登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Golang笔记之Redis

Golang笔记之Redis

高小雨 2025-8-6 19:40:08
本文首发于公众号：Hunter后端
原文链接：Golang笔记之Redis
这一篇笔记主要介绍 Golang 连接和使用 Redis，以下是本篇笔记目录：

目录

  • 1、安装模块
  • 2、连接 Redis
  • 3、字符串

    • 1. 字符串写入
    • 2. 字符串读取

  • 4、哈希

    • 1. 写入

      • 1) 单字段写入
      • 2) 多字段写入

    • 2. 读取

      • 1) 单字段读取
      • 2) 多字段读取

    • 3. 删除字段
    • 4. 检查字段是否存在

  • 5、列表

    • 1. 数据写入

      • 1) RPush-从列表右边写入
      • 2) LInsert-在指定元素位置前后插入
      • 3) LInsterBefore/LInsterAfter-在指定元素位置前/后插入

    • 2. 数据查看

      • 1) LRange-指定范围查看数据
      • 2) LIndex-指定索引查看数据
      • 3) LLen-查看列表长度

    • 3. 数据删除与修改

      • 1) LPop-弹出最左边的元素
      • 2) LPopCount-从左边弹出指定数量的元素
      • 3) LRem-遍历删除指定个数的指定元素
      • 4) LTrim-按照索引范围修剪列表
      • 5) LSet-指定位置修改元素


  • 6、集合

    • 1. 写入数据
    • 2. 读取数据

      • 1) SMembers-获取集合全部元素
      • 2) SCard-获取集合元素总数
      • 3) SRandMember-随机取出集合中元素
      • 4) SRandMemberN-随机取出集合中 N 个元素

    • 3. 删除元素

      • 1) SRem-移除指定元素
      • 2) SPop-移除随机元素

    • 4. 集合间操作

      • 1) SDiff-集合差集
      • 2) SInter-集合交集
      • 3) SUnion-集合并集


  • 7、有序集合

    • 1. 数据写入
    • 2. 数据查询

      • 1) ZRangeWithScores-返回指定排序范围的分值和元素
      • 2) ZRange-返回指定排序范围的元素
      • 3) ZRangeByScore-返回指定 score 分值范围排序的元素
      • 4) ZScore-返回指定元素的 score
      • 5) ZRank-返回指定元素的排序数
      • 6) ZCard-返回指定 key 的元素总数
      • 7) ZCount-返回 key 指定 score 范围的元素总数

    • 3. 删除操作

      • 1) ZRem-指定元素删除
      • 2) ZRemRangeByScore-删除指定 score 范围内的元素
      • 3) ZRemRangeByRank-删除指定排序范围内的元素
      • 4) ZPopMin-按照 score 从有序集合中弹出指定个数的元素


  • 8、 通用命令

    • 1. Exists-判断 key 是否存在
    • 2. Expire-设置过期时间
    • 3. Del-删除 key
    • 4. TTL-查看过期时间



  • 安装模块
  • 连接 Redis
  • 字符串
  • 哈希
  • 列表
  • 集合
  • 有序集合
  • 通用命令
1、安装模块

首先需要安装一下用到的第三方库：
  1. go get github.com/go-redis/redis/v8
复制代码
2、连接 Redis

接下来连接 Redis 并测试连接情况，如下是代码：
  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  7.     "github.com/go-redis/redis/v8"
  8. )
  10. var ctx = context.Background()
  11.    
  12. func GetRedisClient() *redis.Client {
  13.     redisClient := redis.NewClient(&redis.Options{
  14.         Addr:     "localhost:6379",
  15.         Password: "",
  16.         DB:       0,
  17.     })
  20.     pong, err := redisClient.Ping(ctx).Result()
  21.     if err != nil {
  22.         fmt.Println("连接失败: ", err)
  23.         return nil
  24.     }
  25.     fmt.Println("连接成功: ", pong)
  26.     return redisClient
  27. }
复制代码
3、字符串

1. 字符串写入

字符串写入 Redis 的操作如下：
  1. redisClient.Set(ctx, key, value, expire)
