Redis-Sorted-Sets相关命令

BZMPOP timeout numkeys key [key ...] MIN|MAX [COUNT count]

自 7.0.0 起可用。

时间复杂度： O(K) + O(N*log(M)) 其中 K 是提供的键的数量，N 是排序集中的元素数，M 是弹出的元素数。

BZMPOP是 ZMPOP 的阻塞变体。

当任何排序集包含元素时，此命令的行为与ZMPOP完全相同。在MULTI / EXEC块内使用时，此命令的行为与ZMPOP完全相同。当所有排序集为空时，Redis 将阻止连接，直到另一个客户端将成员添加到其中一个键或直到timeout（指定要阻止的最大秒数的双精度值）过去。Atimeout为零可用于无限期阻塞。

有关详细信息，请参阅ZMPOP。

返回值

数组回复：具体来说：

Anil当没有元素可以被弹出时。
一个双元素数组，第一个元素是从中弹出元素的键的名称，第二个元素是弹出元素的数组。elements 数组中的每个条目也是一个包含成员及其分数的数组。

BZPOPMAX key [key ...] timeout

从 5.0.0 开始可用。

时间复杂度： O(log(N))，其中 N 是排序集中的元素数。

BZPOPMAX是有序集ZPOPMAX原语的阻塞变体。

它是阻塞版本，因为当没有任何成员可以从任何给定的排序集中弹出时，它会阻塞连接。得分最高的成员从非空的第一个排序集中弹出，给定的键按给定的顺序检查。

该timeout参数被解释为指定要阻止的最大秒数的双精度值。零超时可用于无限期阻塞。

有关确切的语义，请参阅BZPOPMIN 文档，因为BZPOPMAX与BZPOPMIN 相同，唯一的区别是它弹出得分最高的成员，而不是弹出得分最低的成员。

返回值

数组回复：具体来说：

nil当没有元素可以弹出并且超时过期时的多批量。
一个三元素 multi-bulk，第一个元素是弹出成员的键的名称，第二个元素是弹出的成员本身，第三个元素是弹出元素的分数。

例子

redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMAX zset1 zset2 0
1) "zset1"
2) "c"
3) "2"

历史

Redis 版本 >= 6.0.0：timeout 被解释为双精度而不是整数。

BZPOPMIN key [key ...] timeout

从 5.0.0 开始可用。

时间复杂度： O(log(N))，其中 N 是排序集中的元素数。

BZPOPMIN是有序集ZPOPMIN原语的阻塞变体。

它是阻塞版本，因为当没有任何成员可以从任何给定的排序集中弹出时，它会阻塞连接。从第一个非空的排序集中弹出得分最低的成员，并按照给定的顺序检查给定的键。

该timeout参数被解释为指定要阻止的最大秒数的双精度值。零超时可用于无限期阻塞。

有关确切的语义，请参阅BLPOP 文档，因为BZPOPMIN与BLPOP相同，唯一的区别是从中弹出的数据结构。

返回值

数组回复：具体来说：

nil当没有元素可以弹出并且超时过期时的多批量。
一个三元素 multi-bulk，第一个元素是弹出成员的键的名称，第二个元素是弹出的成员本身，第三个元素是弹出元素的分数。

例子

redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMIN zset1 zset2 0
1) "zset1"
2) "a"
3) "0"

历史

Redis 版本 >= 6.0.0：timeout 被解释为双精度而不是整数。

ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]

从 1.2.0 开始可用。

时间复杂度： O(log(N)) 对于添加的每个项目，其中 N 是排序集中的元素数。

将具有指定分数的所有指定成员添加到存储在的排序集中key。可以指定多个分数/成员对。如果指定的成员已经是排序集的成员，则更新分数并将元素重新插入到正确的位置以确保正确的排序。

如果key不存在，则创建一个以指定成员作为唯一成员的新排序集，就像排序集为空一样。如果键存在但不包含排序集，则返回错误。

分数值应该是双精度浮点数的字符串表示形式。+inf和-inf值也是有效值。

ZADD 选项

ZADD 支持选项列表，在键名之后和第一个分数参数之前指定。选项是：

XX：只更新已经存在的元素。不要添加新元素。
NX：只添加新元素。不要更新已经存在的元素。
LT：仅当新分数低于当前分数时才更新现有元素。此标志不会阻止添加新元素。
GT：仅当新分数大于当前分数时才更新现有元素。此标志不会阻止添加新元素。
CH：将返回值从添加的新元素数修改为改变的元素总数（CH 是changed的缩写）。更改的元素是添加的新元素和已更新分数的元素。因此，命令行中指定的与过去得分相同的元素不计算在内。注意：通常ZADD的返回值只计算添加的新元素的数量。
INCR：当指定此选项时，ZADD 的行为类似于ZINCRBY。在此模式下只能指定一个分数元素对。

注意：GT、LT和NX选项是互斥的。

可精确表达的整数分数范围

