Golang 操作 Redis:SortedSet有序集合数据类型操作用法 - go-redis 使用指南

文章目录

在本系列上一篇文章中,我们详细介绍了如何使用 go-redis 库来操作 Redis 的 List 列表数据类型。如果你错过了,可以点击这里查看。在本篇文章中,我们将聚焦于 Redis 的另一种强大数据结构:SortedSet(有序集合),并介绍如何使用 go-redis 库进行相关操作。

👉 点击查看 go-redis 使用指南目录

在《go-redis 使用指南》系列文章中,我们将详细介绍如何在 Golang 项目中使用 redis/go-redis 库与 Redis 进行交互。以下是该系列文章的全部内容:

  1. Golang 操作 Redis:快速上手 - go-redis 使用指南
  2. Golang 操作 Redis:连接设置与参数详解 - go-redis 使用指南
  3. Golang 操作 Redis:基础的字符串键值操作 - go-redis 使用指南
  4. Golang 操作 Redis:如何设置 key 的过期时间 - go-redis 使用指南
  5. Golang 操作 Redis:Hash 哈希数据类型操作用法 - go-redis 使用指南
  6. Golang 操作 Redis:Set 集合数据类型操作用法 - go-redis 使用指南
  7. Golang 操作 Redis:为 Hash 中的字段设置过期时间 - go-redis 使用指南
  8. Golang 操作 Redis:List 列表数据类型操作用法 - go-redis 使用指南
  9. Golang 操作 Redis:SortedSet 有序集合数据类型操作用法 - go-redis 使用指南
  10. Golang 操作 Redis:bitmap 数据类型操作用法 - go-redis 使用指南
  11. Golang 操作 Redis:事务处理操作用法 - go-redis 使用指南
  12. Golang 操作 Redis:地理空间数据类型操作用法 - go-redis 使用指南
  13. Golang 操作 Redis:HyperLogLog 操作用法 - go-redis 使用指南
  14. Golang 操作 Redis:Pipeline 操作用法 - go-redis 使用指南
  15. Golang 操作 Redis:PubSub发布订阅用法 - go-redis 使用指南
  16. Golang 操作 Redis:布隆过滤器(Bloom Filter)操作用法 - go-redis 使用指南
  17. Golang 操作 Redis:Cuckoo Filter操作用法 - go-redis 使用指南
  18. Golang 操作 Redis:Stream操作用法 - go-redis 使用指南
golang redis 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 使用指南 可查看更多相关教程!


也可以看看


小而赚副业指南

分享低成本靠谱赚钱副业,获取实用的搞钱指南,开启你的副业赚钱之旅吧!

全国大流量卡免费领

19元月租ㆍ超值优惠ㆍ长期套餐ㆍ免费包邮ㆍ官方正品