复制代码
ctx 是 context 上下文，key 和 value 是需要设置的键和值，expire 是一个 time.Duration 类型，表示过期时间，如果设为小于等于 0 则表示永不过期。
下面是字符串写入 Redis 的使用示例：
  1. func SetString(redisClient *redis.Client, ctx context.Context, key, value string, expire time.Duration) error {
  2.     err := redisClient.Set(ctx, key, value, expire).Err()
  3.     if err != nil {
  4.         fmt.Println("设置失败: ", err)
  5.         return err
  6.     }
  7.     fmt.Println("设置成功")
  8.     return nil
  9. }
  11. func main(){
  12.     redisClient := GetRedisClient()
  13.     defer redisClient.Close()
  14.     ctx := context.Background()
  15.     key := "test_key"
  16.     value := "test_value"
  17.     err := SetString(redisClient, ctx, key, value, 10*time.Second)
  18.     if err != nil {
  19.         fmt.Printf("key:%s set value:%s, error:%v\n", key, value, err)
  20.     }
  21. }
复制代码
2. 字符串读取

从 Redis 中读取字符串的操作如下：
  1. val, err := redisClient.Get(ctx, key).Result()
复制代码
其中，val 为返回的值，err 表示读取过程中是否有错误。
这里需要注意下，如果对应的 key 没有值，也会返回 error，其结果是 redis.Nil，可以做一下单独的判断处理。
下面是一个使用示例：
  1. func main(){
  2.     redisClient := GetRedisClient()
  3.     ctx := context.Background()
  4.     key := "test_key"
  6.     val, err := redisClient.Get(ctx, key).Result()
  7.     if err != nil {
  8.         if err == redis.Nil {
  9.             fmt.Printf("key:%s, has no value\n", key)
  10.         } else {
  11.             fmt.Printf("get key:%s, error: %v\n", key, err)
  12.         }
  13.     }
  14.     fmt.Printf("key:%s, value:%s\n", key, val)
  15. }
复制代码
4、哈希

1. 写入

1) 单字段写入

哈希类型的数据单个字段写入的操作如下：
  1. val, err := redisClient.HSet(ctx, key, field, value).Result()
复制代码
这里返回的 val 类型是 int64，值表示设置成功写入的数量，HSet() 方法这里介绍的是单字段写入，后面再介绍多字段写入。
使用代码示例如下：
  1. func HSetField(redisClient *redis.Client, ctx context.Context, key, field, value string) {
  2.     val, err := redisClient.HSet(ctx, key, field, value).Result()
  3.     if err != nil {
  4.         fmt.Println("哈希单个字段设置错误: ", err)
  5.     } else {
  6.         if val == 1 {
  7.             fmt.Println("哈希单个字段设置成功：", val)
  8.         } else {
  9.             fmt.Println("哈希单个字段更新成功：", val)
  10.         }
  11.     }
  12. }
  14. func main() {
  15.     redisClient := GetRedisClient()
  16.     defer redisClient.Close()
  18.     ctx := context.Background()
  19.     key := "test_hash_key"
  21.     HSetField(redisClient, ctx, key, "field1", "value1")
  22. }
复制代码
2) 多字段写入

多字段写入可以使用 HMSet() 操作，但 HSet() 也支持多字段写入。
HMSet() 操作是一个已弃用的版本，为了兼容 Redis 3 版本。
而 HSet() 操作只有 Redis 4 及以上才支持多字段的写入。
使用 HMSet() 的代码的几种操作如下：
  1. // 操作 1
  2. val, err := redisClient.HMSet(ctx, key, "field1", "value1", "field2", "value2").Result()
  4. // 操作2
  5. field_value_slice := []string{"field1", "value1", "field2", "value2"}
  6. val, err := redisClient.HMSet(ctx, key, field_value_slice).Result()
  8. // 操作3
  9. m := map[string]interface{}{"field1": "value1", "field2": "value2"}
  10. val, err := redisClient.HMSet(ctx, key, m).Result()
