Set

• redis的set是string类型的无序集合。集合中成员是唯一的，这就意味着集合中不能出现重复的数据。redis中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。集合中最大的成员数为3^32^ - 1（4294967295，每个集合可以存储40多亿个成员）。
• set类型一般用于赞，踩，标签，好友关系等。

结构图

相关命令

命令	说明
sadd key member1 [member2...]	向集合中添加一个或多个成员
smembers key	返回集合中的所有成员
scard key	获取集合的成员数
srandmember key [count]	返回集合中一个或多个随机数
sismember key member	判断member元素是否是集合key的成员
srem key member1 [member2...]	移除集合中一个或多个成员
sdiff key1 [key2]	返回给定所有集合的差集
sdiffstore destination key1 [key2...]	返回给定所有集合的差集并存储在 destination 中
sinter key1 [key2...]	返回给定所有集合的交集
sinterstore destination key1 [key2...]	返回给定所有集合的交集并存储在 destination 中
sunion key1 [key2...]	返回所有给定集合的并集
sunionstore destination key1 [key2...]	所有给定集合的并集存储在 destination 集合中
smove source destination member	将 member 元素从 source 集合移动到 destination 集合
spop key [count]	移除并返回集合中的一个随机元素
sscan key cursor [MATCH pattern] [COUNT count]	迭代集合中的元素

sdiff key1 [key2]

• sdiff 是 Redis 中的一个命令，它用于执行集合（set）的对称差集运算。对称差集是两个集合的差集的并集，即只属于第一个集合或只属于第二个集合的元素组成的集合。

• 具体来说，如果你有两个集合 key1 和 key2，并且你执行了 SDIFF key1 key2，Redis 将返回那些属于 key1 但不属于 key2 的元素，以及那些属于 key2 但不属于 key1 的元素。

但是，需要注意的是，Redis 的 SDIFF 命令的语法并不是你给出的 sdiff key1 [key2]。实际的语法是：

SDIFF key1 [key2 ...]

这意味着你可以指定一个或多个额外的键（除了 key1），并且 Redis 将返回与 key1 的对称差集。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 b c d

执行 SDIFF set1 set2 将返回：

1) "a"
2) "d"

因为 “a” 只存在于 set1 中，而 “d” 只存在于 set2 中。

sdiffstore destination key1 [key2...]

• SDIFFSTORE 是 Redis 中的一个命令，它用于执行集合（set）的对称差集运算，并将结果存储在一个新的集合中。这与 SDIFF 命令类似，但 SDIFFSTORE 会将结果保存到指定的 destination 键中，而不是直接返回结果。

SDIFFSTORE 命令的语法是：

SDIFFSTORE destination key1 [key2 ...]

其中：

• destination：用于存储对称差集结果的新集合的键名。
• key1：要进行对称差集运算的第一个集合的键名。
• [key2 ...]：可选的，要进行对称差集运算的其他集合的键名。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 b c d

执行 SDIFFSTORE set_result set1 set2 将把 set1 和 set2 的对称差集结果保存到 set_result 中。结果集合 set_result 将包含元素 “a” 和 “d”，因为 “a” 只存在于 set1 中，而 “d” 只存在于 set2 中。

你可以通过 SMEMBERS 命令来查看 set_result 的内容：

SMEMBERS set_result
1) "a"
2) "d"

sinter key1 [key2...]

是的，SINTER 是 Redis 中的一个命令，用于执行集合（set）的交集运算。它会返回所有指定集合的交集，即同时存在于所有集合中的元素。

SINTER 命令的语法是：

SINTER key1 [key2 ...]

其中：

• key1：第一个集合的键名。
• [key2 ...]：可选的，其他集合的键名。

如果至少有一个集合是空的，那么 SINTER 将返回一个空集合。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 c e

执行 SINTER set1 set2 set3 将返回：

1) "c"

因为 “c” 是唯一同时存在于 set1、set2 和 set3 中的元素。

sinterstore destination key1 [key2...]

• SINTERSTORE 是 Redis 中用于执行集合（set）的交集运算并将结果存储在一个新集合的命令。这个命令会计算所有给定集合的交集，并将结果保存在指定的 destination 键中。

SINTERSTORE 命令的语法是：

SINTERSTORE destination key1 [key2 ...]

其中：

• destination：新集合的键名，用于存储交集的结果。
• key1：第一个集合的键名。
• [key2 ...]：可选的，其他集合的键名。

如果至少有一个集合是空的，或者没有任何集合被指定，那么 SINTERSTORE 命令将在 destination 键中存储一个空集合。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 c e

执行 SINTERSTORE set_intersection set1 set2 set3 将把 set1、set2 和 set3 的交集结果保存到 set_intersection 中。结果集合 set_intersection 将只包含元素 “c”，因为它是唯一同时存在于 set1、set2 和 set3 中的元素。

你可以通过 SMEMBERS 命令来查看 set_intersection 的内容：

SMEMBERS set_intersection
1) "c"

sunion key1 [key2...]

SUNION 是 Redis 中的一个命令，用于执行集合（set）的并集运算。它会返回所有指定集合的并集，即存在于任何一个集合中的元素。

SUNION 命令的语法是：

SUNION key1 [key2 ...]

其中：

• key1：第一个集合的键名。
• [key2 ...]：可选的，其他集合的键名。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 e f

