本文首发于公众号：Hunter 后端
原文链接：Golang笔记之Redis
这一篇笔记主要介绍 Golang 连接和使用 Redis，以下是本篇笔记目录：
安装模块
连接 Redis
字符串
哈希
列表
集合
有序集合
通用命令
1、安装模块
首先需要安装一下用到的第三方库：
go get github.com/go-redis/redis/v8
复制代码
2、连接 Redis
接下来连接 Redis 并测试连接情况，如下是代码：
package main
import ( "context" "fmt"
"github.com/go-redis/redis/v8")
var ctx = context.Background() func GetRedisClient() *redis.Client { redisClient := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", DB: 0, })
pong, err := redisClient.Ping(ctx).Result() if err != nil { fmt.Println("连接失败: ", err) return nil } fmt.Println("连接成功: ", pong) return redisClient}
复制代码
3、字符串
1. 字符串写入
字符串写入 Redis 的操作如下：
redisClient.Set(ctx, key, value, expire)
复制代码
ctx 是 context 上下文，key 和 value 是需要设置的键和值，expire 是一个 time.Duration 类型，表示过期时间，如果设为小于等于 0 则表示永不过期。
下面是字符串写入 Redis 的使用示例：
func SetString(redisClient *redis.Client, ctx context.Context, key, value string, expire time.Duration) error { err := redisClient.Set(ctx, key, value, expire).Err() if err != nil { fmt.Println("设置失败: ", err) return err } fmt.Println("设置成功") return nil}
func main(){ redisClient := GetRedisClient() defer redisClient.Close() ctx := context.Background() key := "test_key" value := "test_value" err := SetString(redisClient, ctx, key, value, 10*time.Second) if err != nil { fmt.Printf("key:%s set value:%s, error:%v\n", key, value, err) }}
复制代码
2. 字符串读取
从 Redis 中读取字符串的操作如下：
val, err := redisClient.Get(ctx, key).Result()
复制代码
其中，val 为返回的值，err 表示读取过程中是否有错误。
这里需要注意下，如果对应的 key 没有值，也会返回 error，其结果是 redis.Nil，可以做一下单独的判断处理。
下面是一个使用示例：
func main(){ redisClient := GetRedisClient() ctx := context.Background() key := "test_key"
val, err := redisClient.Get(ctx, key).Result() if err != nil { if err == redis.Nil { fmt.Printf("key:%s, has no value\n", key) } else { fmt.Printf("get key:%s, error: %v\n", key, err) } } fmt.Printf("key:%s, value:%s\n", key, val)}
复制代码
4、哈希
1. 写入
1) 单字段写入
哈希类型的数据单个字段写入的操作如下：
val, err := redisClient.HSet(ctx, key, field, value).Result()
复制代码
这里返回的 val 类型是 int64，值表示设置成功写入的数量，HSet() 方法这里介绍的是单字段写入，后面再介绍多字段写入。
使用代码示例如下：
func HSetField(redisClient *redis.Client, ctx context.Context, key, field, value string) { val, err := redisClient.HSet(ctx, key, field, value).Result() if err != nil { fmt.Println("哈希单个字段设置错误: ", err) } else { if val == 1 { fmt.Println("哈希单个字段设置成功：", val) } else { fmt.Println("哈希单个字段更新成功：", val) } }}
func main() { redisClient := GetRedisClient() defer redisClient.Close()
ctx := context.Background() key := "test_hash_key"
HSetField(redisClient, ctx, key, "field1", "value1")}
复制代码
2) 多字段写入
多字段写入可以使用 HMSet() 操作，但 HSet() 也支持多字段写入。
HMSet() 操作是一个已弃用的版本，为了兼容 Redis 3 版本。
而 HSet() 操作只有 Redis 4 及以上才支持多字段的写入。
使用 HMSet() 的代码的几种操作如下：
// 操作 1val, err := redisClient.HMSet(ctx, key, "field1", "value1", "field2", "value2").Result()
// 操作2field_value_slice := []string{"field1", "value1", "field2", "value2"}val, err := redisClient.HMSet(ctx, key, field_value_slice).Result()
// 操作3m := map[string]interface{}{"field1": "value1", "field2": "value2"}val, err := redisClient.HMSet(ctx, key, m).Result()
复制代码
这里支持输入的操作包括直接使用多个字符串，切片和 map，返回的结果 val 是 bool 类型，表示是否设置成功。
而 HSet() 支持的参数与 HMSet() 完全相同，但是返回的 val 是一个 int64，表示成功写入的字段数量。
以下是 HSet() 的操作示例：
// 操作 1val, err := redisClient.HSet(ctx, key, "field1", "value1", "field2", "value2").Result()
// 操作2field_value_slice := []string{"field1", "value1", "field2", "value2"}val, err := redisClient.HSet(ctx, key, field_value_slice).Result()
// 操作3m := map[string]interface{}{"field1": "value1", "field2": "value2"}val, err := redisClient.HSet(ctx, key, m).Result()
复制代码
这里返回的 val 是 int64 类型，表示成功写入数据的数量，如果更新字段，字段数量不会计入。
2. 读取
1) 单字段读取
哈希数据单个字段的读取用 HGet() 操作：
val, err := redisClient.HGet(ctx, key, field).Result()
复制代码
获取的 val 就是对应字段的值。
这里有两种特殊情况，一种是 key 不存在，一种是 field 不存在。
key 或者 field 不存在和之前的字符串读取的 err 的值一样，是 redis.Nil。
代码操作示例如下：
func HGetField(redisClient *redis.Client, ctx context.Context, key, field string) { val, err := redisClient.HGet(ctx, key, field).Result() if err != nil { if err == redis.Nil { fmt.Println("key 或者 field 不存在") } else { fmt.Println("哈希单个字段获取错误: ", err) } } else { fmt.Println("哈希单个字段获取成功：", val) } fmt.Printf("%T, %v\n", val, val)}
func main() { redisClient := GetRedisClient() defer redisClient.Close()
ctx := context.Background() key := "test_hash_key"
HGetField(redisClient, ctx, key, "field1")}
复制代码
2) 多字段读取
获取多个字段值
指定多个字段读取哈希数据用 HMGet() 操作，需要读取的多个 field 可以直接作为参数加在后面，也可以使用切片传入：
val, err := redisClient.HMGet(ctx, key, "field1", "field2", "field3", "field4").Result()
fields := []string{"field1", "field2", "field3", "field14"}val, err := redisClient.HMGet(ctx, key, fields...).Result()
复制代码
其返回的 val 是一个 []interface 结构，其中每个元素都是对应的 field 的 value，比如上面的操作结果如下：
[value11 value12 value2 <nil>]
复制代码
对应的 field 没有 value 的话，其值就是 nil。
在获取对应的 value 进行处理的时候需要转一下：
获取全部字段和值
如果想获取 key 下全部的 field 和对应的 value，可以使用 HGetAll()，其操作如下：
val := redisClient.HGetAll(ctx, key).Val()
复制代码
返回的 val 类型是 map[string]string：
fmt.Println(val)// map[field1:value11 field2:value12 field3:value2]
复制代码
获取全部字段
获取哈希数据下全部的 field 的操作如下：
fieldSlice := redisClient.HKeys(ctx, key).Val()
复制代码
返回的数据是一个字符串切片 []string，如果对应的 key 没有数据，返回的结果是空的字符串切片。
获取全部值
获取哈希数据下全部 field 对应的 value 的操作如下：
valueSlice := redisClient.HVals(ctx, key).Val()
复制代码
返回的数据是一个字符串切片 []string，如果 key 下没有数据，返回的结果是空的字符串切片。
获取字段长度
获取哈希数据下有多少个 field 的操作如下：
fieldLength := redisClient.HLen(ctx, key).Val()
复制代码
返回的结果是一个 int64 类型。
3. 删除字段
如果要删除哈希数据下某一个或多个 field，可以使用 HDel() 方法。
// 删除一个 fieldval := redisClient.HDel(ctx, key, "field1").Val()
// 删除多个 fieldval := redisClient.HDel(ctx, key, "field1", "field2", "field3").Val()
// 删除多个 fieldfieldSlice := []string{"field1", "field2"}val := redisClient.HDel(ctx, key, fieldSlice...).Val()
复制代码
返回的 val 是 int64 类型，表示删除了多少个 field。
4. 检查字段是否存在
HExists() 方法可以用于检测某个字段是否存在。
val := redisClient.HExists(ctx, key, "field1").Val()
复制代码
返回的结果是一个 bool 型，表示是否存在。
5、列表
1. 数据写入
1) RPush-从列表右边写入
RPush() 方法支持从列表右边写入一个或多个数据，使用示例如下：
// 右边推入一条数据res := redisClient.RPush(ctx, key, "a").Val()
// 右边推入多条数据res := redisClient.RPush(ctx, key, "a", "b", "c").Val()
// slice 形式推入多条数据stringSlice := []string{"a", "b", "c"}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 前面插入一个元素，其操作如下：
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 前插入元素：
res := redisClient.LInsertBefore(ctx, key, "c", "before_c").Val()
复制代码
返回的 res 是 int64，表示插入后当前列表的元素总和。
而如果指定的元素不存在，则会返回 -1。
2. 数据查看
1) LRange-指定范围查看数据
可以通过 LRange() 方法指定索引的范围来查看列表数据：
valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()
复制代码
输入的参数后两个为开始和结束索引，上面这个示例表示获取从 0 到 1 的闭区间列表数据。
返回两个值，valueSlice 是一个字符串切片，err 表示返回的错误
下面是使用示例：
valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()if err != nil { fmt.Println("error: ", err)} else { fmt.Printf("%T, %v\n", valueSlice, valueSlice)}
复制代码
与之前的获取逻辑不太一样的地方是，如果 key 对应的列表数据不存在，err 值还是为 nil，只是返回的 valueSlice 是一个长度为 0 的字符串切片。
如果结束位置的索引大于列表的长度，也不会报错，而是会返回全部的列表数据。
而如果我们直接想获取全部的列表数据，可以把结束位置的索引值变成 -1：
valueSlice, err := redisClient.LRange(ctx, key, 0, -1).Result()
复制代码
2) LIndex-指定索引查看数据
使用示例如下：
value, err := redisClient.LIndex(ctx, key, 1).Result()
复制代码
返回的结果 value 为指定位置的元素。
LIndex() 方法支持负数索引，比如想获取倒数第二个元素可以如下操作：
value, err := redisClient.LIndex(ctx, key, -1).Result()
复制代码
而如果指定的索引位置超出了列表的长度，则 err 信息会是 redis.Nil，下面是操作示例：
value, err := redisClient.LIndex(ctx, key, 8).Result()if err != nil { if err == redis.Nil { fmt.Println("索引位置的结果不存在") } else { fmt.Println("error: ", err) }} else { fmt.Printf("%T, %v\n", value, value)}
复制代码
3) LLen-查看列表长度
使用示例如下：
value := redisClient.LLen(ctx, key).Val()
复制代码
返回的结果是一个 int64，表示列表长度，而过 key 不存在，则会返回 0。
3. 数据删除与修改
1) LPop-弹出最左边的元素
LPop() 方法的作用是弹出最左边的元素，操作示例如下：
val, err := redisClient.LPop(ctx, key).Result()
复制代码
其中 val 是弹出的元素，是 string 类型。
如果列表已经为空，err 的值就是 redis.Nil。
同理，如果是想弹出最右边的元素，可以使用 RPop() 方法。
2) LPopCount-从左边弹出指定数量的元素
使用示例如下：
val, err := redisClient.LPopCount(ctx, key, 5).Result()
复制代码
返回的 val 是一个 []string，如果指定的 count，也就是第三个参数大于列表中的元素个数，则会将元素全部弹出。
如果列表中已经没有元素可以弹出了，err 的值是 redis.Nil。
3) LRem-遍历删除指定个数的指定元素
其操作方法如下：
val, err := redisClient.LRem(ctx, key, 2, "c").Result()
复制代码
上面的操作表示从列表左边开始删除 key 对应的列表中两个元素为 c 的元素，返回的 val 表示实际删除的个数。
如果我们想删除全部指定元素，可以将第三个参数设置为 0：
val, err := redisClient.LRem(ctx, key, 0, "c").Result()
复制代码
上面的操作表示删除列表中全部元素为 c 的数据。
4) LTrim-按照索引范围修剪列表
操作代码如下：
val, err := redisClient.LTrim(ctx, key, 0, 2).Result()
复制代码
上面的操作表示只保留列表中 0 到 2 的索引的三个元素，返回的 val 是 string 类型，内容为 OK 表示修剪成功。
5) LSet-指定位置修改元素
LSet() 方法表示修改指定位置的元素内容，比如需要修改索引为 1 的元素内容：
val, err := redisClient.LSet(ctx, key, 1, "index_1_change").Result()
复制代码
返回的 val 是个字符串，内容 OK 表示修改成功，如果指定的索引超出了原有列表的范围，则会返回 err。
6、集合
1. 写入数据
往一个集合中写入的方法是 SAdd()，可以往里面写入单个或者多个元素：
// 写入单个元素val := redisClient.SAdd(ctx, key, "a").Val()
// 写入多个元素stringSlice := []string{"d", "e"}val := redisClient.SAdd(ctx, key, stringSlice).Val()
复制代码
返回的结果 val 是 int64，表示写入的元素个数，如果元素之前已经在集合，则不会计入其中。
2. 读取数据
1) SMembers-获取集合全部元素
使用代码如下：
res, err := redisClient.SMembers(ctx, key).Result()
复制代码
返回的 res 是一个 []string，内容为集合的全部元素。
如果 key 对应的集合不存在，返回的 res 为空切片。
2) SCard-获取集合元素总数
使用代码如下：
res, err := redisClient.SCard(ctx, key).Result()
复制代码
返回的 res 类型是 int64，内容是 key 对应的集合的元素总数。
如果 key 对应的集合不存在，返回的 res 结果是 0。
3) SRandMember-随机取出集合中元素
使用代码如下：
res, err := redisClient.SRandMember(ctx, key).Result()if err == redis.Nil { fmt.Printf("key:%s 对应的集合不存在\n", key)}
复制代码
返回的 res 是集合中随机一个元素。
如果 key 对应的集合不存在，返回 err 的值是 redis.Nil。
4) SRandMemberN-随机取出集合中 N 个元素
使用代码如下：
res, err := redisClient.SRandMemberN(ctx, key, 3).Result()
复制代码
上面的代码表示从集合中随机取出 3 个元素，返回的 res 是 []string。
如果 key 对应的集合不存在，返回的是一个空切片，err 为 nil。
如果指定返回的元素个数大于集合总个数，则会返回全部集合元素。
3. 删除元素
1) SRem-移除指定元素
SRem() 方法可以用于移除指定的一个多个元素，使用示例如下：
// 删除一个指定元素res, err := redisClient.SRem(ctx, key, "a").Result()
// 删除多个指定元素res, err := redisClient.SRem(ctx, key, "a", "b").Result()
stringSlice := []string{"a", "b"}res, err := redisClient.SRem(ctx, key, stringSlice).Result()
复制代码
返回的结果 res 是一个 int64，表示移除的元素个数。
2) SPop-移除随机元素
SPop() 方法用于随机移除集合中的元素。
res, err := redisClient.SPop(ctx, key).Result()
复制代码
res 是返回的移除的元素。
而 SPopN() 用于移除 N 个随机元素：
res, err := redisClient.SPopN(ctx, key, 2).Result()
复制代码
返回的 res 是一个 []string。
4. 集合间操作
1) SDiff-集合差集
SDiff() 方法用于求取集合之间的差集，使用示例如下：
redisClient.SAdd(ctx, "s1", "a", "b", "c")redisClient.SAdd(ctx, "s2", "a")
res, err := redisClient.SDiff(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的差集。
SDiffStore() 可以将集合间的差集存储到一个新的 key 中，使用方法如下：
redisClient.SDiffStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的差集存储到 s3 中。
2) SInter-集合交集
SInter() 方法用于求取集合之间的交集，使用示例如下：
redisClient.SAdd(ctx, "s1", "a", "b", "c")redisClient.SAdd(ctx, "s2", "a")
res, err := redisClient.SInter(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的交集。
SInterStore() 可以将集合间的交集存储到一个新的 key 中，使用方法如下：
redisClient.SInterStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的交集存储到 s3 中。
3) SUnion-集合并集
SUnion() 方法用于求取集合之间的并集，使用示例如下：
redisClient.SAdd(ctx, "s1", "a", "b", "c")redisClient.SAdd(ctx, "s2", "a", "e")
res, err := redisClient.SUnion(ctx, "s1", "s2").Result()
复制代码
返回的 res 是一个 []string，是集合之间的并集。
SUnionStore() 可以将集合间的并集存储到一个新的 key 中，使用方法如下：
redisClient.SUnionStore(ctx, "s3", "s1", "s2")
复制代码
上面的操作表示将 s1 和 s2 之间的并集存储到 s3 中。
7、有序集合
1. 数据写入
有序集合数据的写入可以使用 ZAdd()，使用的示例如下：
res, err := redisClient.ZAdd(ctx, key, &redis.Z{Score: 100, Member: "Golang"}).Result()
复制代码
输入的第三个参数是 redis.Z 类型，其结构如下：
type Z struct { Score float64 Member interface{}}
复制代码
Score 是元素用于排序的分数，Member 是有序集合的元素。
除了单个元素，还可以写入多个元素：
zList := []*redis.Z{ {Score: 101, Member: "Golang"}, {Score: 221, Member: "Python"}, {Score: 445, Member: "Java"},}res, err := redisClient.ZAdd(ctx, key, zList...)
复制代码
返回的 res 类型是 int64，表示插入数据的个数。
2. 数据查询
1) ZRangeWithScores-返回指定排序范围的分值和元素
ZRangeWithScores() 方法用于返回指定排序范围的分值和元素，比如需要返回前三位的数据，使用示例如下：
res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()for _, item := range res1 { fmt.Printf("score:%f, member:%s\n", item.Score, item.Member)}
复制代码
其返回的 res1 类型是 []Z，数据按照 score 从小到大排列。
如果想要获取有序集合中全部元素，可以将指定的范围写成 0 和 -1：
res1, err := redisClient.ZRangeWithScores(ctx, key, 0, -1).Result()
复制代码
通过，有一个逆序方法 ZRevRangeWithScores()，比如获取从最后往前三位的数据：
res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()
复制代码
2) ZRange-返回指定排序范围的元素
ZRange() 方法用于返回指定排序范围的元素，，比如需要返回前三位的数据，使用示例如下：
res1, err := redisClient.ZRange(ctx, key, 0, 2).Result()
复制代码
返回的 res1 类型是 []string，元素是有序集合的元素，按照 score 从小到大排列。
如果想要获取有序集合中全部元素，可以将指定的范围写成 0 和 -1。
同理，有一个逆序的获取方法 ZRevRange()，比如获取从最后往前三位的数据，操作如下：
res1, err := redisClient.ZRevRange(ctx, key, 0, 2).Result()
复制代码
3) ZRangeByScore-返回指定 score 分值范围排序的元素
ZRangeByScore 传入的参数是 redis.ZRangeBy，其数据结构如下：
type ZRangeBy struct { Min, Max string Offset, Count int64}
复制代码
Min 和 Max 表示 score 分值的范围，如果想获取这个范围内的全部元素，Offset 和 Count 参数置为 0 即可。
如果想要获取类似分页的操作，可以对 Offset 和 Count 进行赋值，Count 表示需要获取的总数，Offset 表示从 Min 开始的偏移量。
使用示例如下：
zRangeBy := &redis.ZRangeBy{ Min: "1", Max: "500",}res1, err := redisClient.ZRangeByScore(ctx, key, zRangeBy).Result()
复制代码
上面的示例表示获取 key 对应的有序集合 score 从 1 到 500 之间的全部元素，返回的 res1 类型是 []string。
其对应的逆序获取方法为 ZRevRangeByScore()，操作示例如下：
res1, err := redisClient.ZRevRangeByScore(ctx, key, zRangeBy).Result()
复制代码
4) ZScore-返回指定元素的 score
使用示例如下：
elementName := "Golang"res1, err := redisClient.ZScore(ctx, key, elementName).Result()if err != nil { if err == redis.Nil { fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName) } else { fmt.Println("err: ", err) }} else { fmt.Printf("key:%s, 元素:%s 的分值是%f\n", key, elementName, res1)}
复制代码
返回的 res1 类型是 float64，表示指定元素的 score，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。
另一个方法 ZMScore() 可以获取多个指定元素的 score：
elementSlice := []string{"Golang", "Python"}res1, err := redisClient.ZMScore(ctx, key, elementSlice...).Result()
复制代码
返回的 res1 是一个 []float64，返回的是对应的 elementSlice 对应位置元素的 score。
如果元素不存在，则对应的位置会返回 0。
5) ZRank-返回指定元素的排序数
使用代码示例如下：
elementName := "Golang"res1, err := redisClient.ZRank(ctx, key, elementName).Result()if err != nil { if err == redis.Nil { fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName) } else { fmt.Println("err: ", err) }} else { fmt.Printf("key:%s, 元素:%s 的排序是%d\n", key, elementName, res1)}
复制代码
返回的 res1 类型是 int64，表示指定元素的排序数，排序数从 0 开始，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。
ZRevRank() 方法表示逆序获取，使用方法和 ZRank() 方法一致：
res1, err := redisClient.ZRevRank(ctx, key, elementName).Result()
复制代码
6) ZCard-返回指定 key 的元素总数
使用示例如下：
res1, err := redisClient.ZCard(ctx, key).Result()
复制代码
ZCard() 方法返回指定 key 的元素总数，res1 类型是 int64，表示指定 key 的元素总数。
如果对应的 key 不存在，结果为 0，err 为 nil。
7) ZCount-返回 key 指定 score 范围的元素总数
使用示例如下：
res1, err := redisClient.ZCount(ctx, key, "1", "4").Result()
复制代码
ZCount() 方法输入的第三、四个参数是 score 分值的最小和最大值，类型是字符串。
返回的 res1 类型是 int64，如果 key 不存在，结果为 0。
3. 删除操作
1) ZRem-指定元素删除
ZRem() 方法用于有序集合指定元素删除操作，可以删除一个或多个元素：
res1, err := redisClient.ZRem(ctx, key, []string{"Java", "Golang"}).Result()
复制代码
返回的 res1 类型是 int64，表示删除的元素个数。
2) ZRemRangeByScore-删除指定 score 范围内的元素
ZRemRangeByScore() 方法用于删除指定 score 范围内的元素，第三、四个参数是有序集合的 score 的最小值和最大值，类型是 string，使用示例如下：
res1, err := redisClient.ZRemRangeByScore(ctx, key, "0", "23").Result()
复制代码
上述示例表示删除指定 key 的 score 在 0 到 23 之间的闭区间的元素，res1 类型是 int64，表示删除的元素个数。
3) ZRemRangeByRank-删除指定排序范围内的元素
ZRemRangeByRank() 方法用于删除指定排序范围内的元素，第三、四个参数是有序集合的排序位的范围，类型是 int64，比如向删除有序集合排在前两位的数据，操作如下：
res1, err := redisClient.ZRemRangeByRank(ctx, key, 0, 1).Result()
复制代码
返回的 res1 类型是 int64，表示删除的元素个数。
4) ZPopMin-按照 score 从有序集合中弹出指定个数的元素
如果想按照 score 从小到大排列，弹出某个有序集合中排在前两位的元素，操作如下：
res1, err := redisClient.ZPopMin(ctx, key, 2).Result()for _, item := range res1 { fmt.Println(item.Score, item.Member)}
复制代码
返回的 res1 类型是 []Z。
而如果想按照 score 从大到小排列并弹出指定个数的元素，可以使用 ZPopMax() 方法，使用方式与 ZPopMin() 方法一致。
8、 通用命令
1. Exists-判断 key 是否存在
Exists() 方法用于判断指定 key 是否存在，使用示例如下：
res, err := redisClient.Exists(ctx, "a").Result()
复制代码
返回的 res 类型是 int64，如果指定 key 存在，则 res 为 1，否则为 0。
2. Expire-设置过期时间
Expire() 方法用于给指定 key 设置过期时间，使用示例如下：
res1, err := redisClient.Expire(ctx, key, 20*time.Minute).Result()
复制代码
返回的 res1 类型是 bool，如果 key 存在且设置过期时间成功，返回的 res1 为 true，否则为 false。
3. Del-删除 key
Del() 方法用于删除一个或多个 key，使用示例如下：
// 删除一个 keyres1, err := redisClient.Del(ctx, "d").Result()
// 删除多个 keyres1, err := redisClient.Del(ctx, []string{"a", "b", "c"}...).Result()
复制代码
返回的 res1 类型是 int64，表示删除的 key 的个数。
4. TTL-查看过期时间
TTL() 方法用于查看指定 key 的过期时间，使用示例如下：
res1, err := redisClient.TTL(ctx, "a").Result()if err != nil { fmt.Println("error: ", err) return}if res1 == -1 { fmt.Println("指定 key 永不过期")} else if res1 == -2 { fmt.Println("指定 key 不存在")} else { fmt.Println("key 在指定时间后过期: ", res1)}
复制代码
评论