复制代码
这里支持输入的操作包括直接使用多个字符串，切片和 map，返回的结果 val 是 bool 类型，表示是否设置成功。
而 HSet() 支持的参数与 HMSet() 完全相同，但是返回的 val 是一个 int64，表示成功写入的字段数量。
以下是 HSet() 的操作示例：
  1. // 操作 1
  2. val, err := redisClient.HSet(ctx, key, "field1", "value1", "field2", "value2").Result()
  4. // 操作2
  5. field_value_slice := []string{"field1", "value1", "field2", "value2"}
  6. val, err := redisClient.HSet(ctx, key, field_value_slice).Result()
  8. // 操作3
  9. m := map[string]interface{}{"field1": "value1", "field2": "value2"}
  10. val, err := redisClient.HSet(ctx, key, m).Result()
复制代码
这里返回的 val 是 int64 类型，表示成功写入数据的数量，如果更新字段，字段数量不会计入。
2. 读取

1) 单字段读取

哈希数据单个字段的读取用 HGet() 操作：
  1. val, err := redisClient.HGet(ctx, key, field).Result()
复制代码
获取的 val 就是对应字段的值。
这里有两种特殊情况，一种是 key 不存在，一种是 field 不存在。
key 或者 field 不存在和之前的字符串读取的 err 的值一样，是 redis.Nil。
代码操作示例如下：
  1. func HGetField(redisClient *redis.Client, ctx context.Context, key, field string) {
  2.     val, err := redisClient.HGet(ctx, key, field).Result()
  3.     if err != nil {
  4.         if err == redis.Nil {
  5.             fmt.Println("key 或者 field 不存在")
  6.         } else {
  7.             fmt.Println("哈希单个字段获取错误: ", err)
  8.         }
  9.     } else {
  10.         fmt.Println("哈希单个字段获取成功：", val)
  11.     }
  12.     fmt.Printf("%T, %v\n", val, val)
  13. }
  15. func main() {
  16.     redisClient := GetRedisClient()
  17.     defer redisClient.Close()
  19.     ctx := context.Background()
  20.     key := "test_hash_key"
  22.     HGetField(redisClient, ctx, key, "field1")
  23. }
复制代码
2) 多字段读取

获取多个字段值
指定多个字段读取哈希数据用 HMGet() 操作，需要读取的多个 field 可以直接作为参数加在后面，也可以使用切片传入：
  1. val, err := redisClient.HMGet(ctx, key, "field1", "field2", "field3", "field4").Result()
  3. fields := []string{"field1", "field2", "field3", "field14"}
  4. val, err := redisClient.HMGet(ctx, key, fields...).Result()
复制代码
其返回的 val 是一个 []interface 结构，其中每个元素都是对应的 field 的 value，比如上面的操作结果如下：
  1. [value11 value12 value2 <nil>]
复制代码
对应的 field 没有 value 的话，其值就是 nil。
在获取对应的 value 进行处理的时候需要转一下：
  1. val[0].(string)
复制代码
获取全部字段和值
如果想获取 key 下全部的 field 和对应的 value，可以使用 HGetAll()，其操作如下：
  1. val := redisClient.HGetAll(ctx, key).Val()
复制代码
返回的 val 类型是 map[string]string：
  1. fmt.Println(val)
  2. // map[field1:value11 field2:value12 field3:value2]
复制代码
获取全部字段
获取哈希数据下全部的 field 的操作如下：
  1. fieldSlice := redisClient.HKeys(ctx, key).Val()
复制代码
返回的数据是一个字符串切片 []string，如果对应的 key 没有数据，返回的结果是空的字符串切片。
获取全部值
获取哈希数据下全部 field 对应的 value 的操作如下：
  1. valueSlice := redisClient.HVals(ctx, key).Val()
复制代码
返回的数据是一个字符串切片 []string，如果 key 下没有数据，返回的结果是空的字符串切片。
获取字段长度
获取哈希数据下有多少个 field 的操作如下：
  1. fieldLength := redisClient.HLen(ctx, key).Val()
复制代码
返回的结果是一个 int64 类型。
3. 删除字段

如果要删除哈希数据下某一个或多个 field，可以使用 HDel() 方法。
  1. // 删除一个 field
  2. val := redisClient.HDel(ctx, key, "field1").Val()
  4. // 删除多个 field
  5. val := redisClient.HDel(ctx, key, "field1", "field2", "field3").Val()
  7. // 删除多个 field
  8. fieldSlice := []string{"field1", "field2"}
  9. val := redisClient.HDel(ctx, key, fieldSlice...).Val()