执行 SUNION set1 set2 set3 将返回：

1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"

因为这些都是存在于 set1、set2 或 set3 中的元素。

sunionstore destination key1 [key2...]

• 与 SINTERSTORE 类似，Redis 也提供了一个 SUNIONSTORE 命令，该命令将并集的结果存储在一个新的集合中，而不是直接返回结果。其语法是：

SUNIONSTORE destination key1 [key2 ...]

使用 SUNIONSTORE 命令，你可以将并集的结果保存到 destination 指定的键中。例如：

SUNIONSTORE set_union set1 set2 set3

这会将 set1、set2 和 set3 的并集结果保存到 set_union 键中。然后，你可以使用 SMEMBERS 命令来查看 set_union 的内容：

SMEMBERS set_union
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"

smove source destination member

SMOVE 是 Redis 中的一个命令，用于将指定的成员从一个集合（source）移动到另一个集合（destination）。如果成员存在于源集合中，SMOVE 命令将其从源集合中移除，并添加到目标集合中。如果移动成功，命令将返回 1；如果成员不存在于源集合中，命令将返回 0。

SMOVE 命令的语法是：

SMOVE source destination member

其中：

• source：源集合的键名。
• destination：目标集合的键名。
• member：要移动的成员的值。

例如，假设你有以下集合：

SADD set1 a b c
SADD set2 d e

现在，如果你想要将 set1 中的成员 b 移动到 set2，你可以使用 SMOVE 命令：

SMOVE set1 set2 b

执行上述命令后，set1 的内容将变为 a c，而 set2 的内容将变为 d e b（假设移动成功）。然后，你可以使用 SMEMBERS 命令来查看两个集合的内容：

SMEMBERS set1
1) "a"
2) "c"

SMEMBERS set2
1) "d"
2) "e"
3) "b"

注意：如果 b 不存在于 set1 中，SMOVE 命令将返回 0，并且 set2 的内容不会改变。

spop key [count]

SPOP 是 Redis 中的一个命令，用于移除并返回集合（set）中的一个随机元素。如果集合是空的，SPOP 命令将返回一个 nil 值或者一个错误（取决于 Redis 的配置和使用的客户端库）。

SPOP 命令的语法是：

SPOP key [count]

其中：

• key：集合的键名。
• [count]：可选参数，指定要移除并返回的元素数量。如果不提供，或者提供的 count 为 1，那么 SPOP 将只移除并返回一个随机元素。如果 count 大于集合中的元素数量，那么将返回集合中的所有元素。

例如，假设你有以下集合：

SADD myset "one" "two" "three" "four"

执行 SPOP myset 将返回集合 myset 中的一个随机元素，比如 "two"（注意这里返回的是随机元素，不一定是 "two"），并且这个元素会从集合中移除。然后，如果你再次查看 myset 的内容，你会看到 "two" 已经不在其中了。

SMEMBERS myset
1) "one"
2) "three"
3) "four"

如果你指定 count 参数，比如 SPOP myset 2，那么将返回两个随机元素（如果集合中有足够的元素），并从集合中移除它们。

需要注意的是，SPOP 命令是原子性的，即在执行期间不会被其他命令打断。这意味着在并发环境下，你可以安全地使用 SPOP 来处理集合中的元素。

sscan key cursor [MATCH pattern] [COUNT count]

SSCAN 是 Redis 中用于迭代集合（set）中的元素的命令。当集合非常大，无法一次性获取所有元素时，可以使用 SSCAN 来逐步迭代集合中的元素。

SSCAN 命令的语法是：

SSCAN key cursor [MATCH pattern] [COUNT count]

其中：

• key：集合的键名。
• cursor：游标，是一个从 0 开始的整数值。用于标识迭代的起始位置。初始调用时，游标应为 0。在后续的迭代中，应使用前一次迭代返回的游标值。
• MATCH pattern（可选）：用于过滤返回的元素的模式。pattern 是一个 glob 风格的模式串。
• COUNT count（可选）：指定每次迭代返回的元素数量。注意，这是一个提示，Redis 可能会返回更多或更少的元素。

当 SSCAN 命令被调用时，它会返回两个值：

1. 一个新的游标值，用于下一次迭代。如果返回的游标值为 0，则表示迭代结束。
2. 一个数组，包含匹配模式的元素。

示例：

假设你有一个名为 myset 的集合，包含以下元素：one, two, three, four, five。

如果你想迭代这个集合并只获取以 t 开头的元素，你可以这样做：

# 第一次迭代，游标为 0
SSCAN myset 0 MATCH t*
# 假设返回游标为 123 和元素 ["three"]

# 第二次迭代，使用上次返回的游标 123
SSCAN myset 123 MATCH t*
# 如果集合中没有更多的匹配元素，返回的游标值将为 0，且元素数组为空

注意：SSCAN 命令是非阻塞的，并且可以在不锁定集合的情况下迭代集合中的元素。这使得 SSCAN 命令在处理大型集合时非常有用。

• 例：SSCAN names 0 MATCH test* COUNT 10 # 每次返回10条以test为前缀的key (name为key名)

Zset

• Redis有序集合和集合一样也是string类型元素的集合且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的，但分数(score)却可以重复。
• 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为2^32^ - 1 (4294967295, 每个集合可存储40多亿个成员)。
• Zset类型一般用于排行榜等。

