在本系列上一篇文章中，我们详细介绍了如何使用 go-redis 库来操作 Redis 的 List 列表数据类型。如果你错过了，可以点击这里查看。在本篇文章中，我们将聚焦于 Redis 的另一种强大数据结构：SortedSet（有序集合），并介绍如何使用 go-redis 库进行相关操作。
👉 点击查看 go-redis 使用指南目录
在《go-redis 使用指南》系列文章中，我们将详细介绍如何在 Golang 项目中使用 redis/go-redis 库与 Redis 进行交互。以下是该系列文章的全部内容：
- Golang 操作 Redis：快速上手 - go-redis 使用指南
- Golang 操作 Redis：连接设置与参数详解 - go-redis 使用指南
- Golang 操作 Redis：基础的字符串键值操作 - go-redis 使用指南
- Golang 操作 Redis：如何设置 key 的过期时间 - go-redis 使用指南
- Golang 操作 Redis：Hash 哈希数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：Set 集合数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：为 Hash 中的字段设置过期时间 - go-redis 使用指南
- Golang 操作 Redis：List 列表数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：SortedSet 有序集合数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：bitmap 数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：事务处理操作用法 - go-redis 使用指南
- Golang 操作 Redis：地理空间数据类型操作用法 - go-redis 使用指南
- Golang 操作 Redis：HyperLogLog 操作用法 - go-redis 使用指南
- Golang 操作 Redis：Pipeline 操作用法 - go-redis 使用指南
- Golang 操作 Redis：PubSub发布订阅用法 - go-redis 使用指南
- Golang 操作 Redis：布隆过滤器（Bloom Filter）操作用法 - go-redis 使用指南
- Golang 操作 Redis：Cuckoo Filter操作用法 - go-redis 使用指南
- Golang 操作 Redis：Stream操作用法 - go-redis 使用指南
Redis 有序集合（SortedSet）数据结构简介
Redis 有序集合（SortedSet）是一种集合类型，其中的每个元素都关联一个分数，元素按分数从小到大排序。有序集合非常适合用于排行榜、带权重的数据存储、优先级队列等场景。
常见使用场景:
- 排行榜系统：如游戏积分排行榜、竞赛排名等。
- 带权重的数据存储：如热门文章推荐系统，按阅读次数、点赞数等权重排序。
- 优先级队列：任务调度系统，根据任务优先级顺序执行。
相关阅读：
go-redis 中有序集合操作的方法
下面列出 go-redis v9 中 SortedSet 相关操作的方法及其功能描述：
BZPopMax- 弹出并返回具有最大分数的成员，阻塞操作。BZPopMin- 弹出并返回具有最小分数的成员，阻塞操作。BZMPop- 弹出并返回多个最大或最小分数的成员，阻塞操作。ZAdd- 添加一个或多个成员到有序集合。ZAddLT- 添加成员，如果新成员的分数小于现有成员，则更新。ZAddGT- 添加成员，如果新成员的分数大于现有成员，则更新。ZAddNX- 添加成员，只有当成员不存在时才执行。ZAddXX- 添加成员，只有当成员已经存在时才执行。ZAddArgs- 带参数添加成员。ZAddArgsIncr- 带参数添加成员，并增加成员的分数。ZCard- 获取有序集合的成员数量。ZCount- 计算在有序集合中指定分数区间的成员数量。ZLexCount- 计算在有序集合中指定字典区间的成员数量。ZIncrBy- 为有序集合中的成员增加分数。ZInter- 计算有序集合的交集。ZInterWithScores- 计算有序集合的交集，并返回成员分数。ZInterCard- 获取交集中成员的数量。ZInterStore- 计算有序集合的交集，并将结果存储在新的有序集合中。ZMPop- 弹出并返回多个最大或最小分数的成员。ZMScore- 获取多个成员的分数。ZPopMax- 弹出并返回具有最大分数的成员。ZPopMin- 弹出并返回具有最小分数的成员。ZRange- 返回指定区间内的成员。ZRangeWithScores- 返回指定区间内的成员及其分数。ZRangeByScore- 返回指定分数区间内的成员。ZRangeByLex- 返回指定字典区间内的成员。ZRangeByScoreWithScores- 返回指定分数区间内的成员及其分数。ZRangeArgs- 带参数返回指定区间内的成员。ZRangeArgsWithScores- 带参数返回指定区间内的成员及其分数。ZRangeStore- 返回指定区间内的成员，并将结果存储在新的有序集合中。ZRank- 获取成员在有序集合中的排名。ZRankWithScore- 获取成员在有序集合中的排名及其分数。ZRem- 移除一个或多个成员。ZRemRangeByRank- 移除指定排名区间的成员。ZRemRangeByScore- 移除指定分数区间的成员。ZRemRangeByLex- 移除指定字典区间的成员。ZRevRange- 返回指定区间内的成员，按分数从高到低排序。ZRevRangeWithScores- 返回指定区间内的成员及其分数，按分数从高到低排序。ZRevRangeByScore- 返回指定分数区间内的成员，按分数从高到低排序。ZRevRangeByLex- 返回指定字典区间内的成员，按分数从高到低排序。ZRevRangeByScoreWithScores- 返回指定分数区间内的成员及其分数，按分数从高到低排序。ZRevRank- 获取成员在有序集合中的逆序排名。ZRevRankWithScore- 获取成员在有序集合中的逆序排名及其分数。ZScore- 获取成员的分数。ZUnionStore- 计算有序集合的并集，并将结果存储在新的有序集合中。ZRandMember- 随机返回一个或多个成员。ZRandMemberWithScores- 随机返回一个或多个成员及其分数。ZUnion- 计算有序集合的并集。ZUnionWithScores- 计算有序集合的并集，并返回成员分数。ZDiff- 计算有序集合的差集。ZDiffWithScores- 计算有序集合的差集，并返回成员分数。ZDiffStore- 计算有序集合的差集，并将结果存储在新的有序集合中。ZScan- 迭代有序集合中的元素。
go-redis SortedSet 有序集合操作方法详细讲解及示例代码
ZAdd：向有序集合中添加一个或多个成员。
方法签名：
ZAdd(ctx context.Context, key string, members ...Z) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要添加的成员及其分数，类型为Z。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
"time"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 添加成员到有序集合
members := []redis.Z{
{Score: 1.0, Member: "member1"},
{Score: 2.0, Member: "member2"},
{Score: 3.0, Member: "member3"},
}
result := rdb.ZAdd(ctx, "myzset", members...)
// 检查是否成功
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 3
}
ZAddLT：向有序集合中添加成员，如果新成员的分数小于现有成员的分数，则更新。
方法签名:
ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要添加的成员及其分数，类型为Z。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 添加成员到有序集合，如果新成员的分数小于现有成员的分数，则更新
members := []redis.Z{
{Score: 0.5, Member: "member1"},
{Score: 1.5, Member: "member2"},
}
result := rdb.ZAddLT(ctx, "myzset", members...)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 2
}
ZAddGT：向有序集合中添加成员，如果新成员的分数大于现有成员的分数，则更新。
方法签名:
ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要添加的成员及其分数，类型为Z。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 添加成员到有序集合，如果新成员的分数大于现有成员的分数，则更新
members := []redis.Z{
{Score: 2.0, Member: "member1"},
{Score: 3.0, Member: "member2"},
}
result := rdb.ZAddGT(ctx, "myzset", members...)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 2
}
ZAddNX：向有序集合中添加成员，只有当成员不存在时才执行。
方法签名:
ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要添加的成员及其分数，类型为Z。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 添加成员到有序集合，只有当成员不存在时才执行
members := []redis.Z{
{Score: 4.0, Member: "member1"},
{Score: 5.0, Member: "member2"},
}
result := rdb.ZAddNX(ctx, "myzset", members...)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 2
}
ZAddXX：向有序集合中添加成员，只有当成员已经存在时才执行。
方法签名:
ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要添加的成员及其分数，类型为Z。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 添加成员到有序集合，只有当成员已经存在时才执行
members := []redis.Z{
{Score: 6.0, Member: "member1"},
{Score: 7.0, Member: "member2"},
}
result := rdb.ZAddXX(ctx, "myzset", members...)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 2
}
ZAddArgs：向有序集合中添加成员，并允许使用更多的参数配置。
方法签名:
ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。args：添加成员时的参数配置，类型为ZAddArgs。
返回结果说明:
返回一个 *IntCmd，包含添加到有序集合中的新成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 使用参数配置添加成员到有序集合
args := redis.ZAddArgs{
Members: []redis.Z{
{Score: 8.0, Member: "member1"},
{Score: 9.0, Member: "member2"},
},
}
result := rdb.ZAddArgs(ctx, "myzset", args)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加的成员数量
fmt.Println("Added members:", result.Val()) // Output: Added members: 2
}
ZAddArgsIncr：向有序集合中添加成员，并允许使用更多的参数配置，如果成员已存在，则其分数增加。
方法签名:
ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。args：添加成员时的参数配置，类型为ZAddArgs。
返回结果说明:
返回一个 *FloatCmd，包含添加后的成员分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 使用参数配置添加成员到有序集合，并增加成员分数
args := redis.ZAddArgs{
Members: []redis.Z{
{Score: 1.0, Member: "member1"},
},
Incr: true,
}
result := rdb.ZAddArgsIncr(ctx, "myzset", args)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印添加后的成员分数
fmt.Println("New score of member1:", result.Val()) // Output: New score of member1: 1.0
}
ZIncrBy：为有序集合中的成员分数增加指定的增量。
方法签名:
ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。increment：分数的增量。member：成员的名称。
返回结果说明:
返回一个 *FloatCmd，包含增加后的成员分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 为成员分数增加指定的增量
result := rdb.ZIncrBy(ctx, "myzset", 2.0, "member1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印增加后的成员分数
fmt.Println("New score of member1:", result.Val()) // Output: New score of member1: 8.0
}
ZScore：获取有序集合中指定成员的分数。
方法签名:
ZScore(ctx context.Context, key, member string) *FloatCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。member：成员的名称。
返回结果说明:
返回一个 *FloatCmd，包含成员的分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取成员的分数
result := rdb.ZScore(ctx, "myzset", "member1")
// 检查是否成功
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印成员分数
fmt.Println("Score of member1:", result.Val()) // Output: Score of member1: 1
}
ZMScore：获取多个成员的分数。
方法签名:
ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：成员的名称。
返回结果说明:
返回一个 *FloatSliceCmd，包含多个成员的分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取多个成员的分数
result := rdb.ZMScore(ctx, "myzset", "member1", "member2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印多个成员的分数
scores := result.Val()
for i, member := range []string{"member1", "member2"} {
fmt.Printf("Member: %s, Score: %.2f\n", member, scores[i]) // Output: Member: member1, Score: 1.0
}
}
ZCard：获取有序集合中的成员数量。
方法签名:
ZCard(ctx context.Context, key string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。
返回结果说明:
返回一个 *IntCmd，包含有序集合中的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中的成员数量
result := rdb.ZCard(ctx, "myzset")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印成员数量
fmt.Println("Number of members in myzset:", result.Val()) // Output: Number of members in myzset: 2
}
ZCount：获取有序集合中指定分数范围内的成员数量。
方法签名:
ZCount(ctx context.Context, key, min, max string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小分数。max：最大分数。
返回结果说明:
返回一个 *IntCmd，包含指定分数范围内的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定分数范围内的成员数量
result := rdb.ZCount(ctx, "myzset", "0", "5")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印成员数量
fmt.Println("Number of members with scores between 0 and 5:", result.Val()) // Output: Number of members with scores between 0 and 5: 1
}
ZLexCount：获取有序集合中指定字典区间内的成员数量。
方法签名:
ZLexCount(ctx context.Context, key, min, max string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小成员。max：最大成员。
返回结果说明:
返回一个 *IntCmd，包含指定字典区间内的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定字典区间内的成员数量
result := rdb.ZLexCount(ctx, "myzset", "[a", "[z")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印成员数量
fmt.Println("Number of members in lex range [a, z]:", result.Val()) // Output: Number of members in lex range [a, z]: 2
}
ZInter：计算多个有序集合的交集，并返回结果。
方法签名:
ZInter(ctx context.Context, store *ZStore) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。store：用于存储交集计算参数的结构体，类型为*ZStore。
返回结果说明:
返回一个 *StringSliceCmd，包含交集计算结果的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的交集
store := &redis.ZStore{
Keys: []string{"myzset1", "myzset2"},
}
result := rdb.ZInter(ctx, store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印交集计算结果的成员
fmt.Println("Intersection members:", result.Val()) // Output: Intersection members: [member1 member2]
}
ZInterWithScores：计算多个有序集合的交集，并返回带分数的结果。
方法签名:
ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。store：用于存储交集计算参数的结构体，类型为*ZStore。
返回结果说明:
返回一个 *ZSliceCmd，包含交集计算结果的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的交集并返回带分数的结果
store := &redis.ZStore{
Keys: []string{"myzset1", "myzset2"},
}
result := rdb.ZInterWithScores(ctx, store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印交集计算结果的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score) // Output: Member: member1, Score: 10.0
}
}
ZInterCard：计算多个有序集合的交集数量。
方法签名:
ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。limit：交集计算的最大数量。keys：有序集合的键。
返回结果说明:
返回一个 *IntCmd，包含交集计算的数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的交集数量
result := rdb.ZInterCard(ctx, 10, "myzset1", "myzset2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印交集计算的数量
fmt.Println("Intersection count:", result.Val()) // Output: Intersection count: 2
}
ZInterStore：计算多个有序集合的交集，并将结果存储在目标键中。
方法签名:
ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。destination：目标键。store：用于存储交集计算参数的结构体，类型为*ZStore。
返回结果说明:
返回一个 *IntCmd，包含存储在目标键中的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的交集并将结果存储在目标键中
store := &redis.ZStore{
Keys: []string{"myzset1", "myzset2"},
}
result := rdb.ZInterStore(ctx, "destzset", store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印存储在目标键中的成员数量
fmt.Println("Number of members in destination set:", result.Val()) // Output: Number of members in destination set: 2
}
ZMPop：从多个有序集合中弹出最小或最大的多个成员。
方法签名:
ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。order：弹出成员的顺序，"MIN"表示最小，"MAX"表示最大。count：弹出的成员数量。keys：有序集合的键。
返回结果说明:
返回一个 *ZSliceWithKeyCmd，包含弹出的成员及其分数和所在的键。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 从多个有序集合中弹出最小的多个成员
result := rdb.ZMPop(ctx, "MIN", 2, "myzset1", "myzset2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出的成员及其分数和所在的键
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f, Key: %s\n", z.Member, z.Score, z.Key) // Output: Member: member1, Score: 1.0, Key: myzset1
}
}
BZMPop：从有序集合中弹出并返回多个最大或最小分数的成员，该操作是阻塞的。
方法签名:
BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。timeout：超时时间，阻塞等待的时间。order：弹出顺序，“min” 或 “max”。count：要弹出的成员数量。keys：一个或多个有序集合的键。
返回结果说明:
返回一个 *ZSliceWithKeyCmd，包含弹出成员的信息（成员名称、分数及键）。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
"time"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 弹出并返回多个具有最大分数的成员，阻塞操作
result := rdb.BZMPop(ctx, 5*time.Second, "max", 2, "myzset")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出成员的信息
members := result.Val()
fmt.Println("Popped members:", members)
}
BZPopMax：从有序集合中弹出并返回具有最大分数的成员，该操作是阻塞的。
方法签名:
BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
参数说明：
ctx：上下文，用于控制请求的生命周期。timeout：超时时间，阻塞等待的时间。keys：一个或多个有序集合的键。
返回结果说明:
返回一个 *ZWithKeyCmd，包含弹出成员的信息（成员名称、分数及键）。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
"time"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 弹出并返回具有最大分数的成员，阻塞操作
result := rdb.BZPopMax(ctx, 5*time.Second, "myzset")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出成员的信息
member := result.Val()
fmt.Println("Popped member:", member)
}
BZPopMin：从有序集合中弹出并返回具有最小分数的成员，该操作是阻塞的。
方法签名:
BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。timeout：超时时间，阻塞等待的时间。keys：一个或多个有序集合的键。
返回结果说明:
返回一个 *ZWithKeyCmd，包含弹出成员的信息（成员名称、分数及键）。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
"time"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 弹出并返回具有最小分数的成员，阻塞操作
result := rdb.BZPopMin(ctx, 5*time.Second, "myzset")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出成员的信息
member := result.Val()
fmt.Println("Popped member:", member)
}
ZPopMax：从有序集合中弹出具有最大分数的成员。
方法签名:
ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。count：要弹出的成员数量（可选）。
返回结果说明:
返回一个 *ZSliceCmd，包含弹出的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 从有序集合中弹出具有最大分数的成员
result := rdb.ZPopMax(ctx, "myzset", 2)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZPopMin：从有序集合中弹出具有最小分数的成员。
方法签名:
ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。count：要弹出的成员数量（可选）。
返回结果说明:
返回一个 *ZSliceCmd，包含弹出的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 从有序集合中弹出具有最小分数的成员
result := rdb.ZPopMin(ctx, "myzset", 2)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印弹出的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRange：获取有序集合中指定区间内的成员。
方法签名：
ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。start：开始索引。stop：结束索引。
返回结果说明:
返回一个 *StringSliceCmd，包含指定区间内的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定区间内的成员
result := rdb.ZRange(ctx, "myzset", 0, -1)
// 检查是否成功
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印成员列表
members := result.Val()
fmt.Println("Members:", members) // Output: Members: [member1 member2 member3]
}
ZRangeWithScores：获取有序集合中指定范围内的成员及其分数。
方法签名:
ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。start：起始索引。stop：结束索引。
返回结果说明：
返回一个 *ZSliceCmd，包含指定范围内的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定范围内的成员及其分数
result := rdb.ZRangeWithScores(ctx, "myzset", 0, -1)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRangeByScore：获取有序集合中指定分数范围内的成员。
方法签名：
ZRangeByScore(ctx context.Context, key, min, max string) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小分数。max：最大分数。
返回结果说明:
返回一个 *StringSliceCmd，包含指定分数范围内的成员。
示例代码:
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定分数范围内的成员
result := rdb.ZRangeByScore(ctx, "myzset", "0", "5")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定分数范围内的成员
fmt.Println("Members with scores between 0 and 5:", result.Val())
}
ZRangeByLex：获取有序集合中指定字典区间内的成员。
方法签名:
ZRangeByLex(ctx context.Context, key, min, max string) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小字典值。max：最大字典值。
返回结果说明:
返回一个 *StringSliceCmd，包含指定字典区间内的成员。
示例代码
PACKAge main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定字典区间内的成员
result := rdb.ZRangeByLex(ctx, "myzset", "[a", "[z")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定字典区间内的成员
fmt.Println("Members in lex range [a, z]:", result.Val())
}
ZRangeByScoreWithScores：获取有序集合中指定分数范围内的成员及其分数。
方法签名:
ZRangeByScoreWithScores(ctx context.Context, key, min, max string) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小分数。max：最大分数。
返回结果说明：
返回一个 *ZSliceCmd，包含指定分数范围内的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定分数范围内的成员及其分数
result := rdb.ZRangeByScoreWithScores(ctx, "myzset", "0", "5")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定分数范围内的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRangeArgs：根据给定的参数获取有序集合中的成员。
方法签名:
ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。z：包含参数的ZRangeArgs结构体。
返回结果说明:
返回一个 *StringSliceCmd，包含指定范围内的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 使用 ZRangeArgs 获取有序集合中的成员
args := redis.ZRangeArgs{
Key: "myzset",
Start: 0,
Stop: -1,
ByScore: true,
}
result := rdb.ZRangeArgs(ctx, args)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员
fmt.Println("Members:", result.Val())
}
ZRangeArgsWithScores：根据给定的参数获取有序集合中的成员及其分数。
方法签名:
ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。z：包含参数的ZRangeArgs结构体。
返回结果说明:
返回一个 *ZSliceCmd，包含指定范围内的成员及其分数。
示例代码:
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 使用 ZRangeArgsWithScores 获取有序集合中的成员及其分数
args := redis.ZRangeArgs{
Key: "myzset",
Start: 0,
Stop: -1,
ByScore: true,
}
result := rdb.ZRangeArgsWithScores(ctx, args)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRangeStore：将有序集合中指定范围内的成员存储到另一个集合中。
方法签名:
ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。dst：目标集合的键。z：包含参数的ZRangeArgs结构体。
返回结果说明:
返回一个 *IntCmd，包含被存储的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 使用 ZRangeStore 将有序集合中的成员存储到另一个集合中
args := redis.ZRangeArgs{
Key: "myzset",
Start: 0,
Stop: -1,
ByScore: true,
}
result := rdb.ZRangeStore(ctx, "mydstset", args)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印被存储的成员数量
fmt.Println("Stored members count:", result.Val())
}
ZRevRange：获取有序集合中指定范围内的成员，按分数从高到低排序。
方法签名:
ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。start：起始索引。stop：结束索引。
返回结果说明:
返回一个 *StringSliceCmd，包含指定范围内的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定范围内的成员，按分数从高到低排序
result := rdb.ZRevRange(ctx, "myzset", 0, -1)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员
fmt.Println("Members:", result.Val())
}
ZRevRangeWithScores：获取有序集合中指定范围内的成员及其分数，按分数从高到低排序。
方法签名:
ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。start：起始索引。stop：结束索引。
返回结果说明:
返回一个 *ZSliceCmd，包含指定范围内的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定范围内的成员及其分数，按分数从高到低排序
result := rdb.ZRevRangeWithScores(ctx, "myzset", 0, -1)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRevRangeByScore：获取有序集合中指定分数范围内的成员，按分数从高到低排序。
方法签名:
ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。opt：包含范围参数的ZRangeBy结构体。
返回结果说明:
返回一个 *StringSliceCmd，包含指定分数范围内的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定分数范围内的成员，按分数从高到低排序
opt := &redis.ZRangeBy{
Min: "-inf",
Max: "+inf",
}
result := rdb.ZRevRangeByScore(ctx, "myzset", opt)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员
fmt.Println("Members:", result.Val())
}
ZRevRangeByLex：获取有序集合中指定字典范围内的成员，按字典顺序从高到低排序。
方法签名:
ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。opt：包含范围参数的ZRangeBy结构体。
返回结果说明:
返回一个 *StringSliceCmd，包含指定字典范围内的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定字典范围内的成员，按字典顺序从高到低排序
opt := &redis.ZRangeBy{
Min: "[a",
Max: "[c",
}
result := rdb.ZRevRangeByLex(ctx, "myzset", opt)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员
fmt.Println("Members:", result.Val())
}
ZRevRangeByScoreWithScores：获取有序集合中指定分数范围内的成员及其分数，按分数从高到低排序。
方法签名:
ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。opt：包含范围参数的ZRangeBy结构体。
返回结果说明:
返回一个 *ZSliceCmd，包含指定分数范围内的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取有序集合中指定分数范围内的成员及其分数，按分数从高到低排序
opt := &redis.ZRangeBy{
Min: "-inf",
Max: "+inf",
}
result := rdb.ZRevRangeByScoreWithScores(ctx, "myzset", opt)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定范围内的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZRank：获取指定成员在有序集合中的排名。
方法签名:
ZRank(ctx context.Context, key, member string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。member：成员。
返回结果说明:
返回一个 *IntCmd，包含指定成员的排名。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定成员在有序集合中的排名
result := rdb.ZRank(ctx, "myzset", "member1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定成员的排名
fmt.Println("Rank of member1:", result.Val())
}
ZRankWithScore：获取指定成员在有序集合中的排名及其分数。
方法签名:
ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。member：成员。
返回结果说明:
返回一个 *RankWithScoreCmd，包含指定成员的排名及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定成员在有序集合中的排名及其分数
result := rdb.ZRankWithScore(ctx, "myzset", "member1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定成员的排名及其分数
rankWithScore := result.Val()
fmt.Printf("Rank: %d, Member: %s, Score: %.2f\n", rankWithScore.Rank, rankWithScore.Member, rankWithScore.Score)
}
ZRevRank：获取指定成员在有序集合中的逆序排名。
方法签名:
ZRevRank(ctx context.Context, key, member string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。member：成员。
返回结果说明:
返回一个 *IntCmd，包含指定成员的逆序排名。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定成员在有序集合中的逆序排名
result := rdb.ZRevRank(ctx, "myzset", "member1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定成员的逆序排名
fmt.Println("Reverse rank of member1:", result.Val())
}
ZRevRankWithScore：获取指定成员在有序集合中的逆序排名及其分数。
方法签名:
ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。member：成员。
返回结果说明:
返回一个 *RankWithScoreCmd，包含指定成员的逆序排名及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 获取指定成员在有序集合中的逆序排名及其分数
result := rdb.ZRevRankWithScore(ctx, "myzset", "member1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印指定成员的逆序排名及其分数
rankWithScore := result.Val()
fmt.Printf("Reverse Rank: %d, Member: %s, Score: %.2f\n", rankWithScore.Rank, rankWithScore.Member, rankWithScore.Score)
}
ZRem：移除有序集合中的一个或多个成员。
方法签名:
ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。members：要移除的成员名称，类型为interface{}。
返回结果说明:
返回一个 *IntCmd，包含移除的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 移除成员
result := rdb.ZRem(ctx, "myzset", "member1", "member2")
// 检查是否成功
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印移除的成员数量
fmt.Println("Removed members:", result.Val()) // Output: Removed members: 2
}
ZRemRangeByRank：移除有序集合中指定排名范围内的成员。
方法签名:
ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。start：起始排名。stop：结束排名。
返回结果说明:
返回一个 *IntCmd，包含被移除的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 移除有序集合中指定排名范围内的成员
result := rdb.ZRemRangeByRank(ctx, "myzset", 0, 1)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印被移除的成员数量
fmt.Println("Removed members count:", result.Val())
}
ZRemRangeByScore：移除有序集合中指定分数范围内的成员。
方法签名:
ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小分数。max：最大分数。
返回结果说明:
返回一个 *IntCmd，包含被移除的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 移除有序集合中指定分数范围内的成员
result := rdb.ZRemRangeByScore(ctx, "myzset", "0", "1")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印被移除的成员数量
fmt.Println("Removed members count:", result.Val())
}
ZRemRangeByLex：移除有序集合中指定字典范围内的成员。
方法签名:
ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。min：最小字典值。max：最大字典值。
返回结果说明:
返回一个 *IntCmd，包含被移除的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "
localhost:6379",
})
// 移除有序集合中指定字典范围内的成员
result := rdb.ZRemRangeByLex(ctx, "myzset", "[a", "[c")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印被移除的成员数量
fmt.Println("Removed members count:", result.Val())
}
ZRandMember：随机获取有序集合中的一个或多个成员。
方法签名:
ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd
参数说明：
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。count：要随机获取的成员数量。
返回结果说明:
返回一个 *StringSliceCmd，包含随机获取的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 随机获取有序集合中的一个或多个成员
result := rdb.ZRandMember(ctx, "myzset", 3)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印随机获取的成员
fmt.Println("Random members:", result.Val())
}
ZRandMemberWithScores：随机获取有序集合中的一个或多个成员及其分数。
方法签名:
ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。count：要随机获取的成员数量。
返回结果说明:
返回一个 *ZSliceCmd，包含随机获取的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 随机获取有序集合中的一个或多个成员及其分数
result := rdb.ZRandMemberWithScores(ctx, "myzset", 3)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印随机获取的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZUnion：计算多个有序集合的并集。
方法签名:
ZUnion(ctx context.Context, store ZStore) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。store：包含源集合及相关参数的ZStore结构体。
返回结果说明:
返回一个 *StringSliceCmd，包含并集的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的并集
store := redis.ZStore{
Keys: []string{"zset1", "zset2"},
Weights: []float64{1, 1},
}
result := rdb.ZUnion(ctx, store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印并集的成员
fmt.Println("Union members:", result.Val())
}
ZUnionWithScores：计算多个有序集合的并集及其分数。
方法签名:
ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。store：包含源集合及相关参数的ZStore结构体。
返回结果说明:
返回一个 *ZSliceCmd，包含并集的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的并集及其分数
store := redis.ZStore{
Keys: []string{"zset1", "zset2"},
Weights: []float64{1, 1},
}
result := rdb.ZUnionWithScores(ctx, store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印并集的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZUnionStore：将多个有序集合的并集存储到一个新的有序集合中。
方法签名:
ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。dest：目标有序集合的键。store：包含源集合及相关参数的ZStore结构体。
返回结果说明:
返回一个 *IntCmd，包含新有序集合中的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 将多个有序集合的并集存储到一个新的有序集合中
store := &redis.ZStore{
Keys: []string{"zset1", "zset2"},
Weights: []float64{1, 1},
}
result := rdb.ZUnionStore(ctx, "zunion", store)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印新有序集合中的成员数量
fmt.Println("Number of members in the new sorted set:", result.Val())
}
ZDiff：计算多个有序集合的差集。
方法签名:
ZDiff(ctx context.Context, keys ...string) *StringSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。keys：有序集合的键列表。
返回结果说明:
返回一个 *StringSliceCmd，包含差集的成员。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的差集
result := rdb.ZDiff(ctx, "zset1", "zset2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印差集的成员
fmt.Println("Difference members:", result.Val())
}
ZDiffWithScores：计算多个有序集合的差集及其分数。
方法签名:
ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。keys：有序集合的键列表。
返回结果说明:
返回一个 *ZSliceCmd，包含差集的成员及其分数。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 计算多个有序集合的差集及其分数
result := rdb.ZDiffWithScores(ctx, "zset1", "zset2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印差集的成员及其分数
for _, z := range result.Val() {
fmt.Printf("Member: %s, Score: %.2f\n", z.Member, z.Score)
}
}
ZDiffStore：将多个有序集合的差集存储到一个新的有序集合中。
方法签名:
ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。destination：目标有序集合的键。keys：有序集合的键列表。
返回结果说明:
返回一个 *IntCmd，包含新有序集合中的成员数量。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 将多个有序集合的差集存储到一个新的有序集合中
result := rdb.ZDiffStore(ctx, "zdiff", "zset1", "zset2")
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印新有序集合中的成员数量
fmt.Println("Number of members in the new sorted set:", result.Val())
}
ZScan：迭代有序集合中的成员。
方法签名：
ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
参数说明:
ctx：上下文，用于控制请求的生命周期。key：有序集合的键。cursor：迭代游标。match：匹配模式。count：每次迭代的最大数量。
返回结果说明:
返回一个 *ScanCmd，包含迭代结果。
示例代码
package main
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
})
// 迭代有序集合中的成员
var cursor uint64
for {
result := rdb.ZScan(ctx, "myzset", cursor, "*", 10)
if result.Err() != nil {
fmt.Println("Error:", result.Err())
return
}
// 打印迭代结果
members := result.Val()
for i := 0; i < len(members); i += 2 {
fmt.Printf("Member: %s, Score: %s\n", members[i], members[i+1])
}
cursor = result.Cursor()
if cursor == 0 {
break
}
}
}
结语
通过本篇文章的学习，我们掌握了如何使用 go-redis 库操作 Redis 的 SortedSet 有序集合。无论是添加、查询、删除还是排序，这些方法都能帮助你轻松地管理 Redis 中的有序集合。希望你能将这些知识应用到实际项目中，充分发挥 Redis 有序集合的强大功能。如果你有任何问题或建议，欢迎在评论区留言讨论。点击 go-redis 使用指南 可查看更多相关教程！