复制代码
返回的 val 是 int64 类型，表示删除了多少个 field。
4. 检查字段是否存在

HExists() 方法可以用于检测某个字段是否存在。
  1. val := redisClient.HExists(ctx, key, "field1").Val()
复制代码
返回的结果是一个 bool 型，表示是否存在。
5、列表

1. 数据写入

1) RPush-从列表右边写入

RPush() 方法支持从列表右边写入一个或多个数据，使用示例如下：
  1. // 右边推入一条数据
  2. res := redisClient.RPush(ctx, key, "a").Val()
  4. // 右边推入多条数据
  5. res := redisClient.RPush(ctx, key, "a", "b", "c").Val()
  7. // slice 形式推入多条数据
  8. stringSlice := []string{"a", "b", "c"}
  9. res := redisClient.RPush(ctx, key, stringSlice).Val()
复制代码
返回的结果是一个 int64 类型，表示数据推入列表后，列表当前一共有多少个元素。
如果是从左边推入，则使用对应的 LPush() 方法。
注意： 这里需要注意一下从左边推入和右边推入的元素顺序，比如通用的是 ["a", "b", "c"]，从右边推入的结果是 ["a", "b", "c"]，但是从左边推入的结果是 ["c", "b", "a"]
还有个 LPushX 和 RPushX 方法，表示仅当有 key 这个列表的时候可以写入数据，如果 key 不存在，则不会写入数据。
2) LInsert-在指定元素位置前后插入

LInsert() 方法支持在指定元素的前后插入一条数据，比如原始的列表数据是 ["a", "b", "c"]，想要元素 b 前面插入一个元素，其操作如下：
  1. res := redisClient.LInsert(ctx, key, "before", "b", "before_b").Val()
复制代码
插入成功后列表的元素就会变成 ["a", "before_b", "b", "c"]。
LInsert() 方法的第三个参数是可选的，可选值有 before 和 after 分别表示在指定元素的前面还是后面插入。
第四个参数是指定的元素，第五个参数是需要插入的元素。
方法的返回值是个 int64，表示插入成功后当前列表的元素总数。
而如果第四个参数指定的元素不存在，那么将找不到插入的位置，则会插入失败，返回的 res 的值就会是 -1，可以通过这个返回值监控是否插入成功。
3) LInsterBefore/LInsterAfter-在指定元素位置前/后插入

LInsterBefore() 和 LInsterAfter() 则是 LInsert() 方法的指定版本，直接在方法层面确认了在指定元素前还是后插入元素。
比如在元素 c 前插入元素：
  1. res := redisClient.LInsertBefore(ctx, key, "c", "before_c").Val()
复制代码
返回的 res 是 int64，表示插入后当前列表的元素总和。
而如果指定的元素不存在，则会返回 -1。
2. 数据查看

1) LRange-指定范围查看数据

可以通过 LRange() 方法指定索引的范围来查看列表数据：
  1. valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()
复制代码
输入的参数后两个为开始和结束索引，上面这个示例表示获取从 0 到 1 的闭区间列表数据。
返回两个值，valueSlice 是一个字符串切片，err 表示返回的错误
下面是使用示例：
  1. valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()
  2. if err != nil {
  3.     fmt.Println("error: ", err)
  4. } else {
  5.     fmt.Printf("%T, %v\n", valueSlice, valueSlice)
  6. }
复制代码
与之前的获取逻辑不太一样的地方是，如果 key 对应的列表数据不存在，err 值还是为 nil，只是返回的 valueSlice 是一个长度为 0 的字符串切片。
如果结束位置的索引大于列表的长度，也不会报错，而是会返回全部的列表数据。
而如果我们直接想获取全部的列表数据，可以把结束位置的索引值变成 -1：
  1. valueSlice, err := redisClient.LRange(ctx, key, 0, -1).Result()
复制代码
2) LIndex-指定索引查看数据

使用示例如下：
  1. value, err := redisClient.LIndex(ctx, key, 1).Result()
