Redis有序集合ZSET

特点：

• 按照score排序
• member 值不能重复，score可以重复

ZADD key score member [[score member] [score member] …]

> 可用版本： >= 1.2.0
> 时间复杂度: O(M*log(N))， `N` 是有序集的基数， `M` 为成功添加的新成员的数量。

127.0.0.1:6379> zadd z1 1 aa 2 bb     #添加成功
(integer) 2
127.0.0.1:6379> zadd z1 1 a1             #添加成功
(integer) 1
127.0.0.1:6379> zadd z1 0 z               #添加成功
(integer) 1
127.0.0.1:6379> zadd z1 0 z               #添加不成功，值z已经存在
(integer) 0
127.0.0.1:6379> zadd z1 0 b      
(integer) 1
127.0.0.1:6379> zadd z1 10 b            #添加失败，无法通过zadd进行对score的更新
(integer) 0

ZSCORE key member 显示值的分数

127.0.0.1:6379> zscore z1 z
"0"
127.0.0.1:6379> zscore z1 b
"10"

ZINCRBY key increment member 自增值

127.0.0.1:6379> zscore z1 b
"10"
127.0.0.1:6379> zincrby z1 100 b
"110"
127.0.0.1:6379> zscore z1 b
"110"

ZCARD key 返回有序集的元素个数

127.0.0.1:6379> zcard z1
(integer) 6

ZCOUNT key min max 统计min（含）和max（含）区间的元素个数

127.0.0.1:6379> zadd z2 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zcount z2 2 3         #计算分数为2-3（含）的元素个数
(integer) 2

ZRANGE key start stop [WITHSCORES] 返回有序集 key 中指定区间内的成员，从小到大

可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

127.0.0.1:6379> zrange z2 0 -1
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrange z2 0 -1 withscores
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"

ZREVRANGE key start stop [WITHSCORES]返回有序集 key 中指定区间内的成员，从大到小

127.0.0.1:6379> zrevrange z2 0 -1 withscores
1) "c"
2) "3"
3) "b"
4) "2"
5) "a"
6) "1"

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 按score从小到大返回min和max区间的分值进行

可用版本： >= 1.0.5
时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为被结果集的基数。

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。

可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。

可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。 该选项自 Redis 2.0 版本起可用。

区间及无限

min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。

默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

举个例子：
ZRANGEBYSCORE zset (1 5
返回所有符合条件 1 < score <= 5 的成员，而

ZRANGEBYSCORE zset (5 (10
则返回所有符合条件 5 < score < 10 的成员。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例

redis> ZADD salary 2500 jack                        # 测试数据
(integer) 0
redis> ZADD salary 5000 tom
(integer) 0
redis> ZADD salary 12000 peter
(integer) 0

redis> ZRANGEBYSCORE salary -inf +inf               # 显示整个有序集
1) "jack"
2) "tom"
3) "peter"

redis> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"

redis> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
1) "jack"
2) "2500"
3) "tom"
4) "5000"

redis> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
1) "peter"

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count] 按score从大到小返回min和max区间的分值进行

见上代码示例，略。

ZRANK key member 返回member在key中的排名（从小到大），以0开始计

ZREVRANK key member 返回member在key中的排名（从大到小），以0开始计

127.0.0.1:6379> zrange z2 0 -1 withscores
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
127.0.0.1:6379> zrank z2 a
(integer) 0
127.0.0.1:6379> zrevrank z2 a
(integer) 2

ZREM key member [member …] 移除key中的member元素，可多个

127.0.0.1:6379> zrem z2 a b c           #全部移除后，z2这个列表也不存在了
(integer) 3

ZREMRANGEBYRANK key start stop 按基数移除第start（含）至第stop（含）的元素，从0开始计

127.0.0.1:6379> zadd z3 1 1 2 2 3 3 4 4 5 5 6 6 7 7
(integer) 7
127.0.0.1:6379> zremrangebyrank z3 2 3
(integer) 2
127.0.0.1:6379> zrange z3 0 -1 withscores
 1) "1"
 2) "1"
 3) "2"
 4) "2"
 5) "5"
 6) "5"
 7) "6"
 8) "6"
 9) "7"
10) "7"

ZREMRANGEBYSCORE key min max 按score移除min至max的score值元素

127.0.0.1:6379> zremrangebyscore z3 2 5
(integer) 2
127.0.0.1:6379> zrange z3 0 -1
1) "1"
2) "6"
3) "7"
127.0.0.1:6379>

---

下面没闹明白，有空再回头来看看。

ZRANGEBYLEX key min max [LIMIT offset count]

可用版本： >= 2.8.9
时间复杂度：O(log(N)+M)， 其中 N 为有序集合的元素数量， 而 M 则是命令返回的元素数量。 如果 M 是一个常数（比如说，用户总是使用 LIMIT 参数来返回最先的 10 个元素）， 那么命令的复杂度也可以看作是 O(log(N)) 。
当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。

如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。

命令会使用 C 语言的 memcmp() 函数， 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。

可选的 LIMIT offset count 参数用于获取指定范围内的匹配元素 （就像 SQL 中的 SELECT LIMIT offset count 语句）。 需要注意的一点是， 如果 offset 参数的值非常大的话， 那么命令在返回结果之前， 需要先遍历至 offset 所指定的位置， 这个操作会为命令加上最多 O(N) 复杂度。

如何指定范围区间
合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。

特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX - + ， 命令将返回有序集合中的所有元素。

返回值
数组回复：一个列表，列表里面包含了有序集合在指定范围内的成员。

代码示例

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"

ZLEXCOUNT key min max

可用版本： >= 2.8.9
时间复杂度： O(log(N))，其中 N 为有序集合包含的元素数量。

对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 min 参数和 max 参数的意义一样。

返回值

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

代码示例

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

ZREMRANGEBYLEX key min max

可用版本： >= 2.8.9
时间复杂度： O(log(N)+M)， 其中 N 为有序集合的元素数量， 而 M 则为被移除的元素数量。

对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 min 参数和 max 参数的意义一样。

返回值

整数回复：被移除的元素数量。

代码示例

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"

ZSCAN key cursor [MATCH pattern] [COUNT count]

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

可用版本：>= 2.0.0

时间复杂度: O(N)+O(M log(M))， N 为给定有序集基数的总和， M 为结果集的基数。

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

WEIGHTS

使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。

如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。

AGGREGATE

使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。

默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score值。

返回值

保存到 destination 的结果集的基数。

代码示例

redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"

redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"

redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司决定加薪。。。除了程序员。。。
(integer) 6

redis> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
7) "herry"
8) "6000"
9) "mary"
10) "10500"
11) "bob"
12) "12000"

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

可用版本： >= 2.0.0

时间复杂度: O(NK)+O(Mlog(M))， N 为给定 key 中基数最小的有序集， K 为给定有序集的数量， M 为结果集的基数。

计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.

关于 WEIGHTS 和 AGGREGATE 选项的描述，参见 ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX] 命令。

返回值

保存到 destination 的结果集的基数。

代码示例

redis > ZADD mid_test 70 "Li Lei"
(integer) 1
redis > ZADD mid_test 70 "Han Meimei"
(integer) 1
redis > ZADD mid_test 99.5 "Tom"
(integer) 1

redis > ZADD fin_test 88 "Li Lei"
(integer) 1
redis > ZADD fin_test 75 "Han Meimei"
(integer) 1
redis > ZADD fin_test 99.5 "Tom"
(integer) 1

redis > ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3

redis > ZRANGE sum_point 0 -1 WITHSCORES     # 显示有序集内所有成员及其 score 值
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"