Redis 排序集使用双 64 位浮点数来表示分数。在我们支持的所有架构中，这表示为IEEE 754 浮点数-(2^{53)，它能够精确地表示介于两者之间的整数+(2}53)。在更实际的情况下，-9007199254740992 和 9007199254740992 之间的所有整数都可以完美表示。较大的整数或分数在内部以指数形式表示，因此您可能只获得您设置为分数的十进制数或非常大整数的近似值。

排序集 101

排序集按其分数升序排序。同一个元素只存在一次，不允许有重复的元素。分数可以被ZADD修改，它会更新元素分数，作为副作用，它在排序集上的位置，以及ZINCRBY可以用来更新分数相对于它的先前值。

可以使用ZSCORE命令检索元素的当前分数，该命令还可用于验证元素是否已存在。

有关排序集的介绍，请参阅排序集上的数据类型页面。

分数相同的元素

由于每个元素都是唯一的，因此不能在排序集中重复相同的元素，但可以添加多个具有相同 score 的不同元素。当多个元素具有相同的分数时，它们是按字典顺序排序的（它们仍然以分数作为第一个键进行排序，但是在局部，所有具有相同分数的元素都按字典顺序相对排序）。

使用的字典顺序是二进制的，它将字符串作为字节数组进行比较。

如果用户以相同的分数（例如 0）插入一个有序集合中的所有元素，则有序集合的所有元素都按字典顺序排序，并且可以使用命令ZRANGEBYLEX对元素进行范围查询（注：也可以使用ZRANGEBYSCORE按分数范围查询排序集）。

返回值

整数回复，具体来说：

当不使用可选参数时，添加到排序集中的元素数量（不包括分数更新）。
如果CH指定了该选项，则为已更改（添加或更新）的元素数。

如果指定了INCR选项，则返回值为Bulk string reply：

member（双精度浮点数）的新分数表示为字符串，或者nil操作是否中止（当使用XX或NX选项调用时）

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 1 "uno"
(integer) 1
redis> ZADD myzset 2 "two" 3 "three"
(integer) 2
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "uno"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"
redis>

历史

Redis 版本 >= 2.4.0：接受多个元素。
Redis 版本 >= 3.0.2：添加了 XX、NX、CH 和 INCR 选项。
Redis 版本 >= 6.2.0：添加了 GT 和 LT 选项。

ZCARD key

从 1.2.0 开始可用。

时间复杂度： O(1)

返回存储在的排序集的排序集基数（元素数）key。

返回值

整数回复：排序集的基数（元素数），或者0 如果key不存在。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZCARD myzset
(integer) 2
redis>

ZCOUNT key min max

从 2.0.0 开始可用。

时间复杂度： O(log(N))，其中 N 是排序集中的元素数。

返回排序集合中的元素数，key分数介于 min和之间max。

min和参数具有与ZRANGEBYSCORE描述的max相同语义。

注意：该命令的复杂度仅为O(log(N))，因为它使用元素等级（请参阅ZRANK）来了解范围。因此，不需要做与范围大小成比例的工作。

返回值

整数回复：指定分数范围内的元素数。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZCOUNT myzset -inf +inf
(integer) 3
redis> ZCOUNT myzset (1 3
(integer) 2
redis>

ZDIFF numkeys key [key ...] [WITHSCORES]

从 6.2.0 开始可用。

时间复杂度： O(L + (NK)log(N)) 最坏情况，其中 L 是所有集合中元素的总数，N 是第一个集合的大小，K 是结果集的大小。

此命令类似于ZDIFFSTORE，但不是存储结果排序集，而是返回给客户端。

返回值

数组回复：差异的结果（如果给出选项，可以选择他们的分数WITHSCORES）。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset1 3 "three"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZDIFF 2 zset1 zset2
1) "three"
redis> ZDIFF 2 zset1 zset2 WITHSCORES
1) "three"
2) "3"
redis>

ZDIFFSTORE destination numkeys key [key ...]

从 6.2.0 开始可用。

时间复杂度： O(L + (NK)log(N)) 最坏情况，其中 L 是所有集合中元素的总数，N 是第一个集合的大小，K 是结果集的大小。

计算第一个和所有连续输入排序集之间的差异，并将结果存储在destination. 输入键的总数由指定numkeys。

不存在的键被认为是空集。

如果destination已经存在，则将其覆盖。

返回值

整数回复：结果排序集中的元素数 destination。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset1 3 "three"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZDIFFSTORE out 2 zset1 zset2
(integer) 1
redis> ZRANGE out 0 -1 WITHSCORES
1) "three"
2) "3"
redis>

ZINCRBY key increment member

从 1.2.0 开始可用。

时间复杂度： O(log(N))，其中 N 是排序集中的元素数。

增加member存储在keyby 的排序集中的分数increment。如果member在排序集中不存在，则将其添加increment为它的分数（就好像它之前的分数是0.0）。如果key不存在，member则创建一个以指定为唯一成员的新排序集。

key存在但不包含排序集时返回错误。

该score值应该是数字值的字符串表示形式，并接受双精度浮点数。可以提供一个负值来降低分数。

返回值

批量字符串回复member：（双精度浮点数）的新分数，以字符串表示。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZINCRBY myzset 2 "one"
"3"
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "two"
2) "2"
3) "one"
4) "3"
redis>