复制代码
返回的结果 value 为指定位置的元素。
LIndex() 方法支持负数索引，比如想获取倒数第二个元素可以如下操作：
  1. value, err := redisClient.LIndex(ctx, key, -1).Result()
复制代码
而如果指定的索引位置超出了列表的长度，则 err 信息会是 redis.Nil，下面是操作示例：
  1. value, err := redisClient.LIndex(ctx, key, 8).Result()
  2. if err != nil {
  3.     if err == redis.Nil {
  4.         fmt.Println("索引位置的结果不存在")
  5.     } else {
  6.         fmt.Println("error: ", err)
  7.     }
  8. } else {
  9.     fmt.Printf("%T, %v\n", value, value)
  10. }
复制代码
3) LLen-查看列表长度

使用示例如下：
  1. value := redisClient.LLen(ctx, key).Val()
复制代码
返回的结果是一个 int64，表示列表长度，而过 key 不存在，则会返回 0。
3. 数据删除与修改

1) LPop-弹出最左边的元素

LPop() 方法的作用是弹出最左边的元素，操作示例如下：
  1. val, err := redisClient.LPop(ctx, key).Result()
复制代码
其中 val 是弹出的元素，是 string 类型。
如果列表已经为空，err 的值就是 redis.Nil。
同理，如果是想弹出最右边的元素，可以使用 RPop() 方法。
2) LPopCount-从左边弹出指定数量的元素

使用示例如下：
  1. val, err := redisClient.LPopCount(ctx, key, 5).Result()
复制代码
返回的 val 是一个 []string，如果指定的 count，也就是第三个参数大于列表中的元素个数，则会将元素全部弹出。
如果列表中已经没有元素可以弹出了，err 的值是 redis.Nil。
3) LRem-遍历删除指定个数的指定元素

其操作方法如下：
  1. val, err := redisClient.LRem(ctx, key, 2, "c").Result()
复制代码
上面的操作表示从列表左边开始删除 key 对应的列表中两个元素为 c 的元素，返回的 val 表示实际删除的个数。
如果我们想删除全部指定元素，可以将第三个参数设置为 0：
  1. val, err := redisClient.LRem(ctx, key, 0, "c").Result()
复制代码
上面的操作表示删除列表中全部元素为 c 的数据。
4) LTrim-按照索引范围修剪列表

操作代码如下：
  1. val, err := redisClient.LTrim(ctx, key, 0, 2).Result()
复制代码
上面的操作表示只保留列表中 0 到 2 的索引的三个元素，返回的 val 是 string 类型，内容为 OK 表示修剪成功。
5) LSet-指定位置修改元素

LSet() 方法表示修改指定位置的元素内容，比如需要修改索引为 1 的元素内容：
  1. val, err := redisClient.LSet(ctx, key, 1, "index_1_change").Result()
复制代码
返回的 val 是个字符串，内容 OK 表示修改成功，如果指定的索引超出了原有列表的范围，则会返回 err。
6、集合

1. 写入数据

往一个集合中写入的方法是 SAdd()，可以往里面写入单个或者多个元素：
  1. // 写入单个元素
  2. val := redisClient.SAdd(ctx, key, "a").Val()
  4. // 写入多个元素
  5. stringSlice := []string{"d", "e"}
  6. val := redisClient.SAdd(ctx, key, stringSlice).Val()
复制代码
返回的结果 val 是 int64，表示写入的元素个数，如果元素之前已经在集合，则不会计入其中。
2. 读取数据

1) SMembers-获取集合全部元素

使用代码如下：
  1. res, err := redisClient.SMembers(ctx, key).Result()
复制代码
返回的 res 是一个 []string，内容为集合的全部元素。
如果 key 对应的集合不存在，返回的 res 为空切片。
2) SCard-获取集合元素总数

使用代码如下：
  1. res, err := redisClient.SCard(ctx, key).Result()
复制代码
返回的 res 类型是 int64，内容是 key 对应的集合的元素总数。
如果 key 对应的集合不存在，返回的 res 结果是 0。
3) SRandMember-随机取出集合中元素

使用代码如下：
  1. res, err := redisClient.SRandMember(ctx, key).Result()
  2. if err == redis.Nil {
  3.     fmt.Printf("key:%s 对应的集合不存在\n", key)
  4. }
