redis 入门之有序集合

zadd

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。score 值可以是整数值或双精度浮点数。
如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
当 key 存在但不是有序集类型时，返回一个错误。

# 添加单个元素
redis> ZADD page_rank  google.com
(integer)
# 添加多个元素
redis> ZADD page_rank  baidu.com  bing.com
(integer)
redis> ZRANGE page_rank  - WITHSCORES
) "bing.com"
) ""
) "baidu.com"
) ""
) "google.com"
) ""
# 添加已存在元素，且 score 值不变
redis> ZADD page_rank  google.com
(integer) 

redis> ZRANGE page_rank  - WITHSCORES  # 没有改变
) "bing.com"
) ""
) "baidu.com"
) ""
) "google.com"
) ""
# 添加已存在元素，但是改变 score 值
redis> ZADD page_rank  bing.com
(integer)
redis> ZRANGE page_rank  - WITHSCORES  # bing.com 元素的 score 值被改变
) "bing.com"
) ""
) "baidu.com"
) ""
) "google.com"
) ""

zscore

返回有序集 key 中，成员 member 的 score 值。如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

redis> ZRANGE salary  - WITHSCORES    # 测试数据
) "tom"
) ""
) "peter"
) ""
) "jack"
) ""
redis> ZSCORE salary peter              # 注意返回值是字符串
""

zincrby

ZINCRBY key increment member为有序集 key 的成员 member 的 score 值加上增量 increment 。
可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
当 key 不是有序集类型时，返回一个错误。score 值可以是整数值或双精度浮点数。

redis> ZSCORE salary tom
""
redis> ZINCRBY salary  tom   # tom 加薪啦！
""

zcard

返回有序集 key 的基数。

redis > ZADD salary  tom    # 添加一个成员
(integer)
redis > ZCARD salary
(integer)
redis > ZADD salary  jack   # 再添加一个成员
(integer)
redis > ZCARD salary
(integer)
redis > EXISTS non_exists_key   # 对不存在的 key 进行 ZCARD 操作
(integer)
redis > ZCARD non_exists_key
(integer) 

zcount

ZCOUNT key min max返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

redis> ZRANGE salary  - WITHSCORES    # 测试数据
) "jack"
) ""
) "peter"
) ""
) "tom"
) ""
redis> ZCOUNT salary            # 计算薪水在 - 之间的人数
(integer)
redis> ZCOUNT salary            # 计算薪水在 - 之间的人数
(integer) 

zrange

返回有序集 key 中，指定区间内的成员。

redis > ZRANGE salary  - WITHSCORES             # 显示整个有序集成员
) "jack"
) ""
) "tom"
) ""
) "boss"
) ""
redis > ZRANGE salary   WITHSCORES              # 显示有序集下标区间  至  的成员
) "tom"
) ""
) "boss"
) ""
redis > ZRANGE salary   WITHSCORES         # 测试 end 下标超出最大下标时的情况
) "jack"
) ""
) "tom"
) ""
) "boss"
) ""
redis > ZRANGE salary   WITHSCORES   # 测试当给定区间不存在于有序集时的情况
(empty list or set)

zervrange

ZREVRANGE key start stop [WITHSCORES]返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序排列。
除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。

redis> ZRANGE salary  - WITHSCORES        # 递增排列
) "peter"
) ""
) "tom"
) ""
) "jack"
) ""
redis> ZREVRANGE salary  - WITHSCORES     # 递减排列
) "jack"
) ""
) "tom"
) ""
) "peter"
) ""

zrangebyscore

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。
可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 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) ""
3) "tom"
4) ""
5) "peter"
6) ""
redis> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
1) "jack"
2) ""
3) "tom"
4) ""
redis> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
1) "peter"

zrevrangebyscore

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
具有相同 score 值的成员按字典序的逆序排列。

redis > ZADD salary 10086 jack
(integer) 1
redis > ZADD salary 5000 tom
(integer) 1
redis > ZADD salary 7500 peter
(integer) 1
redis > ZADD salary 3500 joe
(integer) 1
redis > ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
1) "jack"
2) "peter"
3) "tom"
4) "joe"
redis > ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
1) "peter"
2) "tom"
3) "joe"

zrank

ZRANK key member返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

redis> ZRANGE salary 0 -1 WITHSCORES        # 显示所有成员及其 score 值
1) "peter"
2) ""
3) "tom"
4) ""
5) "jack"
6) ""
redis> ZRANK salary tom                     # 显示 tom 的薪水排名，第二
(integer) 1

zrevrank

ZREVRANK key member返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
排名以 0 为底，也就是说， score 值最大的成员排名为 0 。

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
1) "jack"
2) ""
3) "peter"
4) ""
5) "tom"
6) ""
redis> ZREVRANK salary peter     # peter 的工资排第二
(integer) 1
redis> ZREVRANK salary tom       # tom 的工资最高
(integer) 0

zrem

ZREM key member [member …]移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
当 key 存在但不是有序集类型时，返回一个错误。

# 测试数据
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) ""
3) "baidu.com"
4) ""
5) "google.com"
6) ""
# 移除单个元素
redis> ZREM page_rank google.com
(integer) 1
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) ""
3) "baidu.com"
4) ""
# 移除多个元素
redis> ZREM page_rank baidu.com bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)
# 移除不存在元素
redis> ZREM page_rank non-exists-element
(integer) 0

zremrangebyrank

ZREMRANGEBYRANK key start stop移除有序集 key 中，指定排名(rank)区间内的所有成员。
区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。

redis> ZADD salary 2000 jack
(integer) 1
redis> ZADD salary 5000 tom
(integer) 1
redis> ZADD salary 3500 peter
(integer) 1
redis> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
(integer) 2
redis> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
1) "tom"
2) ""

zrenrangebyscore

ZREMRANGEBYSCORE key min max移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员

redis> ZRANGE salary 0 -1 WITHSCORES          # 显示有序集内所有成员及其 score 值
1) "tom"
2) ""
3) "peter"
4) ""
5) "jack"
6) ""
redis> ZREMRANGEBYSCORE salary 1500 3500      # 移除所有薪水在 1500 到 3500 内的员工
(integer) 2
redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成员
1) "jack"
2) ""

zrangebylex

ZRANGEBYLEX key min max [LIMIT offset count]当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。

合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。
特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素。

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"

zunionstore

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) ""
3) "jack"
4) ""
5) "tom"
6) ""
redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) ""
3) "mary"
4) ""
5) "bob"
6) ""
redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司决定加薪。。。除了程序员。。。
(integer) 6
redis> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) ""
3) "jack"
4) ""
5) "tom"
6) ""
7) "herry"
8) ""
9) "mary"
10) ""
11) "bob"
12) ""

zinterstore

计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.

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) ""
3) "Li Lei"
4) ""
5) "Tom"
6) ""