ZINTER numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]

从 6.2.0 开始可用。

时间复杂度： O(NK)+O(Mlog(M)) 最坏情况，N 是最小的输入排序集，K 是输入排序集的数量，M 是结果排序集中的元素数.

此命令类似于ZINTERSTORE，但不是存储结果排序集，而是返回给客户端。

有关WEIGHTS和AGGREGATE选项的说明，请参阅ZUNIONSTORE。

返回值

数组回复：交集的结果（如果给出选项，则可以选择它们的分数WITHSCORES）。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZINTER 2 zset1 zset2
1) "one"
2) "two"
redis> ZINTER 2 zset1 zset2 WITHSCORES
1) "one"
2) "2"
3) "two"
4) "4"
redis>

ZINTERCARD numkeys key [key ...] [LIMIT limit]

自 7.0.0 起可用。

时间复杂度： O(N*K) 最坏情况，N 是最小的输入排序集，K 是输入排序集的数量。

此命令类似于ZINTER，但它不返回结果集，而是只返回结果的基数。

不存在的键被认为是空集。如果其中一个键是空集，则结果集也是空的（因为集合与空集的交集总是导致空集）。

默认情况下，该命令计算所有给定集合的交集的基数。当提供可选LIMIT参数（默认为 0，表示无限制）时，如果交集基数在计算过程中达到极限，算法将退出并产生极限作为基数。这样的实现确保了对限制低于实际交叉点基数的查询的显着加速。

返回值

整数回复：结果交集中的元素数。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZINTER 2 zset1 zset2
1) "one"
2) "two"
redis> ZINTERCARD 2 zset1 zset2
ERR Unknown or disabled command 'ZINTERCARD'
redis> ZINTERCARD 2 zset1 zset2 LIMIT 1
ERR Unknown or disabled command 'ZINTERCARD'
redis>

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

从 2.0.0 开始可用。

时间复杂度： O(NK)+O(Mlog(M)) 最坏情况，N 是最小的输入排序集，K 是输入排序集的数量，M 是结果排序集中的元素数.

计算numkeys由指定键给定的排序集的交集，并将结果存储在destination. numkeys在传递输入键和其他（可选）参数之前，必须提供输入键的数量 ( )。

默认情况下，一个元素的结果分数是它在它所在的排序集中的分数的总和。因为交集要求元素是每个给定排序集的成员，所以结果排序集中每个元素的分数等于输入排序集的数量。

有关WEIGHTS和AGGREGATE选项的说明，请参阅ZUNIONSTORE。

如果destination已经存在，则将其覆盖。

返回值

整数回复：结果排序集中的元素数 destination。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 2
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "two"
4) "10"
redis>

ZLEXCOUNT key min max

自 2.8.9 起可用。

时间复杂度： O(log(N))，其中 N 是排序集中的元素数。

当排序集中的所有元素以相同的分数插入时，为了强制按字典顺序，此命令返回排序集中的元素数量，key其值介于min和之间max。

min和参数的max含义与为 ZRANGEBYLEX描述的含义相同。

注意：该命令的复杂度仅为O(log(N))，因为它使用元素等级（请参阅ZRANK）来了解范围。因此，不需要做与范围大小成比例的工作。

返回值

整数回复：指定分数范围内的元素数。

例子

redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e
(integer) 5
redis> ZADD myzset 0 f 0 g
(integer) 2
redis> ZLEXCOUNT myzset - +
(integer) 7
redis> ZLEXCOUNT myzset [b [f
(integer) 5
redis>

ZMPOP numkeys key [key ...] MIN|MAX [COUNT count]

自 7.0.0 起可用。

时间复杂度： O(K) + O(N*log(M)) 其中 K 是提供的键的数量，N 是排序集中的元素数，M 是弹出的元素数。

从提供的键名列表中的第一个非空排序集中弹出一个或多个元素，它们是成员分数对。

ZMPOP和BZMPOP类似于以下更有限的命令：

ZPOPMIN或ZPOPMAX只需要一个键，并且可以返回多个元素。
BZPOPMIN或BZPOPMAX接受多个键，但仅从一个键返回一个元素。
有关此命令的阻塞变体，请参见BZMPOP。

使用MIN修饰符时，弹出的元素是第一个非空排序集中得分最低的元素。MAX修饰符会弹出得分最高的元素。可选项COUNT可用于指定要弹出的元素数量，默认设置为 1。

弹出元素的数量是排序集的基数和COUNT值中的最小值。

返回值

数组回复：具体来说：

Anil当没有元素可以被弹出时。
一个双元素数组，第一个元素是从中弹出元素的键的名称，第二个元素是弹出元素的数组。elements 数组中的每个条目也是一个包含成员及其分数的数组。

例子

redis> ZMPOP 1 notsuchkey MIN
ERR Unknown or disabled command 'ZMPOP'
redis> ZADD myzset 1 "one" 2 "two" 3 "three"
(integer) 3
redis> ZMPOP 1 myzset MIN
ERR Unknown or disabled command 'ZMPOP'
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"
redis> ZMPOP 1 myzset MAX COUNT 10
ERR Unknown or disabled command 'ZMPOP'
redis> ZADD myzset2 4 "four" 5 "five" 6 "six"
(integer) 3
redis> ZMPOP 2 myzset myzset2 MIN COUNT 10
ERR Unknown or disabled command 'ZMPOP'
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"
redis> ZMPOP 2 myzset myzset2 MAX COUNT 10
ERR Unknown or disabled command 'ZMPOP'
redis> ZRANGE myzset2 0 -1 WITHSCORES
1) "four"
2) "4"
3) "five"
4) "5"
5) "six"
6) "6"
redis> EXISTS myzset myzset2
(integer) 2
redis>