复制代码
返回的 res 是集合中随机一个元素。
如果 key 对应的集合不存在，返回 err 的值是 redis.Nil。
4) SRandMemberN-随机取出集合中 N 个元素

使用代码如下：
  1. res, err := redisClient.SRandMemberN(ctx, key, 3).Result()
复制代码
上面的代码表示从集合中随机取出 3 个元素，返回的 res 是 []string。
如果 key 对应的集合不存在，返回的是一个空切片，err 为 nil。
如果指定返回的元素个数大于集合总个数，则会返回全部集合元素。
3. 删除元素

1) SRem-移除指定元素

SRem() 方法可以用于移除指定的一个多个元素，使用示例如下：
  1. // 删除一个指定元素
  2. res, err := redisClient.SRem(ctx, key, "a").Result()
  4. // 删除多个指定元素
  5. res, err := redisClient.SRem(ctx, key, "a", "b").Result()
  7. stringSlice := []string{"a", "b"}
  8. res, err := redisClient.SRem(ctx, key, stringSlice).Result()
复制代码
返回的结果 res 是一个 int64，表示移除的元素个数。
2) SPop-移除随机元素

SPop() 方法用于随机移除集合中的元素。
  1. res, err := redisClient.SPop(ctx, key).Result()
复制代码
res 是返回的移除的元素。
而 SPopN() 用于移除 N 个随机元素：
  1. res, err := redisClient.SPopN(ctx, key, 2).Result()
复制代码
返回的 res 是一个 []string。
4. 集合间操作

1) SDiff-集合差集

SDiff() 方法用于求取集合之间的差集，使用示例如下：
  1. redisClient.SAdd(ctx, "s1", "a", "b", "c")
  2. redisClient.SAdd(ctx, "s2", "a")
  4. res, err := redisClient.SDiff(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的差集。
SDiffStore() 可以将集合间的差集存储到一个新的 key 中，使用方法如下：
  1. redisClient.SDiffStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的差集存储到 s3 中。
2) SInter-集合交集

SInter() 方法用于求取集合之间的交集，使用示例如下：
  1. redisClient.SAdd(ctx, "s1", "a", "b", "c")
  2. redisClient.SAdd(ctx, "s2", "a")
  4. res, err := redisClient.SInter(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的交集。
SInterStore() 可以将集合间的交集存储到一个新的 key 中，使用方法如下：
  1. redisClient.SInterStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的交集存储到 s3 中。
3) SUnion-集合并集

SUnion() 方法用于求取集合之间的并集，使用示例如下：
  1. redisClient.SAdd(ctx, "s1", "a", "b", "c")
  2. redisClient.SAdd(ctx, "s2", "a", "e")
  4. res, err := redisClient.SUnion(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的并集。
SUnionStore() 可以将集合间的并集存储到一个新的 key 中，使用方法如下：
  1. redisClient.SUnionStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的并集存储到 s3 中。
7、有序集合

1. 数据写入

有序集合数据的写入可以使用 ZAdd()，使用的示例如下：
  1. res, err := redisClient.ZAdd(ctx, key, &redis.Z{Score: 100, Member: "Golang"}).Result()
复制代码
输入的第三个参数是 redis.Z 类型，其结构如下：
  1. type Z struct {
  2.     Score  float64
  3.     Member interface{}
  4. }
复制代码
Score 是元素用于排序的分数，Member 是有序集合的元素。
除了单个元素，还可以写入多个元素：
  1. zList := []*redis.Z{
  2.     {Score: 101, Member: "Golang"},
  3.     {Score: 221, Member: "Python"},
  4.     {Score: 445, Member: "Java"},
  5. }
  6. res, err := redisClient.ZAdd(ctx, key, zList...)
复制代码
返回的 res 类型是 int64，表示插入数据的个数。
2. 数据查询

1) ZRangeWithScores-返回指定排序范围的分值和元素

ZRangeWithScores() 方法用于返回指定排序范围的分值和元素，比如需要返回前三位的数据，使用示例如下：
  1. res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()
  2. for _, item := range res1 {
  3.     fmt.Printf("score:%f, member:%s\n", item.Score, item.Member)
  4. }