结构图

相关命令

命令语法	说明
zadd key score1 member1 [score2 member2...]	向有序集合添加一个或多个成员，或者更新已存在成员的分数
zcard key	获取有序集合的成员数
zcount key min max	计算在有序集合中指定区间分数的成员数
zincrby key increment member	有序集合中对指定成员的分数加上增量 increment
zlexcount key min max	在有序集合中计算指定字典区间内成员数量
zrange key start stop [withscores]	通过索引区间返回有序集合指定区间内的成员
zrangebylex key min max [limit offset count]	通过字典区间返回有序集合的成员
zrangebyscore key min max [withscores] [limit offset count]	通过分数返回有序集合指定区间内的成员
zrank key member	返回有序集合中指定成员的索引
zrem key member [member...]	移除有序集合中的一个或多个成员
zremrangebylex key min max	移除有序集合中给定的字典区间的所有成员
zremrangebyrank key start stop	移除有序集合中给定的排名区间的所有成员
zremrangebyscore key min max	移除有序集合中给定的分数区间的所有成员
zrevrange key start stop [withscores]	返回有序集中指定区间内的成员，通过索引，分数从高到低
zrevrangebyscore key max min [withscores]	返回有序集中指定分数区间内的成员，分数从高到低排序
zrevrank key member	返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
zscore key member	返回有序集中，成员的分数值
zinterstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]	计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
zunionstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]	计算给定的一个或多个有序集的并集，并存储在新的 key 中
zscan key cursor [MATCH pattern] [COUNT count]	迭代有序集合中的元素（包括元素成员和元素分值）

zcount key min max

ZCOUNT key min max 是 Redis 中用于有序集合（sorted set）的命令，用于计算指定分数范围内的成员数量。以下是关于该命令的详细解释：

命令格式

ZCOUNT key min max

参数说明