ZMSCORE key member [member ...]

从 6.2.0 开始可用。

时间复杂度： O(N)，其中 N 是被请求的成员数。

members返回与存储在的排序集中的指定相关联的分数key。

对于member排序集中不存在的每一个，nil都会返回一个值。

返回值

数组回复：分数列表或nil与指定member值相关联（双精度浮点数），表示为字符串。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZMSCORE myzset "one" "two" "nofield"
1) "1"
2) "2"
3) (nil)
redis>

ZPOPMAX key [count]

从 5.0.0 开始可用。

时间复杂度： O(log(N)*M)，其中 N 是排序集中的元素数，M 是弹出的元素数。

删除并返回count存储在的排序集中得分最高的成员key。

未指定时，默认值为count1。指定count 高于排序集基数的值不会产生错误。返回多个元素时，得分最高的将是第一个，其次是得分较低的元素。

返回值

数组回复：弹出元素和分数的列表。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMAX myzset
1) "three"
2) "3"
redis>

ZPOPMIN key [count]

从 5.0.0 开始可用。

时间复杂度： O(log(N)*M)，其中 N 是排序集中的元素数，M 是弹出的元素数。

删除并返回count存储在的排序集中得分最低的成员key。

未指定时，默认值为count1。指定count 高于排序集基数的值不会产生错误。返回多个元素时，得分最低的将是第一个，其次是得分较高的元素。

返回值

数组回复：弹出元素和分数的列表。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMIN myzset
1) "one"
2) "1"
redis>

ZRANDMEMBER key [count [WITHSCORES]]

从 6.2.0 开始可用。

时间复杂度： O(N)，其中 N 是返回的元素数

当仅使用key参数调用时，从存储在的已排序集合值中返回一个随机元素key。

如果提供的参数是正数，则返回一个不同元素count的数组。数组的长度是排序集的基数 ( ZCARD )，以较低者为准。count

如果使用否定调用，则行为会发生变化，并且允许该命令多次count返回相同的元素。在这种情况下，返回元素的数量是指定的绝对值。count

可选WITHSCORES修饰符更改回复，使其包含从排序集中随机选择的元素的相应分数。

返回值

Bulk string reply：没有附加count参数，该命令返回一个带有随机选择元素的 Bulk Reply，或者nil当key不存在时。

数组回复：当附加count参数被传递时，该命令返回一个元素数组，key如果不存在则返回一个空数组。如果WITHSCORES使用了修饰符，则回复是列表元素及其来自排序集中的分数。

例子

redis> ZADD dadi 1 uno 2 due 3 tre 4 quattro 5 cinque 6 sei
(integer) 6
redis> ZRANDMEMBER dadi
ERR Unknown or disabled command 'ZRANDMEMBER'
redis> ZRANDMEMBER dadi
ERR Unknown or disabled command 'ZRANDMEMBER'
redis> ZRANDMEMBER dadi -5 WITHSCORES
ERR Unknown or disabled command 'ZRANDMEMBER'
redis>

通过计数时的行为规范

当count参数为正值时，此命令的行为如下：

不返回重复的元素。
如果count大于排序集的基数，则该命令将仅返回整个排序集而不返回其他元素。
回复中元素的顺序并不是真正随机的，所以如果需要，由客户端来打乱它们。

当count为负值时，行为变化如下：

重复元素是可能的。
如果排序集为空（不存在的键），则始终返回确切count的元素或空数组。
回复中元素的顺序是真正随机的。

ZRANGE key min max [BYSCORE|BYLEX] [REV] [LIMIT offset count] [WITHSCORES]

从 1.2.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。

返回存储在的排序集中的指定元素范围。

ZRANGE可以执行不同类型的范围查询：按索引（排名）、按分数或按字典顺序。

从 Redis 6.2.0 开始，此命令可以替换以下命令：ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX和ZREVRANGEBYLEX。

常见行为和选项

元素的顺序是从最低分数到最高分数。具有相同分数的元素按字典顺序排列。

可选REV参数反转排序，因此元素从最高分数到最低分数排序，并且通过反向词典排序解决分数关系。

可选LIMIT参数可用于从匹配元素中获取子范围（类似于SQL 中的SELECT LIMIT 偏移量、计数）。负数返回所有元素。请记住，如果很大，则需要遍历排序集以获取元素，然后才能返回元素，这可能会增加O(N)时间复杂度。