复制代码
其返回的 res1 类型是 []Z，数据按照 score 从小到大排列。
如果想要获取有序集合中全部元素，可以将指定的范围写成 0 和 -1：
  1. res1, err := redisClient.ZRangeWithScores(ctx, key, 0, -1).Result()
复制代码
通过，有一个逆序方法 ZRevRangeWithScores()，比如获取从最后往前三位的数据：
  1. res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()
复制代码
2) ZRange-返回指定排序范围的元素

ZRange() 方法用于返回指定排序范围的元素，，比如需要返回前三位的数据，使用示例如下：
  1. res1, err := redisClient.ZRange(ctx, key, 0, 2).Result()
复制代码
返回的 res1 类型是 []string，元素是有序集合的元素，按照 score 从小到大排列。
如果想要获取有序集合中全部元素，可以将指定的范围写成 0 和 -1。
同理，有一个逆序的获取方法 ZRevRange()，比如获取从最后往前三位的数据，操作如下：
  1. res1, err := redisClient.ZRevRange(ctx, key, 0, 2).Result()
复制代码
3) ZRangeByScore-返回指定 score 分值范围排序的元素

ZRangeByScore 传入的参数是 redis.ZRangeBy，其数据结构如下：
  1. type ZRangeBy struct {
  2.     Min, Max      string
  3.     Offset, Count int64
  4. }
复制代码
Min 和 Max 表示 score 分值的范围，如果想获取这个范围内的全部元素，Offset 和 Count 参数置为 0 即可。
如果想要获取类似分页的操作，可以对 Offset 和 Count 进行赋值，Count 表示需要获取的总数，Offset 表示从 Min 开始的偏移量。
使用示例如下：
  1. zRangeBy := &redis.ZRangeBy{
  2.     Min: "1",
  3.     Max: "500",
  4. }
  5. res1, err := redisClient.ZRangeByScore(ctx, key, zRangeBy).Result()
复制代码
上面的示例表示获取 key 对应的有序集合 score 从 1 到 500 之间的全部元素，返回的 res1 类型是 []string。
其对应的逆序获取方法为 ZRevRangeByScore()，操作示例如下：
  1. res1, err := redisClient.ZRevRangeByScore(ctx, key, zRangeBy).Result()
复制代码
4) ZScore-返回指定元素的 score

使用示例如下：
  1. elementName := "Golang"
  2. res1, err := redisClient.ZScore(ctx, key, elementName).Result()
  3. if err != nil {
  4.     if err == redis.Nil {
  5.         fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName)
  6.     } else {
  7.         fmt.Println("err: ", err)
  8.     }
  9. } else {
  10.     fmt.Printf("key:%s, 元素:%s 的分值是%f\n", key, elementName, res1)
  11. }
复制代码
返回的 res1 类型是 float64，表示指定元素的 score，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。
另一个方法 ZMScore() 可以获取多个指定元素的 score：
  1. elementSlice := []string{"Golang", "Python"}
  2. res1, err := redisClient.ZMScore(ctx, key, elementSlice...).Result()
复制代码
返回的 res1 是一个 []float64，返回的是对应的 elementSlice 对应位置元素的 score。
如果元素不存在，则对应的位置会返回 0。
5) ZRank-返回指定元素的排序数

使用代码示例如下：
  1. elementName := "Golang"
  2. res1, err := redisClient.ZRank(ctx, key, elementName).Result()
  3. if err != nil {
  4.     if err == redis.Nil {
  5.         fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName)
  6.     } else {
  7.         fmt.Println("err: ", err)
  8.     }
  9. } else {
  10.     fmt.Printf("key:%s, 元素:%s 的排序是%d\n", key, elementName, res1)
  11. }
复制代码
返回的 res1 类型是 int64，表示指定元素的排序数，排序数从 0 开始，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。
ZRevRank() 方法表示逆序获取，使用方法和 ZRank() 方法一致：
  1. res1, err := redisClient.ZRevRank(ctx, key, elementName).Result()
复制代码
6) ZCard-返回指定 key 的元素总数

