在本系列上一篇文章中,我们详细介绍了如何使用 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 使用指南 可查看更多相关教程!