可选WITHSCORES参数用返回的元素分数来补充命令的回复。返回的列表包含value1,score1,...,valueN,scoreN而不是value1,...,valueN. 客户端库可以自由地返回更合适的数据类型（建议：带有（值，分数）数组/元组的数组）。

索引范围

默认情况下，该命令执行索引范围查询。和参数表示从零开始的索引，其中0是第一个元素，1是下一个元素，依此类推。这些参数指定一个包含范围，例如，ZRANGE myzset 0 1将返回排序集的第一个和第二个元素。

索引也可以是负数，表示距排序集末尾的偏移量，是排序集-1的最后一个元素，-2倒数第二个元素，等等。

超出范围的索引不会产生错误。

如果大于排序集的结束索引或，则返回一个空列表。

如果大于排序集的结束索引，Redis 将使用排序集的最后一个元素。

分数范围

提供该BYSCORE选项时，该命令的行为类似于ZRANGEBYSCORE并返回排序集中得分等于或介于和之间的元素范围。

和可以是-inf和+inf，分别表示负无穷和正无穷。这意味着您无需知道排序集中的最高或最低分数即可从或达到某个分数的所有元素。

默认情况下，由和指定的分数间隔是封闭的（包括）。可以通过在分数前面加上字符来指定一个开区间（不包括）(。

例如：

ZRANGE zset (1 5 BYSCORE

1 < score <= 5将返回所有带有while的元素：

ZRANGE zset (5 (10 BYSCORE

将返回所有元素5 < score < 10（不包括 5 和 10）。

反向范围

使用该REV选项反转排序集，索引 0 作为得分最高的元素。

默认情况下，必须小于或等于才能返回任何内容。但是，如果选择BYSCORE、或BYLEX选项，则是要考虑的最高分数，也是要考虑的最低分数，因此必须大于或等于才能返回任何内容。

例如：

ZRANGE zset 5 10 REV

将返回反向索引中索引 5 和 10 之间的元素。

ZRANGE zset 10 5 REV BYSCORE

将返回分数小于 10 且大于 5 的所有元素。

字典范围

使用该BYLEX选项时，该命令的行为类似于ZRANGEBYLEX并返回排序集中的元素范围，该范围介于和字典封闭范围间隔之间。

请注意，字典顺序依赖于具有相同分数的所有元素。当元素有不同的分数时，回复是未指定的。

有效且必须以(or开头[，以分别指定范围区间是独占还是包含。

+or -for和的特殊值分别表示正负无限字符串，例如ZRANGE myzset - + BYLEX，如果所有元素具有相同的分数，则该命令保证返回排序集中的所有元素。

REV选项反转and元素的顺序，其中必须按字典顺序大于才能产生非空结果。

字符串的字典比较
字符串作为二进制字节数组进行比较。由于 ASCII 字符集是如何指定的，这意味着通常这也具有以明显的字典方式比较普通 ASCII 字符的效果。但是，如果使用非纯 ASCII 字符串（例如，utf8 字符串），则情况并非如此。

但是，用户可以对编码字符串应用转换，以便插入到排序集中的元素的第一部分将根据用户对特定应用程序的要求进行比较。例如，如果我想添加将以不区分大小写的方式进行比较的字符串，但我仍然想在查询时检索真实大小写，我可以通过以下方式添加字符串：

ZADD autocomplete 0 foo:Foo 0 bar:BAR 0 zap:zap

由于每个元素中的第一个规范化部分（在冒号字符之前），我们强制进行给定的比较。但是，在使用查询范围后ZRANGE ... BYLEX，应用程序可以向用户显示冒号之后的字符串的第二部分。

比较的二进制性质允许使用排序集作为通用索引，例如，元素的第一部分可以是 64 位大端数。由于大端数字在初始位置具有最高有效字节，因此二进制比较将匹配数字的数值比较。这可用于实现对 64 位值的范围查询。如下例所示，在前 8 个字节之后，我们可以存储我们正在索引的元素的值。

返回值

数组回复：指定范围内的元素列表（如果给出选项，可以选择它们的分数WITHSCORES）。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANGE myzset 0 -1
1) "one"
2) "two"
3) "three"
redis> ZRANGE myzset 2 3
1) "three"
redis> ZRANGE myzset -2 -1
1) "two"
2) "three"
redis>

以下示例使用WITHSCORES显示了该命令如何始终返回一个数组，但这次填充了element_1、score_1、element_2、score_2、 ...、element_N、score_N。

redis> ZRANGE myzset 0 1 WITHSCORES
1) "one"
2) "1"
3) "two"
4) "2"
redis>

这个例子展示了如何按分数查询排序集，不包括值1，直到无穷大，只返回结果的第二个元素：

redis> ZRANGE myzset (1 +inf BYSCORE LIMIT 1 1
1) "three"
redis>

历史

Redis 版本 >= 6.2.0：添加了 REV、BYSCORE、BYLEX 和 LIMIT 选项。

ZRANGEBYLEX key min max [LIMIT offset count]

自 2.8.9 起可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。如果 M 是常数（例如，总是用 LIMIT 要求前 10 个元素），你可以认为它是 O(log(N))。