使用示例如下：
  1. res1, err := redisClient.ZCard(ctx, key).Result()
复制代码
ZCard() 方法返回指定 key 的元素总数，res1 类型是 int64，表示指定 key 的元素总数。
如果对应的 key 不存在，结果为 0，err 为 nil。
7) ZCount-返回 key 指定 score 范围的元素总数

使用示例如下：
  1. res1, err := redisClient.ZCount(ctx, key, "1", "4").Result()
复制代码
ZCount() 方法输入的第三、四个参数是 score 分值的最小和最大值，类型是字符串。
返回的 res1 类型是 int64，如果 key 不存在，结果为 0。
3. 删除操作

1) ZRem-指定元素删除

ZRem() 方法用于有序集合指定元素删除操作，可以删除一个或多个元素：
  1. res1, err := redisClient.ZRem(ctx, key, []string{"Java", "Golang"}).Result()
复制代码
返回的 res1 类型是 int64，表示删除的元素个数。
2) ZRemRangeByScore-删除指定 score 范围内的元素

ZRemRangeByScore() 方法用于删除指定 score 范围内的元素，第三、四个参数是有序集合的 score 的最小值和最大值，类型是 string，使用示例如下：
  1. res1, err := redisClient.ZRemRangeByScore(ctx, key, "0", "23").Result()
复制代码
上述示例表示删除指定 key 的 score 在 0 到 23 之间的闭区间的元素，res1 类型是 int64，表示删除的元素个数。
3) ZRemRangeByRank-删除指定排序范围内的元素

ZRemRangeByRank() 方法用于删除指定排序范围内的元素，第三、四个参数是有序集合的排序位的范围，类型是 int64，比如向删除有序集合排在前两位的数据，操作如下：
  1. res1, err := redisClient.ZRemRangeByRank(ctx, key, 0, 1).Result()
复制代码
返回的 res1 类型是 int64，表示删除的元素个数。
4) ZPopMin-按照 score 从有序集合中弹出指定个数的元素

如果想按照 score 从小到大排列，弹出某个有序集合中排在前两位的元素，操作如下：
  1. res1, err := redisClient.ZPopMin(ctx, key, 2).Result()
  2. for _, item := range res1 {
  3.     fmt.Println(item.Score, item.Member)
  4. }
复制代码
返回的 res1 类型是 []Z。
而如果想按照 score 从大到小排列并弹出指定个数的元素，可以使用 ZPopMax() 方法，使用方式与 ZPopMin() 方法一致。
8、 通用命令

1. Exists-判断 key 是否存在

Exists() 方法用于判断指定 key 是否存在，使用示例如下：
  1. res, err := redisClient.Exists(ctx, "a").Result()
复制代码
返回的 res 类型是 int64，如果指定 key 存在，则 res 为 1，否则为 0。
2. Expire-设置过期时间

Expire() 方法用于给指定 key 设置过期时间，使用示例如下：
  1. res1, err := redisClient.Expire(ctx, key, 20*time.Minute).Result()
复制代码
返回的 res1 类型是 bool，如果 key 存在且设置过期时间成功，返回的 res1 为 true，否则为 false。
3. Del-删除 key

Del() 方法用于删除一个或多个 key，使用示例如下：
  1. // 删除一个 key
  2. res1, err := redisClient.Del(ctx, "d").Result()
  4. // 删除多个 key
  5. res1, err := redisClient.Del(ctx, []string{"a", "b", "c"}...).Result()
复制代码
返回的 res1 类型是 int64，表示删除的 key 的个数。
4. TTL-查看过期时间

TTL() 方法用于查看指定 key 的过期时间，使用示例如下：
  1. res1, err := redisClient.TTL(ctx, "a").Result()
  2. if err != nil {
  3.     fmt.Println("error: ", err)
  4.     return
  5. }
  6. if res1 == -1 {
  7.     fmt.Println("指定 key 永不过期")
  8. } else if res1 == -2 {
  9.     fmt.Println("指定 key 不存在")
  10. } else {
  11.     fmt.Println("key 在指定时间后过期: ", res1)
  12. }
复制代码
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
高小雨
2025-8-6 19:40:08

0

粉丝关注

21

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