• key：有序集合的名称。
• min 和 max：指定分数范围的最小值和最大值。这两个参数支持以下用法：
  • 使用正数表示具体的分数值。
  • 使用 -inf 表示无限小，即包括所有小于 max 的分数。
  • 使用 +inf 表示无限大，即包括所有大于 min 的分数。
  • 在数字前加 ( 表示不包含该数字本身（开区间）。
  • 在数字前加 [ 表示包含该数字本身（闭区间，但默认就是闭区间，所以通常省略）。

返回值

返回一个整数，表示在有序集合 key 中，分数值在 min 和 max 之间（包括等于 min 或 max）的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些员工和他们的薪水（作为分数）：

redis> ZADD myzset 2000 jack
redis> ZADD myzset 3500 peter
redis> ZADD myzset 5000 tom

现在，我们想要计算薪水在 2000 到 5000 之间（包括 2000 和 5000）的员工数量：

redis> ZCOUNT myzset 2000 5000
(integer) 3

这个命令将返回 3，因为有三名员工的薪水在这个范围内。

注意事项

• 如果 key 不存在，或者 key 不是一个有序集合，那么 ZCOUNT 命令将返回一个错误。
• ZCOUNT 命令的时间复杂度为 O(log(N))，因为它使用元素的排名来获取范围的概念，因此不需要做与范围大小成比例的工作。

zincrby key increment member

ZINCRBY 是 Redis 中用于有序集合（sorted set）的命令，用于对有序集合中指定成员的分数进行增加。这个命令会找到指定成员，并将其分数增加指定的增量值。

命令格式

ZINCRBY key increment member

参数说明

• key：有序集合的名称。
• increment：增加的分数值，可以为正数或负数。
• member：有序集合中的成员。

返回值

返回增加后的成员的分数值。如果成员不存在，那么 ZINCRBY 命令将用 0 作为起始分数，然后加上 increment。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些员工和他们的薪水（作为分数）：

redis> ZADD myzset 2000 jack
redis> ZADD myzset 3500 peter
redis> ZADD myzset 5000 tom

现在，我们想要给 jack 的薪水增加 500：

redis> ZINCRBY myzset 500 jack
"2500"

在这个例子中，jack 的薪水从 2000 增加到了 2500，所以命令返回了 2500。

如果我们给一个不存在的成员（比如 jane）增加薪水，Redis 会用 0 作为起始分数：

redis> ZINCRBY myzset 1000 jane
"1000"

在这个例子中，因为 jane 原先不存在于有序集合中，所以 Redis 用 0 作为起始分数，并增加了 1000，最终返回了 1000。

zlexcount key min max

• ZLEXCOUNT 是 Redis 中用于有序集合（sorted set）的命令，但它不是按照分数（score）来计算成员数量的，而是根据成员自身的字符串值（lexicographically，即按字典顺序）来计算在指定范围内的成员数量。这个命令特别适用于那些将字符串作为成员值，并希望按照这些字符串的字典顺序来处理的有序集合。

命令格式

ZLEXCOUNT key min max

参数说明

• key：有序集合的名称。
• min 和 max：指定范围的最小值和最大值，这两个值都是字符串，并且是按照字典顺序来比较的。这两个参数支持以下用法：
  • 使用 + 表示无限大，即包括所有大于 min 的字符串。
  • 使用 - 表示无限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含该字符串本身（闭区间）。
  • 使用 ( 表示不包含该字符串本身（开区间）。如果省略了方括号或圆括号，则默认为闭区间。

返回值

返回一个整数，表示在有序集合 key 中，成员值在 min 和 max 之间（包括等于 min 或 max）的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些字符串成员和它们的分数：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d

现在，我们想要计算成员值在 “b” 和 “d” 之间（包括 “b” 和 “d”）的成员数量：

redis> ZLEXCOUNT myzset "[b" "[d"
(integer) 3

这个命令将返回 3，因为成员 “b”、“c” 和 “d” 的值都在指定的范围内。注意这里我们使用了闭区间，并且由于 Redis 的字符串比较是区分大小写的，所以即使分数相同，成员值也会按照它们的字典顺序来排列和比较。

zrange key start stop [withscores]

ZRANGE 是 Redis 中用于有序集合（sorted set）的命令，用于获取指定范围内的成员列表。这些成员是根据它们的分数（score）来排序的。

命令格式

ZRANGE key start stop [WITHSCORES]

参数说明

• key：有序集合的名称。
• start 和 stop：返回的有序集合成员的索引位置（基于 0 的索引）。start 和 stop 都可以是负数，表示从尾部开始计算索引。例如，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
• [WITHSCORES]：可选参数。如果包含这个参数，那么返回的每个成员后面都会跟着它的分数。

返回值

• 如果没有 [WITHSCORES] 参数，则返回一个包含指定范围内的成员的列表。
• 如果有 [WITHSCORES] 参数，则返回一个包含指定范围内的成员及其对应分数的列表。每个成员和分数都作为列表的一个元素，并且成员和分数是成对出现的。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

现在，我们想要获取索引位置从 0 到 1（包括这两个位置）的成员：

redis> ZRANGE myzset 0 1
1) "a"
2) "b"

如果我们还想要获取这些成员的分数，我们可以使用 [WITHSCORES] 参数：

redis> ZRANGE myzset 0 1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"

注意：在 Redis 中，有序集合成员的分数是唯一的，但是成员本身的值（即字符串值）可以重复。如果有多个成员具有相同的分数，那么它们的相对顺序是根据它们被添加到有序集合中的顺序来确定的。在上面的例子中，我们假设没有成员具有相同的分数，但在实际情况中，这是可能发生的。

zrangebylex key min max [limit offset count]

ZRANGEBYLEX 是 Redis 中用于有序集合（sorted set）的命令，用于根据成员的字典顺序（lexicographically）来获取指定范围内的成员列表。这个命令特别适用于当有序集合被用作字符串集合，并且成员值（而非分数）具有重要性时。

命令格式

ZRANGEBYLEX key min max [LIMIT offset count]

参数说明

• key：有序集合的名称。
• min 和 max：指定范围的最小值和最大值，这两个值都是字符串，并且是按照字典顺序来比较的。这两个参数支持以下用法：
  • 使用 + 表示无限大，即包括所有大于 min 的字符串。
  • 使用 - 表示无限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含该字符串本身（闭区间）。
  • 使用 ( 表示不包含该字符串本身（开区间）。如果省略了方括号或圆括号，则默认为闭区间。
• [LIMIT offset count]：可选参数，用于限制返回结果的数量和起始位置。offset 是返回列表的起始位置（基于 0 的索引），count 是返回的最大元素数量。

返回值

返回一个包含指定范围内的成员的列表。如果使用了 [LIMIT offset count] 参数，则只返回指定范围内的部分成员。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些字符串成员：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d

现在，我们想要获取字典顺序在 “b” 和 “d” 之间（包括 “b” 和 “d”）的成员：

redis> ZRANGEBYLEX myzset "[b" "[d"
1) "b"
2) "c"
3) "d"

如果我们还想要限制返回结果的数量，比如只返回前两个成员，我们可以使用 [LIMIT 0 2] 参数：

redis> ZRANGEBYLEX myzset "[b" "[d" LIMIT 0 2
1) "b"
2) "c"

在这个例子中，我们指定了偏移量为 0（即返回列表的起始位置），并指定了最大元素数量为 2，所以只返回了 “b” 和 “c” 这两个成员。

zrangebyscore key min max [withscores] [limit offset count]

ZRANGEBYSCORE 是 Redis 中用于有序集合（sorted set）的命令，用于获取指定分数范围内的成员列表。这些成员是根据它们的分数（score）来排序的。

命令格式

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

参数说明

• key：有序集合的名称。
• min 和 max：指定分数范围的最小值和最大值。这两个参数支持以下用法：
  • 使用正数表示具体的分数值。
  • 使用 -inf 表示无限小，即包括所有小于 max 的分数。
  • 使用 +inf 表示无限大，即包括所有大于 min 的分数。
  • 在数字前加 ( 表示不包含该分数值本身（开区间）。
  • 在数字前加 [ 表示包含该分数值本身（闭区间，但默认就是闭区间，所以通常省略）。
• [WITHSCORES]：可选参数。如果包含这个参数，那么返回的每个成员后面都会跟着它的分数。
• [LIMIT offset count]：可选参数，用于限制返回结果的数量和起始位置。offset 是返回列表的起始位置（基于 0 的索引），count 是返回的最大元素数量。

返回值

• 返回一个包含指定分数范围内的成员的列表。
• 如果使用了 [WITHSCORES] 参数，则返回的列表中的每个成员后面都会跟着它的分数。
• 如果使用了 [LIMIT offset count] 参数，则只返回指定范围内的部分成员。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

现在，我们想要获取分数在 2 到 4 之间（包括 2 和 4）的成员：

redis> ZRANGEBYSCORE myzset 2 4
1) "b"
2) "c"
3) "d"