弃用通知：从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 BYSCORE 参数的 ZRANGE 来代替。

当一个有序集合中的所有元素都以相同的分数插入时，为了强制字典顺序，该命令返回有序集合中的所有元素，key其值介于min和之间max。

如果排序集中的元素有不同的分数，则返回的元素是未指定的。

memcmp()使用C 函数逐字节比较元素被认为是从低到高的字符串排序的。如果公共部分相同，则较长的字符串被认为大于较短的字符串。

可选LIMIT参数可用于仅获取匹配元素的范围（类似于SELECT LIMIT 偏移量， SQL 中的计数）。负数count 返回所有元素offset。请记住，如果offset很大，则需要遍历排序集以 offset获取元素，然后才能返回元素，这可能会增加 O(N)时间复杂度。

如何指定间隔

有效的start和stop必须以(or开头[，以便指定范围项是分别是独占的还是包含的。+or-的特殊值start和stop具有特殊含义或正无限和负无限字符串，因此例如命令ZRANGEBYLEX myzset - +保证返回排序集中的所有元素，如果所有元素具有相同的分数.

字符串比较的详细信息

字符串作为二进制字节数组进行比较。由于 ASCII 字符集是如何指定的，这意味着通常这也具有以明显的字典方式比较普通 ASCII 字符的效果。但是，如果使用非纯 ASCII 字符串（例如 utf8 字符串），则情况并非如此。

但是，用户可以对编码字符串应用转换，以便插入排序集中的元素的第一部分将根据用户对特定应用程序的要求进行比较。例如，如果我想添加将以不区分大小写的方式进行比较的字符串，但我仍然想在查询时检索真实大小写，我可以通过以下方式添加字符串：

ZADD autocomplete 0 foo:Foo 0 bar:BAR 0 zap:zap

由于每个元素中的第一个规范化部分（在冒号字符之前），我们强制进行给定比较，但是在使用ZRANGEBYLEX查询范围之后，应用程序可以向用户显示冒号之后的字符串的第二部分。

比较的二进制性质允许使用排序集作为通用索引，例如元素的第一部分可以是 64 位大端数：由于大端数在初始位置具有最高有效字节，因此二进制比较将匹配数字的数值比较。这可用于实现对 64 位值的范围查询。如下例所示，在前 8 个字节之后，我们可以存储我们实际索引的元素的值。

返回值

数组回复：指定分数范围内的元素列表。

例子

redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis> ZRANGEBYLEX myzset - [c
1) "a"
2) "b"
3) "c"
redis> ZRANGEBYLEX myzset - (c
1) "a"
2) "b"
redis> ZRANGEBYLEX myzset [aaa (g
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"
redis>

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

从 1.0.5 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。如果 M 是常数（例如，总是用 LIMIT 要求前 10 个元素），你可以认为它是 O(log(N))。

弃用通知：从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 BYSCORE 参数的 ZRANGE 来代替。

返回排序集合中的所有元素，key其分数在min and之间max（包括分数等于minor的元素max）。元素被认为是从低到高排序的。

具有相同分数的元素按字典顺序返回（这遵循 Redis 中排序集实现的属性，不涉及进一步计算）。

可选WITHSCORES参数使命令返回元素及其分数，而不是单独返回元素。此选项自 Redis 2.0 起可用。

排他区间和无穷大

min和max可以是-inf和+inf，这样您就不需要知道排序集中的最高或最低分数来获取或达到某个分数的所有元素。

默认情况下，由min和指定的间隔max是封闭的（包括）。可以通过在分数前面加上字符来指定一个开区间（不包括）(。例如：

ZRANGEBYSCORE zset (1 5

1 < score <= 5将返回所有带有while的元素：

ZRANGEBYSCORE zset (5 (10

将返回所有元素5 < score < 10（不包括 5 和 10）。

返回值

数组回复：指定分数范围内的元素列表（可选地与他们的分数）。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANGEBYSCORE myzset -inf +inf
1) "one"
2) "two"
3) "three"
redis> ZRANGEBYSCORE myzset 1 2
1) "one"
2) "two"
redis> ZRANGEBYSCORE myzset (1 2
1) "two"
redis> ZRANGEBYSCORE myzset (1 (2
(empty list or set)
redis>

模式：元素的加权随机选择

通常ZRANGEBYSCORE仅用于获取分数是索引整数键的项目范围，但是可以使用命令执行不太明显的操作。

例如，实现马尔可夫链和其他算法时的一个常见问题是从集合中随机选择一个元素，但不同的元素可能具有不同的权重，这会改变它们被选择的可能性。

这就是我们如何使用这个命令来挂载这样一个算法：

假设您有元素 A、B 和 C，权重分别为 1、2 和 3。您计算权重之和，即 1+2+3 = 6

此时，您使用此算法将所有元素添加到排序集中：

SUM = ELEMENTS.TOTAL_WEIGHT // 6 in this case.
SCORE = 0
FOREACH ELE in ELEMENTS
    SCORE += ELE.weight / SUM
    ZADD KEY SCORE ELE
END

这意味着您设置：

A to score 0.16
B to score .5
C to score 1

由于这涉及近似值，为了避免将 C 设置为 0.998 而不是 1，我们只需修改上述算法以确保最后一个分数为 1（留给读者练习......）。

此时，每次你想得到一个加权随机元素，只需计算一个介于 0 和 1 之间的随机数（这就像 rand()在大多数语言中调用一样），所以你可以这样做：

RANDOM_ELE = ZRANGEBYSCORE key RAND() +inf LIMIT 0 1

历史

Redis 版本 >= 2.0.0：添加了 WITHSCORES 修饰符。

ZRANGESTORE dst src min max [BYSCORE|BYLEX] [REV] [LIMIT offset count]

从 6.2.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是存储到目标键中的元素数。

此命令类似于ZRANGE，但将结果存储在目标键中。

返回值

整数回复：结果排序集中的元素数。

例子

redis> ZADD srczset 1 "one" 2 "two" 3 "three" 4 "four"
(integer) 4
redis> ZRANGESTORE dstzset srczset 2 -1
ERR Unknown or disabled command 'ZRANGESTORE'
redis> ZRANGE dstzset 0 -1
(empty list or set)
redis>

ZRANK key member

从 2.0.0 开始可用。

时间复杂度： O(log(N))

返回member存储在的排序集中的排名key，分数从低到高排序。排名（或索引）是从 0 开始的，这意味着得分最低的成员具有 rank 0。

使用ZREVRANK获取一个元素的排名，分数从高到低排序。

返回值

如果member存在于排序集中，整数回复：的排名member。
如果member在排序集中不存在或key不存在，则批量字符串回复：nil。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANK myzset "three"
(integer) 2
redis> ZRANK myzset "four"
(nil)
redis>

ZREM key member [member ...]

从 1.2.0 开始可用。

时间复杂度： O(M*log(N))，其中 N 是排序集中的元素数，M 是要删除的元素数。

从存储在的排序集中删除指定的成员key。不存在的成员将被忽略。

key存在且不包含排序集时返回错误。

返回值

整数回复，具体来说：

从排序集中删除的成员数，不包括不存在的成员。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREM myzset "two"
(integer) 1
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "three"
4) "3"
redis>

历史

Redis 版本 >= 2.4.0：接受多个元素。

ZREMRANGEBYLEX key min max

自 2.8.9 起可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是操作删除的元素数。

当以相同的分数插入已排序集中的所有元素时，为了强制按字典顺序，此命令删除存储在和key指定的字典范围之间的已排序集中的所有元素。minmax

min和ZRANGEBYLEX命令的含义max相同。同样，如果使用相同的和参数调用ZRANGEBYLEX，此命令实际上会删除相同的元素。minmax

返回值

整数回复：删除的元素数。

例子

redis> ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
(integer) 5
redis> ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
(integer) 5
redis> ZRANGE myzset 0 -1
1) "ALPHA"
 2) "aaaa"
 3) "alpha"
 4) "b"
 5) "c"
 6) "d"
 7) "e"
 8) "foo"
 9) "zap"