如果我们还想要获取这些成员的分数，我们可以使用 [WITHSCORES] 参数：

redis> ZRANGEBYSCORE myzset 2 4 WITHSCORES
1) "b"
2) "2"
3) "c"
4) "3"
5) "d"
6) "4"

如果我们只想获取前两个成员，我们可以使用 [LIMIT 0 2] 参数：

redis> ZRANGEBYSCORE myzset 2 4 LIMIT 0 2
1) "b"
2) "c"

zrank key member

ZRANK 是 Redis 中用于有序集合（sorted set）的命令，它返回指定成员在有序集合中的排名。排名是根据成员的分数（score）来确定的，分数最小的成员排名为 0。

命令格式

ZRANK key member

参数说明

• key：有序集合的名称。
• member：需要获取排名的成员。

返回值

• 如果成员存在于有序集合中，则返回该成员的排名（基于 0 的索引）。
• 如果成员不存在于有序集合中，则返回 nil 或 None（取决于 Redis 客户端或库的返回方式）。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

现在，我们想要获取成员 b 的排名：

redis> ZRANK myzset b
(integer) 1

因为成员 b 的分数是 2，它在有序集合中的排名是 1（基于 0 的索引）。注意，即使有两个或更多的成员具有相同的分数，它们的排名也是根据它们被添加到有序集合中的顺序来确定的。在上面的例子中，如果我们添加了一个分数也为 2 的成员 e，那么 e 的排名将会在 b 之后（假设 e 是在 b 之后添加的）。

zrem key member [member...]

ZREM 是 Redis 中用于有序集合（sorted set）的命令，用于移除有序集合中的一个或多个成员。

命令格式

ZREM key member [member ...]

参数说明

• key：有序集合的名称。
• member [member ...]：一个或多个需要被移除的成员。

返回值

• 被成功移除的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

现在，我们想要移除成员 b 和 d：

redis> ZREM myzset b d
(integer) 2

因为成功移除了两个成员，所以返回了 2。如果我们再次检查 myzset 的内容，会发现成员 b 和 d 已经不存在了：

redis> ZRANGE myzset 0 -1
1) "a"
2) "c"

在这个例子中，ZRANGE myzset 0 -1 命令用于获取有序集合 myzset 中的所有成员，结果只包含了 a 和 c，说明 b 和 d 已经被成功移除。

zremrangebylex key min max

ZREMRANGEBYLEX 是 Redis 中用于有序集合（sorted set）的命令，它根据成员的字典顺序（lexicographically）来移除指定范围内的成员。这个命令特别适用于当有序集合被用作字符串集合，并且成员值（即字符串值）具有重要性时。

命令格式

ZREMRANGEBYLEX key min max

参数说明

• key：有序集合的名称。
• min 和 max：指定范围的最小值和最大值，这两个值都是字符串，并且是按照字典顺序来比较的。这两个参数支持以下用法：
  • 使用 + 表示无限大，即包括所有大于 min 的字符串。
  • 使用 - 表示无限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含该字符串本身（闭区间）。
  • 使用 ( 表示不包含该字符串本身（开区间）。如果省略了方括号或圆括号，则默认为闭区间。

返回值

• 被成功移除的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些字符串成员：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d
redis> ZADD myzset 0 e

现在，我们想要移除字典顺序在 “b” 和 “d” 之间（包括 “b” 但不包括 “d”）的成员：

redis> ZREMRANGEBYLEX myzset "[b" "(d"
(integer) 2

这个命令移除了成员 “b” 和 “c”，并返回了 2，表示成功移除了两个成员。如果我们再次检查 myzset 的内容，会发现成员 “b” 和 “c” 已经不存在了：

redis> ZRANGE myzset 0 -1
1) "a"
2) "d"
3) "e"

在这个例子中，ZRANGE myzset 0 -1 命令用于获取有序集合 myzset 中的所有成员，结果只包含了 “a”、“d” 和 “e”，说明 “b” 和 “c” 已经被成功移除。

zremrangebyrank key start stop

ZREMRANGEBYRANK 是 Redis 中用于有序集合（sorted set）的命令，它根据成员的排名（rank）来移除指定范围内的成员。排名是根据成员的分数（score）来确定的，分数最低的成员排名为 0，次低的为 1，依此类推。如果成员的分数相同，则它们的排名是连续的，但 Redis 会根据成员在集合中的插入顺序来决定它们的相对排名。

命令格式

ZREMRANGEBYRANK key start stop

参数说明

• key：有序集合的名称。
• start 和 stop：指定范围的开始和结束排名（包含 start，但不包含 stop）。排名是从 0 开始的。

返回值

• 被成功移除的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要移除排名在 1 到 3 之间（包括排名 1，但不包括排名 3）的成员：

redis> ZREMRANGEBYRANK myzset 1 3
(integer) 2

这个命令移除了排名为 1 和 2 的成员，即 “b” 和 “c”，并返回了 2，表示成功移除了两个成员。如果我们再次检查 myzset 的内容，会发现成员 “b” 和 “c” 已经不存在了：

redis> ZRANGE myzset 0 -1 WITHSCORES
1) "a"
2) "1"
3) "d"
4) "4"
5) "e"
6) "5"

在这个例子中，ZRANGE myzset 0 -1 WITHSCORES 命令用于获取有序集合 myzset 中的所有成员及其分数，结果只包含了 “a”、“d” 和 “e”，说明 “b” 和 “c” 已经被成功移除。

zremrangebyscore key min max

ZREMRANGEBYSCORE 是 Redis 中用于有序集合（sorted set）的命令，它根据成员的分数（score）来移除指定范围内的成员。这个命令特别适用于当你想要基于分数来批量删除有序集合中的成员时。

命令格式

ZREMRANGEBYSCORE key min max

参数说明

• key：有序集合的名称。
• min 和 max：指定分数范围的最小值和最大值。这两个参数支持以下用法：
  • 使用正数表示具体的分数值。
  • 使用 -inf 表示无限小，即包括所有小于 max 的分数。
  • 使用 +inf 表示无限大，即包括所有大于 min 的分数。
  • 在数字前加 ( 表示不包含该分数值本身（开区间）。
  • 在数字前加 [ 表示包含该分数值本身（闭区间，但默认就是闭区间，所以通常省略）。

返回值

• 被成功移除的成员数量。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要移除分数在 2 到 4 之间（包括 2 和 4）的成员：

redis> ZREMRANGEBYSCORE myzset 2 4
(integer) 3

这个命令移除了分数为 2、3 和 4 的成员，即 “b”、“c” 和 “d”，并返回了 3，表示成功移除了三个成员。如果我们再次检查 myzset 的内容，会发现成员 “b”、“c” 和 “d” 已经不存在了：

redis> ZRANGE myzset 0 -1 WITHSCORES
1) "a"
2) "1"
3) "e"
4) "5"

在这个例子中，ZRANGE myzset 0 -1 WITHSCORES 命令用于获取有序集合 myzset 中的所有成员及其分数，结果只包含了 “a” 和 “e”，说明 “b”、“c” 和 “d” 已经被成功移除。

zrevrange key start stop [withscores]

ZREVRANGE 是 Redis 中用于有序集合（sorted set）的命令，它返回指定有序集合中成员按分数从高到低排序后的一个子集。与 ZRANGE 命令相反，ZREVRANGE 是按降序排列的。

命令格式

ZREVRANGE key start stop [WITHSCORES]

参数说明

• key：有序集合的名称。
• start 和 stop：指定返回成员的索引范围。索引是基于 0 的，其中 0 是最高分的成员（第一个），-1 是最低分的成员（最后一个），-2 是次低分的成员，依此类推。start 和 stop 都是包含边界的，除非指定了开区间（即使用了 (）。
• [WITHSCORES]：一个可选参数，如果指定了这个选项，返回的成员会和它们的分数一起被返回。

返回值

• 一个包含指定范围内成员的列表。如果指定了 WITHSCORES 选项，则返回每个成员后跟其分数的列表。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要获取分数从高到低排序的前两个成员及其分数：

redis> ZREVRANGE myzset 0 1 WITHSCORES
1) "e"
2) "5"
3) "d"
4) "4"

在这个例子中，我们指定了 start 为 0（即最高分的成员）和 stop 为 1（即次高分的成员），并且使用了 WITHSCORES 选项来同时获取成员和它们的分数。返回的结果包含了成员 “e” 和 “d” 以及它们的分数 “5” 和 “4”。

如果我们只想要获取成员而不带分数，可以省略 WITHSCORES 选项：

redis> ZREVRANGE myzset 0 1
1) "e"
2) "d"

这样，返回的结果就只包含了成员 “e” 和 “d”。

zrevrangebyscore key max min [withscores]

在 Redis 中，ZREVRANGEBYSCORE 命令用于从有序集合（sorted set）中获取分数在指定范围内的成员，并且这些成员是按分数从高到低排序的。这与 ZRANGEBYSCORE 命令相反，后者是按分数从低到高排序的。

命令格式

ZREVRANGEBYSCORE key max min [WITHSCORES]

注意这里的 max 和 min 是按分数从高到低的顺序排列的，所以 max 应该是分数较高的边界，而 min 是分数较低的边界。

参数说明

• key：有序集合的名称。
• max 和 min：指定分数范围的最大值和最小值。这两个参数支持以下用法：
  • 使用正数表示具体的分数值。
  • 使用 +inf 表示无限大，即包括所有大于 min 的分数。
  • 使用 -inf 表示无限小，即包括所有小于 max 的分数。
  • 在数字前加 ( 表示不包含该分数值本身（开区间）。
  • 在数字前加 [ 表示包含该分数值本身（闭区间，但默认就是闭区间，所以通常省略）。
• [WITHSCORES]：一个可选参数，如果指定了这个选项，返回的成员会和它们的分数一起被返回。

返回值

• 一个包含指定分数范围内成员的列表。如果指定了 WITHSCORES 选项，则返回每个成员后跟其分数的列表。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要获取分数在 3 到 1 之间（包括 3 但不包括 1）的成员及其分数：

redis> ZREVRANGEBYSCORE myzset 3 1 WITHSCORES
1) "c"
2) "3"
2) "b"
3) "2"