10) "zip"
redis> ZREMRANGEBYLEX myzset [alpha [omega
(integer) 6
redis> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "zap"
4) "zip"
redis>

ZREMRANGEBYRANK key start stop

从 2.0.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是操作删除的元素数。

删除排序集中存储在和之间的所有key元素。两者和都是基于索引的索引，是得分最低的元素。这些索引可以是负数，它们表示从得分最高的元素开始的偏移量。例如：是得分最高的元素，得分第二高的元素等等。startstopstartstop00-1-2

返回值

整数回复：删除的元素数。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREMRANGEBYRANK myzset 0 1
(integer) 2
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "three"
2) "3"
redis>

ZREMRANGEBYSCORE key min max

从 1.2.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是操作删除的元素数。

删除排序集中存储的所有元素，key其分数介于 min和max（包括）之间。

返回值

整数回复：删除的元素数。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREMRANGEBYSCORE myzset -inf (2
(integer) 1
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "two"
2) "2"
3) "three"
4) "3"
redis>

ZREVRANGE key start stop [WITHSCORES]

从 1.2.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。

弃用通知：从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 REV 参数的 ZRANGE 来代替。

返回存储在的排序集中的指定元素范围key。元素被认为是从最高分数到最低分数排序的。降序字典顺序用于得分相等的元素。

除了倒序之外，ZREVRANGE类似于ZRANGE。

返回值

数组回复：指定范围内的元素列表（可选地带有它们的分数）。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANGE myzset 0 -1
1) "three"
2) "two"
3) "one"
redis> ZREVRANGE myzset 2 3
1) "one"
redis> ZREVRANGE myzset -2 -1
1) "two"
2) "one"
redis>

ZREVRANGEBYLEX key max min [LIMIT offset count]

自 2.8.9 起可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。如果 M 是常数（例如，总是用 LIMIT 要求前 10 个元素），你可以认为它是 O(log(N))。

弃用通知：从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 REV 和 BYLEX 参数的 ZRANGE 来代替。

当一个有序集合中的所有元素都以相同的分数插入时，为了强制字典顺序，该命令返回有序集合中的所有元素，key其值介于max和之间min。