注意：在这个例子中，由于我们想要的是降序排列（分数从高到低），所以 max 是 3 而 min 是 1。返回的结果包含了成员 “c” 和 “b” 以及它们的分数 “3” 和 “2”。

如果我们只想要获取成员而不带分数，可以省略 WITHSCORES 选项：

redis> ZREVRANGEBYSCORE myzset 3 1
1) "c"
2) "b"

这样，返回的结果就只包含了成员 “c” 和 “b”。

zrevrank key member

在 Redis 中，ZREVRANK 命令用于获取有序集合（sorted set）中指定成员的排名，但是该排名是基于分数从高到低排序的。与 ZRANK 命令相反，ZRANK 是基于分数从低到高排序的。

命令格式

ZREVRANK key member

参数说明

• key：有序集合的名称。
• member：要获取排名的成员。

返回值

• 如果成员存在于有序集合中，则返回该成员的排名（从 0 开始，其中 0 是最高分的成员）。
• 如果成员不存在于有序集合中，则返回 nil 或 -1（具体取决于 Redis 的版本和配置）。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要获取成员 “c” 的排名（基于分数从高到低）：

redis> ZREVRANK myzset c
(integer) 2

在这个例子中，成员 “c” 的分数是 3，它在有序集合 myzset 中的排名（从高到低）是 2（因为 “e” 和 “d” 的分数更高）。

如果我们尝试获取一个不存在的成员的排名：

redis> ZREVRANK myzset f
(nil)

或者在某些 Redis 版本中，可能会返回 -1 表示成员不存在：

redis> ZREVRANK myzset f
(integer) -1

zscore key member

在 Redis 中，ZSCORE 命令用于获取有序集合（sorted set）中指定成员的分数。如果成员存在于有序集合中，该命令将返回其分数；如果成员不存在，则返回 nil 或空值。

命令格式

ZSCORE key member

参数说明

• key：有序集合的名称。
• member：要获取分数的成员。

返回值

• 如果成员存在于有序集合中，则返回该成员的分数。
• 如果成员不存在于有序集合中，则返回 nil 或空值。

示例

假设我们有一个名为 myzset 的有序集合，其中存储了一些成员和它们的分数：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

现在，我们想要获取成员 “c” 的分数：

redis> ZSCORE myzset c
"3"

在这个例子中，成员 “c” 的分数是 3，所以 ZSCORE 命令返回了 "3"。

如果我们尝试获取一个不存在的成员的分数：

redis> ZSCORE myzset f
(nil)

命令返回了 (nil)，表示成员 “f” 不存在于有序集合 myzset 中。

zinterstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

在 Redis 中，ZINTERSTORE 命令用于计算多个有序集合（sorted sets）的交集，并将结果存储在另一个有序集合中。这个命令在处理多个有序集合的交集运算时非常有用。

命令格式

ZINTERSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

参数说明

• destination：结果集的目标键名，用于存储交集结果。
• numkeys：接下来要指定的有序集合的数量。
• key1 [key2 ...]：一个或多个有序集合的键名，用于计算交集。
• WEIGHTS weight1 [weight2 ...]（可选）：每个有序集合的权重，用于计算带权重的交集。如果没有指定权重，则所有有序集合的权重默认为 1。
• AGGREGATE SUM|MIN|MAX（可选）：交集成员分数的聚合方式。默认为 SUM。
  • SUM：交集成员的分数为它们在所有输入有序集合中的分数之和。
  • MIN：交集成员的分数为它们在所有输入有序集合中的分数的最小值。
  • MAX：交集成员的分数为它们在所有输入有序集合中的分数的最大值。

返回值

• 交集结果集中元素的数量。

示例

假设我们有三个有序集合 zset1、zset2 和 zset3：

redis> ZADD zset1 1 a 2 b 3 c
redis> ZADD zset2 2 b 3 c 4 d
redis> ZADD zset3 3 c 4 d 5 e

现在，我们想要计算 zset1 和 zset2 的交集，并将结果存储在 zset_intersection 中：

redis> ZINTERSTORE zset_intersection 2 zset1 zset2
(integer) 2
redis> ZRANGE zset_intersection 0 -1 WITHSCORES
1) "b"
2) "2"
3) "c"
4) "3"

如果我们想要计算带权重的交集（比如，我们想要 zset1 的分数乘以 2，zset2 的分数乘以 3），并将结果存储在 zset_weighted_intersection 中：

redis> ZINTERSTORE zset_weighted_intersection 2 zset1 zset2 WEIGHTS 2 3
(integer) 2
redis> ZRANGE zset_weighted_intersection 0 -1 WITHSCORES
1) "b"
2) "10"  # 2 * 2 + 3 * 2
3) "c"
4) "15"  # 3 * 2 + 3 * 3

最后，如果我们想要改变聚合方式，比如使用 MIN 而不是 SUM，我们可以这样做：

redis> ZINTERSTORE zset_min_intersection 2 zset1 zset2 AGGREGATE MIN
(integer) 2
redis> ZRANGE zset_min_intersection 0 -1 WITHSCORES
1) "b"
2) "2"  # 最小值 2
3) "c"
4) "3"  # 最小值 3

zunionstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

在 Redis 中，ZUNIONSTORE 命令用于计算多个有序集合（sorted sets）的并集，并将结果存储在另一个有序集合中。这个命令在处理多个有序集合的并集运算时非常有用。

命令格式

ZUNIONSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

参数说明

• destination：结果集的目标键名，用于存储并集结果。
• numkeys：接下来要指定的有序集合的数量。
• key1 [key2 ...]：一个或多个有序集合的键名，用于计算并集。
• WEIGHTS weight1 [weight2 ...]（可选）：每个有序集合的权重，用于计算带权重的并集。如果没有指定权重，则所有有序集合的权重默认为 1。
• AGGREGATE SUM|MIN|MAX（可选）：并集成员分数的聚合方式。默认为 SUM。
  • SUM：并集成员的分数为它们在所有输入有序集合中的分数之和（如果成员只存在于一个集合中，则直接使用该集合的分数）。
  • MIN：并集成员的分数为它们在所有输入有序集合中的分数的最小值。
  • MAX：并集成员的分数为它们在所有输入有序集合中的分数的最大值。

返回值

• 并集结果集中元素的数量。

示例

假设我们有三个有序集合 zset1、zset2 和 zset3：

redis> ZADD zset1 1 a 2 b 3 c
redis> ZADD zset2 2 b 3 c 4 d
redis> ZADD zset3 3 c 4 d 5 e

现在，我们想要计算 zset1、zset2 和 zset3 的并集，并将结果存储在 zset_union 中：

redis> ZUNIONSTORE zset_union 3 zset1 zset2 zset3
(integer) 5
redis> ZRANGE zset_union 0 -1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
7) "d"
8) "4"
9) "e"
10) "5"

如果我们想要计算带权重的并集（比如，我们想要 zset1 的分数乘以 2，zset2 的分数乘以 3，zset3 的分数乘以 4），并将结果存储在 zset_weighted_union 中：

redis> ZUNIONSTORE zset_weighted_union 3 zset1 zset2 zset3 WEIGHTS 2 3 4
(integer) 5
redis> ZRANGE zset_weighted_union 0 -1 WITHSCORES
1) "a"
2) "2"  # 1 * 2
3) "b"
4) "10"  # 2 * 2 + 2 * 3
5) "c"
6) "23"  # 3 * 2 + 3 * 3 + 3 * 4
7) "d"
8) "22"  # 4 * 3 + 4 * 4
9) "e"
10) "20"  # 5 * 4

最后，如果我们想要改变聚合方式，比如使用 MAX 而不是 SUM，我们可以这样做：

redis> ZUNIONSTORE zset_max_union 3 zset1 zset2 zset3 AGGREGATE MAX
(integer) 5
redis> ZRANGE zset_max_union 0 -1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
7) "d"
8) "4"
9) "e"
10) "5"

注意，在使用 MAX 或 MIN 聚合方式时，结果集中的分数是基于所有输入有序集合中该成员的最大或最小分数。由于成员 “a” 只存在于 zset1 中，所以它的分数在 zset_max_union 中仍然是 1。同样地，“b” 的分数是 2（因为 “b” 在 `zset1

zscan key cursor [MATCH pattern] [COUNT count]

ZSCAN 是 Redis 中的一个命令，用于迭代有序集合（sorted set）中的元素及其分数。与 KEYS 命令不同，ZSCAN 提供了一个基于游标的迭代器，可以在不阻塞 Redis 服务器的情况下安全地迭代大型数据集。

命令格式

ZSCAN key cursor [MATCH pattern] [COUNT count]

参数说明

• key：要扫描的有序集合的名称。
• cursor：游标，用于迭代。初始值为 0，每次调用 ZSCAN 时都会返回一个新的游标，直到游标返回 0 表示迭代完成。
• MATCH pattern（可选）：用于过滤返回的元素。只有符合给定模式的元素才会被返回。
• COUNT count（可选）：指定每次迭代返回的元素数量。这是一个提示，Redis 可能会返回更少或更多的元素。

返回值

• 一个包含两个元素的数组：
  1. 新的游标。
  2. 一个数组，其中每个元素都是一个包含两个元素的数组，表示有序集合中的一个成员及其分数。

示例

假设我们有一个名为 myzset 的有序集合：

redis> ZADD myzset 1 a 2 b 3 c 4 d 5 e

我们可以使用 ZSCAN 来迭代这个有序集合：

redis> ZSCAN myzset 0
1) "0"
2) 1) "a"
   2) "1"
   3) "b"
   4) "2"
   5) "c"
   6) "3"
   7) "d"
   8) "4"
   9) "e"
  10) "5"

在这个例子中，由于有序集合很小，所以一次性返回了所有元素。但在大型有序集合中，你可能需要多次调用 ZSCAN 并使用返回的游标来继续迭代。

我们还可以使用 MATCH 参数来过滤结果：

redis> ZSCAN myzset 0 MATCH b*
1) "0"
2) 1) "b"
   2) "2"
   3) "c"
   4) "3"

在这个例子中，只有以 “b” 开头的成员（即 “b” 和 “c”）被返回。注意，虽然 “c” 不以 “b” 开头，但由于 Redis 的内部实现，它可能作为匹配 “b*” 的结果的一部分被返回。

你还可以使用 COUNT 参数来指定每次迭代返回的元素数量，但请注意这是一个提示，Redis 可能会返回不同数量的元素。