除了倒序之外，ZREVRANGEBYLEX类似于ZRANGEBYLEX。

返回值

数组回复：指定分数范围内的元素列表。

例子

redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis> ZREVRANGEBYLEX myzset [c -
1) "c"
2) "b"
3) "a"
redis> ZREVRANGEBYLEX myzset (c -
1) "b"
2) "a"
redis> ZREVRANGEBYLEX myzset (g [aaa
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
redis>

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

从 2.2.0 开始可用。

时间复杂度： O(log(N)+M)，其中 N 是排序集中的元素数，M 是返回的元素数。如果 M 是常数（例如，总是用 LIMIT 要求前 10 个元素），你可以认为它是 O(log(N))。

弃用通知：从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 REV 和 BYSCORE 参数的 ZRANGE 来代替。

返回排序集合中的所有元素，key其分数在max and之间min（包括分数等于maxor的元素min）。与排序集的默认排序相反，对于此命令，元素被认为是从高到低排序的。

具有相同分数的元素以相反的字典顺序返回。

除了倒序之外，ZREVRANGEBYSCORE类似于 ZRANGEBYSCORE。

返回值

数组回复：指定分数范围内的元素列表（可选地与他们的分数）。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANGEBYSCORE myzset +inf -inf
1) "three"
2) "two"
3) "one"
redis> ZREVRANGEBYSCORE myzset 2 1
1) "two"
2) "one"
redis> ZREVRANGEBYSCORE myzset 2 (1
1) "two"
redis> ZREVRANGEBYSCORE myzset (2 (1
(empty list or set)
redis>

历史

Redis 版本 >= 2.1.6：min 和 max 可以互斥。

ZREVRANK key member

从 2.0.0 开始可用。

时间复杂度： O(log(N))

返回member存储在的排序集中的排名key，分数从高到低排序。排名（或索引）是从 0 开始的，这意味着得分最高的成员具有 rank 0。

使用ZRANK获得一个元素的排名，分数从低到高排列。

返回值

如果member存在于排序集中，整数回复：的排名member。
如果member在排序集中不存在或key不存在，则批量字符串回复：nil。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANK myzset "one"
(integer) 2
redis> ZREVRANK myzset "four"
(nil)
redis>

ZSCAN key cursor [MATCH pattern] [COUNT count]

自 2.8.0 起可用。

时间复杂度：每次调用 O(1)。O(N) 用于完整的迭代，包括足够的命令调用以使光标返回 0。N 是集合内的元素数。

有关ZSCAN文档，请参阅SCAN 。

ZSCORE key member

从 1.2.0 开始可用。

时间复杂度： O(1)

member返回在排序集中的分数key。

如果member在排序集中不存在，或者key不存在，nil则返回。

返回值

批量字符串回复member：（一个双精度浮点数）的分数，以字符串表示。

例子

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZSCORE myzset "one"
"1"
redis>

ZUNION numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]

从 6.2.0 开始可用。

时间复杂度： O(N)+O(M*log(M))，其中 N 是输入排序集的大小之和，M 是结果排序集中的元素数。

此命令类似于ZUNIONSTORE，但不是存储结果排序集，而是返回给客户端。

有关WEIGHTS和AGGREGATE选项的说明，请参阅ZUNIONSTORE。

返回值

数组回复：联合的结果（如果给出选项，可以选择他们的分数WITHSCORES）。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNION 2 zset1 zset2
1) "one"
2) "three"
3) "two"
redis> ZUNION 2 zset1 zset2 WITHSCORES
1) "one"
2) "2"
3) "three"
4) "3"
5) "two"
6) "4"
redis>

ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

从 2.0.0 开始可用。

时间复杂度： O(N)+O(M log(M))，其中 N 是输入排序集大小的总和，M 是结果排序集中元素的数量。

计算numkeys由指定键给定的排序集的并集，并将结果存储在destination. numkeys在传递输入键和其他（可选）参数之前，必须提供输入键的数量 ( )。

默认情况下，一个元素的结果分数是它在它所在的排序集中的分数的总和。

使用该WEIGHTS选项，可以为每个输入排序集指定一个乘法因子。这意味着每个输入排序集中的每个元素的分数在传递给聚合函数之前都会乘以该因子。如果WEIGHTS未给出，则乘法因子默认为1。

使用该AGGREGATE选项，可以指定联合结果的聚合方式。此选项默认为SUM，其中元素的分数在其存在的输入中求和。当此选项设置为MINorMAX时，结果集将包含元素在其存在的输入中的最小或最大分数。

如果destination已经存在，则将其覆盖。

返回值

整数回复：结果排序集中的元素数 destination。

例子

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 3
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "three"
4) "9"
5) "two"
6) "10"
redis>

如果觉得文章对你有用，请随意赞赏

Redis-Sorted-Sets相关命令

https://blog.ichees.tech/archives/redis-sorted-sets%E7%9B%B8%E5%85%B3%E5%91%BD%E4%BB%A4

作者

秘密基地

发布于

2022-03-03

更新于

2023-06-04

许可协议

CC BY 4.0