redis 常用数据结构2

目录

list

LPUSH

LRANGE

LPUSHX

RPUSH

RPUSHX

LPOP

RPOP

LINDEX

LINSERT

LLEN

LREM

LTRIM

LSET

BLPOP / BRPOP

编码方式

set

SADD

SMEMBERS

SISMEMBER

SPOP

SCARD

SRANDMEMBER

SMOVE

SREM

SINTER

SINTERSTORE

SUNION

SUNIONSTORE

SDIFF

SDIFFSTORE

编码方式

zset

ZADD

ZRANGE

ZADD 选项查看

ZCARD

ZCOUNT

ZREVRANGE

ZRANGEBYSCORE

ZPOPMAX

BZPOPMAX

ZPOPMIN

BZPOPMIN

ZRANK

ZREVRANK

ZREM

ZREMRANGEBYRANK

ZREMRANGEBYSCORE

ZINCRBY

ZINTERSOTORE

ZUNIONSTORE

编码方式

---

list

• 链表相当于数组或者是顺序表

• 在 list 中有下标的概念

• list 是有序的

• 从左向右的下标是，从0开始，一直向后增加

• 从右向左的下标是，从最右边开始，下标为 -1 ，向左一直减少

LPUSH

• 链表中插入数据

lpush key value [value ...]

• 返回值是插入后，里面元素的总个数

• lpush 是头插

• 可以一次插入多个元素

• 插入几个元素

  127.0.0.1:6379> lpush key 111 222 333
  3
  

• 继续插入到同一个 key里面

  127.0.0.1:6379> lpush key 444 555 666
  6
  

LRANGE

• 查看链表中的元素

lrange key start stop

• 返回值就是查到的元素

• start 表示从那个位置开始

• stop 表示从那个位置结束

• 这两个位置都是闭区间

• 其中这两个位置可以输入负数，负数表示的是从后面开始计算。

• 查看插入的全部数据

  127.0.0.1:6379> lrange key 0 -1
  666
  555
  444
  333
  222
  111
  

  0 表示从第 0 个位置开始，-1 表示到倒数第一个位置

• 上面查看插入的数据使用的是下标

• 既然是下标，那么就有可能会越界

• 那么 redis 对于越界是怎么样子的？

• 输入一段有问题的范围

  127.0.0.1:6379> lrange key 0 6
  666
  555
  444
  333
  222
  111
  

• 继续输入有问题的范围

  127.0.0.1:6379> lrange key 0 100
  666
  555
  444
  333
  222
  111
  

  127.0.0.1:6379> lrange key 10 100
  

  127.0.0.1:6379> lrange key 10 -100
  

  上面的情况下 redis 并没有报错，而是讲你输入的范围里面有数据就取出来，没有数据就是空。

  redis 这样设定，那么也就证明 redis 的容错能力跟强。

LPUSHX

• key 存在才插入

lpushx key value

• 返回值是插入后的总共元素个数

• 该命令是只有 key 存在才能插入

• 一次性也可以插入多个值

• 插入一个元素

  127.0.0.1:6379> lpushx key 100
  7
  

• 插入多个元素

  127.0.0.1:6379> lpushx key 200 300
  9
  

• 插入到不存在的 key 中

  127.0.0.1:6379> lpushx key1 200 300
  0
  

RPUSH

• 尾插

rpush key value [value ...]

• 返回值是插入后元素的所有个数

• 可以一次插入多个值

• 该命令是尾插

• 插入元素

  127.0.0.1:6379> rpush key1 111 222 333
  3
  

• 继续插入

  127.0.0.1:6379> rpush key1 444 555 666
  6
  

• 查看插入元素

  127.0.0.1:6379> lrange key1 0 -1
  111
  222
  333
  444
  555
  666
  

RPUSHX

• 尾插到存在的 key 中

rpushx key value

• 返回值是插入后元素的总个数

• 只能插入到存在的 key 中

• 可以插入多个元素

• 插入单个元素

  127.0.0.1:6379> rpushx key1 100
  7
  

• 插入多个元素

  127.0.0.1:6379> rpushx key1 200 300
  9
  

• 插入到不存在的 key 中

  127.0.0.1:6379> rpushx key2 400
  0
  

LPOP

• 头删

lpop key

• 删除左侧元素

• 返回值就是删除掉的元素，如果没有元素，返回 nil

• 在 redis 6.2 以上版本该命令后面还有一个 count ，表示删除几个

• 删除元素

  127.0.0.1:6379> lpop key1 
  111
  

• 查看

  127.0.0.1:6379> lrange key1 0 -1
  222
  333
  444
  555
  666
  100
  200
  300
  

• 删除全部元素

  127.0.0.1:6379> lpop key1
  222
  127.0.0.1:6379> lpop key1
  333
  127.0.0.1:6379> lpop key1
  444
  127.0.0.1:6379> lpop key1
  555
  127.0.0.1:6379> lpop key1
  666
  127.0.0.1:6379> lpop key1
  100
  127.0.0.1:6379> lpop key1
  200
  127.0.0.1:6379> lpop key1
  300
  127.0.0.1:6379> lpop key1
  

  删除到最后删成了 nil，但是这里没有显示出来

RPOP

• 尾删

rpop key

• 删除最右边的元素

• 剩下的特性和 lpop 一样

• 删除元素

  127.0.0.1:6379> lpush key 111 222 333
  3
  127.0.0.1:6379> rpop key
  111
  

• 查看删除后的结果

  127.0.0.1:6379> lrange key 0 -1
  333
  222
  

• 全部删除

  127.0.0.1:6379> rpop key
  222
  127.0.0.1:6379> rpop key
  333
  127.0.0.1:6379> rpop key
  

  全部删除后，就变成 nil 了

• 上面的 list 可以灵活使用lpush 或者 rpush 或者 rpop 或者 lpop ，就可以达到栈或者队列的效果

LINDEX

• 返回指定位置的元素

lindex key index

• 返回值是指定位置的元素

• 下标从 0 开始

• 如果指定位置不在范围内，那么久返回 nil

• index 还可以是负数，负数表示从后向前的位置

• 先插入元素

  127.0.0.1:6379> lpush key 10 20 30 40 50
  5
  127.0.0.1:6379> lrange key 0 -1
  50
  40
  30
  20
  10
  

• 查看元素

  127.0.0.1:6379> lindex key 3
  20
  

• 输入负数

  127.0.0.1:6379> lindex key -1
  10
  

• 查看不存在的位置

  127.0.0.1:6379> lindex key 10
  

LINSERT

• 插入在指定元素前或者后

linsert key BEFORE|AFTER pivot value

• 返回值就是插入后的总共元素个数，如果该元素不存在，那么返回 -1

• pivot 表示插入该基准值

• BEFORE | AFTER 表示插入到该基准值的前或者后

• 由于list 可以重复，所以基准值可能存在多个，但是 redis 是从左边开始查找，遇到的第一个基准值

• 插入指定元素前面

  127.0.0.1:6379> linsert key before 30 99
  6
  127.0.0.1:6379> lrange key 0 -1
  50
  40
  99
  30
  20
  10
  

• 插入到指定元素后面

  127.0.0.1:6379> lrange key 0 -1
  50
  40
  99
  30
  88
  20
  10
  

• 插入到不存在的位置

  127.0.0.1:6379> linsert key after 100 10
  -1
  

LLEN

• 返回 list 里面元素的个数

llen key

• 返回值是返回 key 对应 list 里面的元素个数，如果没有对应的 key，则返回 0

• 查看 key 里面的元素个数

  127.0.0.1:6379> llen key
  7
  

• 查看不存在的 key

  127.0.0.1:6379> llen key1
  0
  

LREM

• 删除指定元素 count 个

lrem key count value

• value 表示要删除的元素

• count 表示删除几个值为 value 的元素

• 但是 count 可以为 0 和 负数

• count > 0 表示：从左往右开始删除 count 个元素

• count < 0 表示：从右往左开始删除 count 个元素

• count = 0 表示：删除值为 value 的全部元素

• 返回值就是删除成功的元素的个数

• 构建一个 list

  127.0.0.1:6379> rpush key 1 2 3 4
  4
  127.0.0.1:6379> rpush key 1 2 3 4
  8
  127.0.0.1:6379> rpush key 1 2 3 4
  12
  127.0.0.1:6379> rpush key 1 2 3 4
  16
  

  127.0.0.1:6379> lrange key 0 -1
  1
  2
  3
  4
  1
  2
  3
  4
  1
  2
  3
  4
  1
  2
  3
  4
  

• 删除从左往右数的 2 个 1

  127.0.0.1:6379> lrem key 2 1
  2
  

• 查看

  127.0.0.1:6379> lrange key 0 -1
  2
  3
  4
  2
  3
  4
  1
  2
  3
  4
  1
  2
  3
  4
  

• 重新构造案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> rpush key 1 2 3 4
  4
  127.0.0.1:6379> rpush key 1 2 3 4
  8
  127.0.0.1:6379> rpush key 1 2 3 4
  12
  127.0.0.1:6379> rpush key 1 2 3 4
  16
  

• 删除从右往左数的 2 个 1

  127.0.0.1:6379> lrem key -2 1
  2
  

• 查看

  127.0.0.1:6379> lrange key 0 -1
  1
  2
  3
  4
  1
  2
  3
  4
  2
  3
  4
  2
  3
  4
  

• 重新构造案例

• 删除全部的 1

  127.0.0.1:6379> lrem key 0 1
  4
  

• 查看

  127.0.0.1:6379> lrange key 0 -1
  2
  3
  4
  2
  3
  4
  2
  3
  4
  2
  3
  4
  

LTRIM

• 删除指定范围的元素

ltrim key start stop

• start 表示起始位置

• stop 表示终止位置

• 这两个位置是闭区间

• 但是这里并不是删除 start ~ stop 中间的元素，而是保留该闭区间的元素，删除该范围外的所有元素

• 这两个位置同样可以为负数

• 返回值，删除成功

• 构建案例

  127.0.0.1:6379> rpush key 1 2 3 4 5 6 7 8
  8
  

• 删除 保留下标从 2 开始到 下标 5 的所有元素

  127.0.0.1:6379> ltrim key 2 5
  OK
  

• 查看

  127.0.0.1:6379> lrange key 0 -1
  3
  4
  5
  6
  

LSET

• 修改指定位置的元素

lset key index value

• index 可以为负数

• 如果超出范围，则或报错

• 返回值，删除成功的话，返回 ok

• 构建案例

  127.0.0.1:6379> rpush key 1 2 3 4 5 6 7 8
  8
  

• 修改 index 为 5 的元素，修改为 60

  127.0.0.1:6379> lset key 5 60
  OK
  

• 查看

  127.0.0.1:6379> lrange key 0 -1
  1
  2
  3
  4
  5
  60
  7
  8
  

• 修改不存在的范围

  127.0.0.1:6379> lset key 10 0
  ERR index out of range
  

BLPOP / BRPOP

• 这两个命令也是删除，功能基本和 lpop 和 rpop 的功能额基本相同

• 但是 blpop 和 brpop 是阻塞删除

• 如果 list 中有元素，那么 blpop 和 brpop 和 lpop 和 rpop 的功能一样

• 但是如果 list 中没有元素， 那么 lpop 和 rpop 就会返回 nil

• 而 blpop 和 brpop 则会阻塞

• 但是阻塞本本会根据 timeout，阻塞一段时间，期间 redis 可以执行其他命令

• timeout 也是可以自行设置的

• 虽然说是阻塞，但是 blpop 和 brpop 并不会对 redis 产生负面影响

• 对于同一个元素来说，哪一个客户端先调用了 pop ，那么就先被哪一个客户端获取到

blpop key [key ...] timeout

brpop key [key ...] timeout

• 可以删除多个 key 里面的元素

• timeout 的单位是 秒

• 返回值是一个而二元组

• 构建案例

  127.0.0.1:6379> rpush key 1 2 3 4 5
  5
  

• 对一个非空 key 进行操作

  127.0.0.1:6379> blpop key 0
  key
  1
  

  这里看到返回值其实是一个二元组，是哪一个 key 里面删除的，删除的元素是哪个。

• 对空 key 进行操作

  127.0.0.1:6379> blpop key1 5
  

  对空 key 操作，这里就会阻塞5秒，然后返回 nil

• 对空 key 操作，然后又其他客户端插入数据

  127.0.0.1:6379> blpop key1 100
  

• 刚开始是阻塞的

• 由其他客户端插入数据后

  127.0.0.1:6379> rpush key1 10
  1
  

• 阻塞删除的客户端立马返回数据

  127.0.0.1:6379> blpop key1 100
  key1
  10
  

• 其中 brpop 和 blpop 的阻塞时一样的，所以这里也就不演示了

编码方式

• ziplist: 压缩链表

• linkedlist: 普通链表

• 但是这是之前的 list 采用的编码方式

• 现在的 list 采用的编码方式时 quicklist

• quicklist 是一个链表，该链表里面的每个元素都是 ziplist

• 二 quicklist 里面的 ziplist 的长度都不会太长

set

• 无序集合

• 集合就是把一些右有关联的数据放到一起

• 集合中的元素是有序的！例如：[1,2,3] 和 [2,1,3] 是不同的

• 集合中的元素是不能重复的（唯一的）

• 集合中的每个元素也都是 string 类型的

SADD

• 向一个集合添加元素

sadd key member [member ...]

• 该命令可以一次添加一个元素，也可以一次添加多个元素

• 返回值就是本次添加成功的个数

• 添加元素

  127.0.0.1:6379> sadd key 1 2 3 4
  (integer) 4
  

  表示我们添加成功 4 个元素

• 添加重复元素

  127.0.0.1:6379> sadd key1 1 1 2 3 4 
  (integer) 4
  

  这次添加了两个 1，下面显示我们添加了4 个元素，显然是重复的 1 值添加了一个

SMEMBERS

• 查看集合中的元素

smembers key

• 返回值就是对应 key 中所有的元素

• 如果没有返回空

• 查看

  127.0.0.1:6379> smembers key
  1) "1"
  2) "2"
  3) "3"
  4) "4"
  

SISMEMBER

• 查看一个元素是否在集合中

sismember key member

• 返回值0 或者 1

• 0 表示没有

• 1 表示有

• 查看元素是否存在

  127.0.0.1:6379> sismember key 1
  (integer) 1
  127.0.0.1:6379> sismember key 100
  (integer) 0
  

SPOP

• 随机删除一个 key 里面的元素

spop key [count]

• count 表示删除几个元素，如果不写，就代表随机删除1 个，写了的话，那么就是我们写的个数

• 返回值，删除的元素

• 如果删除没有的 key 那么返回 nil

• 构建案例

  127.0.0.1:6379> sadd key 1 2 3 4
  (integer) 4
  

• 删除一个值

  127.0.0.1:6379> spop key
  "1"
  

• 删除全部的值

  127.0.0.1:6379> spop key
  "1"
  127.0.0.1:6379> spop key
  "3"
  127.0.0.1:6379> spop key
  "2"
  127.0.0.1:6379> spop key
  "4"
  

  这就是删除的顺序，那么下一次我们还是随机删除吗？我们的随即删除是真随机还是对不同的集合删除的顺序不同？下面我们试一下。

• 重新构建

  127.0.0.1:6379> sadd key 1 2 3 4 
  (integer) 4
  

• 全部删除

  127.0.0.1:6379> spop key
  "2"
  127.0.0.1:6379> spop key
  "1"
  127.0.0.1:6379> spop key
  "4"
  127.0.0.1:6379> spop key
  "3"
  

  这一次我们的删除顺序是和上一次时不同的，实际上，在官方文档里面也是表明了，redis 的spop 的删除就是随机删除。

SCARD

• 获取集合中元素的个数

scard key

SRANDMEMBER

• 随机获得一个数

srandmember key [count]

• count 为 获取到随机数的个数

• 返回值就是获取到的随机值

• 随机获取一个

  127.0.0.1:6379> srandmember key
  "4"
  

SMOVE

• 将一个元素从一个集合移动到另一个集合

smove source destination member

• 该命令就表示把 memeber 从 source 移动到 destination

• 返回值，移动成功，返回 1，否则返回 0

• 移动元素

127.0.0.1:6379> smove key key1 1
(integer) 1
127.0.0.1:6379> smove key key1 2
(integer) 1

• 查看

  127.0.0.1:6379> smembers key
  1) "3"
  2) "4"
  127.0.0.1:6379> smembers key1
  1) "1"
  2) "2"
  3) "5"
  4) "6"
  5) "7"
  6) "8"
  

• 那么如果从 souce 里面移动的元素到 destination 里面有重复元素呢？

  127.0.0.1:6379> sadd key 1
  (integer) 1
  127.0.0.1:6379> sadd key1 1 2 3 4
  (integer) 4
  

  将 1 从 key 里面移动到 key1 里面

  127.0.0.1:6379> smove key key1 1
  (integer) 1
  

• 查看

  127.0.0.1:6379> smembers key
  (empty list or set)
  127.0.0.1:6379> smembers key1
  1) "1"
  2) "2"
  3) "3"
  4) "4"
  

• 那么如果 souce 里面没有要移动的元素呢？

  127.0.0.1:6379> sadd key 2 3 4
  (integer) 3
  127.0.0.1:6379> sadd key1 5 6 7 8
  (integer) 4
  

  将 1 从 souce 移动到 destination 里面

  127.0.0.1:6379> smove key key1 1
  (integer) 0
  

  这里移动失败返回 0

SREM

• 删除集合中的元素

srem key member [member ...]

• 可以一次删除多个值

• 返回值就是删除成功的个数

• 构建案例

  127.0.0.1:6379> sadd key 1 2 3 4
  (integer) 4
  

• 删除一个值

  127.0.0.1:6379> srem key 4
  (integer) 1
  

• 删除多个值

  127.0.0.1:6379> srem key 1 2 3
  (integer) 3
  

SINTER

• 求多个集合的交集

sinter key [key ...]

• 返回值就是求到的交际的元素

• 构建案例

  127.0.0.1:6379> sadd key1 1 2 3 4
  (integer) 4
  127.0.0.1:6379> sadd key2 3 4 5 6
  (integer) 4
  

• 求交集

  127.0.0.1:6379> sinter key1 key2
  1) "3"
  2) "4"
  

SINTERSTORE

• 也是求交集

sinterstore destination key [key ...]

• 但是返回值不同，这个命令的返回值是交集元素的个数

• destination 表示求到的交集存储到该key 里面

• 求交集

  127.0.0.1:6379> sinterstore key3 key1 key2
  (integer) 2
  

• 查看

  127.0.0.1:6379> smembers key3
  1) "3"
  2) "4"
  

SUNION

• 查询集合的并集

sunion key [key ...]

• 返回值就是查询到的集合的并集

• 查询并集

  127.0.0.1:6379> sunion key1 key2
  1) "1"
  2) "2"
  3) "3"
  4) "4"
  5) "5"
  6) "6"
  

SUNIONSTORE

• 也是查询并集

sunionstore destination key [key ...]

• 但是返回值不同，该命令返回值是查询到并集的个数

• destination 是查询到的并集存储的 key

• 查看并集

  127.0.0.1:6379> sunionstore key4 key1 key2
  (integer) 6
  

• 查询

  127.0.0.1:6379> smembers key4
  1) "1"
  2) "2"
  3) "3"
  4) "4"
  5) "5"
  6) "6"
  

SDIFF

• 查询集合的差集

sdiff key [key ...]

• 返回值就是查询到的差集

• 查询差集

  127.0.0.1:6379> sdiff key1 key2
  1) "1"
  2) "2"
  

• 由于 A 和 B 的差集 与 B 和 A 的差集是不同的，所以我们换一下位置

  127.0.0.1:6379> sdiff key2 key1
  1) "5"
  2) "6"
  

SDIFFSTORE

• 查询差集

sdiffstore destination key [key ...]

• 返回值是查询到差集的个数

• destination 是查询到的差集的存放的 key

• 查询差集

  127.0.0.1:6379> sdiffstore key5 key1 key2
  (integer) 2
  

• 查询

  127.0.0.1:6379> smembers key5
  1) "1"
  2) "2"
  

编码方式

• intset：整数集合，当元素均为整数，并且元素个数不是很多的时候，使用 intset

• hashtable：哈希表

zset

• 有序结合（升序或者降序）

• 排序规则：给 zset 引入了一个数属性 分数（score），浮点类型

• 每个 member 都会安排一个分数

• 进行排序的时候，就是一宅次数的分数大小来进行升序或者降序排序

• 里面的元素是不可以重复的，但是分数可以重复

• zset 主要还是存储 member ，分数只是一个辅助

ZADD

• 添加 zadd 类型元素

zadd key [NX|XX] [CH] [INCR] score member [score member ...]

• [] 表示可选项

• zadd 不仅有 member 还有 score ，所以在添加元素的时候还需要添加 score

• NX 表示如果没有 member 那么就插入，有的话就不插入

• XX 表示如果有 member 那么就跟新 score 否则就不跟新

• 如果 NX 和 XX 都不带的话，表示如果没有member 就插入 ，有的话就跟新 score

• INCR 表示跟新 score 为新值，可以指定新值进行自增或者自减

• CH 表示修改了分值的成员数量，包括添加新的成员和跟新了已存在的成员的分值

• 添加元素

  127.0.0.1:6379> zadd key 98 貂蝉 99 林黛玉 97 女儿国王
  3
  

ZRANGE

• 查看 zadd 类型数据

zrange key start stop [WITHSCORES]

• 返回值就是查到的数据

• start 和 stop 为范围，可以为负数

• WITHSOCORES 表示显示的时候带上分数

• 查询

  127.0.0.1:6379> zrange key 0 -1
  女儿国王
  貂蝉
  林黛玉
  

• 带分数查询

  127.0.0.1:6379> zrange key 0 -1 withscores
  女儿国王
  97
  貂蝉
  98
  林黛玉
  99
  

• 插入member 重复但是 score 不重复的值

  127.0.0.1:6379> zadd key 100 林黛玉
  0
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  女儿国王
  97
  貂蝉
  98
  林黛玉
  100
  

ZADD 选项查看

• NX：不存在即插入

  127.0.0.1:6379> zadd key 110 貂蝉
  0
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  女儿国王
  97
  林黛玉
  100
  貂蝉
  110
  

• XX ：存在就修改，不存在不插入

  127.0.0.1:6379> zadd key xx 95 大桥
  0
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  女儿国王
  97
  林黛玉
  100
  貂蝉
  110
  

• CH：不存在插入，存在就修改 score

  127.0.0.1:6379> zadd key ch 99 女儿国王
  1
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  女儿国王
  99
  林黛玉
  100
  貂蝉
  110
  

• INCR：不存在插入，存在就修改 score，返回修改后的分数

  127.0.0.1:6379> zadd key incr 66 廉颇
  66
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  廉颇
  66
  女儿国王
  99
  林黛玉
  100
  貂蝉
  110
  

ZCARD

• 获取当前 key 里面的元素个数

zcard key

ZCOUNT

• 返回在一定分数范围内的元素个数

zcount key min max

• min 表示底分数线

• max 表示高分数线

• 这两个分数线都是闭区间

• 如果想要是开区间，可以加 '('

• min 和 max 还可以是 inf 和 -inf

• 查看所有人

  127.0.0.1:6379> zrange key 0 -1 withscores
  廉颇
  66
  西施
  95
  女儿国王
  99
  林黛玉
  100
  貂蝉
  110
  

• 查看分数在 95 到 110 的人

  127.0.0.1:6379> zcount key 95 110
  4
  

• 不想包含 95

  127.0.0.1:6379> zcount key (95 110
  3
  

• 不想包含 110

  127.0.0.1:6379> zcount key 95 (110
  3
  

  是的！上面并没有写错

• 两个都不想包含

  127.0.0.1:6379> zcount key (95 (110
  2
  

  在说明一下，上面没有写错，就是这么个格式

• 使用 inf 和 -inf

  127.0.0.1:6379> zcount key -inf inf
  5
  

ZREVRANGE

• 获取元素逆序的结果

zrevrange key start stop [WITHSCORES]

• 其他条件个 zrange 相同

• 查看逆序的元素

  127.0.0.1:6379> zrevrange key 0 -1
  貂蝉
  林黛玉
  女儿国王
  西施
  廉颇
  

• 也可以带 withscores

  127.0.0.1:6379> zrevrange key 0 -1 withscores
  貂蝉
  110
  林黛玉
  100
  女儿国王
  99
  西施
  95
  廉颇
  66
  

ZRANGEBYSCORE

• 该命令可以通过分数获得元素

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

• limit offset count 可以限制获取到的个数

• 其余的和zrange 相同

• 获取元素

  127.0.0.1:6379> zrangebyscore key 95 110
  西施
  女儿国王
  林黛玉
  貂蝉
  

• 剩下的就不进行示范了

ZPOPMAX

• 删除有序集合中 score 最大的值

zpopmax key [count]

• count 表示删除的个数，不写代表 1

• 返回值是删除后的元素（member 和 score）

• 删除一个元素

  127.0.0.1:6379> zpopmax key
  貂蝉
  110
  

• 删除多个元素

  127.0.0.1:6379> zpopmax key 2
  林黛玉
  100
  女儿国王
  99
  

BZPOPMAX

• 阻塞删除分数最大的值

bzpopmax key [key ...] timeout

• 如果当前 key 有数据，那么就直接删除

• 如当前 key 没有数据，那么就会阻塞

• timeout 表示超时时间，单位秒

• 如果没有数据，超出超时时间就会返回

• 返回值是 key 与 删除的元素还有 score

• 删除空 key

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> bzpopmax key 1
  

  表示阻塞一秒，如果一秒内还没有数据，那么就会返回 nil

• 删除有数据的 key

  127.0.0.1:6379> bzpopmax key 0
  key
  hello
  1
  

ZPOPMIN

• 删除 score 最小的值

zpopmin key [count]

• 该命令与 zpopmax 基本一样所以这里也就不多解释

BZPOPMIN

• 阻塞删除 score 的最小值

bzpopmin key [key ...] timeout

• 该命令与 bzpopmax 一样，不解释

ZRANK

• 查看一个元素的排名

zrank key member

• 返回值是该元素的根据 score 的排名，默认升序

• 如果没有对应的 key 那么返回空

• 构建案例

  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu
  3
  

• 查询元素

  127.0.0.1:6379> zrank key zhangsan
  0
  127.0.0.1:6379> zrank key lisi
  1
  127.0.0.1:6379> zrank key oo
  

ZREVRANK

• 返回指定元素的排名

zrevrank key member

• 该命令和前面的 ZREVRANGE 是很相似的，都是从后往前

• 所以该命令获取到的排名是降序的排名

• 剩下的和 ZRANK 一样

ZREM

• 删除指定的元素

zrem key member [member ...]

• 一次可以删除多个元素

• 返回值就是删除成功的元素个数

• 构建案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu 40 zhaoliu 50 tianqi
  5
  

• 删除元素

  127.0.0.1:6379> zrem key zhaoliu tianqi
  2
  

• 查看是否删除

  127.0.0.1:6379> zrange key 0 -1
  zhangsan
  lisi
  wangwu
  

ZREMRANGEBYRANK

• 删除一个范围内的元素

zremrangebyrank key start stop

• 根据下标的范围删除该范围内的元素

• start 和 stop 是闭区间，也可以为负数

• 返回值是删除成功元素的个数

• 构建案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu 40 zhaoliu 50 tianqi
  5
  

• 删除一个范围内的元素

  127.0.0.1:6379> zremrangebyrank key 1 2
  2
  

• 查看是否删除成功

  127.0.0.1:6379> zrange key 0 -1
  zhangsan
  zhaoliu
  tianqi
  

ZREMRANGEBYSCORE

• 删除一个范围的元素

zremrangebyscore key min max

• 不过这个范围是根据分数的范围

• 剩下的和上面的命令一样

• 构建案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu 40 zhaoliu 50 tianqi
  5
  

• 删除元素

  127.0.0.1:6379> zremrangebyscore key 30 50
  3
  

• 查看是否被删除

  127.0.0.1:6379> zrange key 0 -1
  zhangsan
  lisi
  

ZINCRBY

• 对指定元素的分数进行加一个值

zincrby key increment member

• 返回值就是该元素的分数增加指定分数后的分数

• 如果没有对应的 member 默认从 0 开始

• 构建案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu 40 zhaoliu 50 tianqi
  5
  

• 对空member 进行增加

  127.0.0.1:6379> zincrby key 1 sunba
  1
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  sunba
  1
  zhangsan
  10
  lisi
  20
  wangwu
  30
  zhaoliu
  40
  tianqi
  50
  

• 对指定元素进行增加一个值

  127.0.0.1:6379> zincrby key 100 zhangsan
  110
  

• 查看

  127.0.0.1:6379> zrange key 0 -1 withscores
  sunba
  1
  lisi
  20
  wangwu
  30
  zhaoliu
  40
  tianqi
  50
  zhangsan
  110
  

对于 zset 在 6.2 版本后有 inter union zdiff 但是现在的测试版本是 5 系列的，所以并没有上述的命令，但是该版本有下面的两个命令：

ZINTERSOTORE

• 求交集

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

• 该命令就是求交集

• 求到的交集存储到 destination 中

• numkeys 表示求交集的 key 一共有多少个

• weights 表示权重

• 权重就是在求交集的时候，每个 key 里面的分数乘对应的权重

• agreegate 表示求交集的时候分数如何处理，这里默认是分数求和，还可以取最大值，或者最小值

• 构建案例

  127.0.0.1:6379> flushall
  OK
  127.0.0.1:6379> zadd key 10 zhangsan 20 lisi 30 wangwu
  3
  127.0.0.1:6379> zadd key1 15 zhangsan 25 lisi 35 zhaoliu
  3
  

• 求交集，不带任何可选项

  127.0.0.1:6379> zinterstore key2 2 key key1
  2
  

• 查看求到的交集

  127.0.0.1:6379> zrange key2 0 -1 withscores
  zhangsan
  25
  lisi
  45
  

  如果什么都不带的话，就是默认，这里默认的分数就是 sum，不带权重的话，每个 key 的分数就是本身的分数

• 求交集，带权重

  127.0.0.1:6379> zinterstore key3 2 key key1 weights 10 10
  2
  

• 查看不到的交集

  127.0.0.1:6379> zrange key3 0 -1 withscores
  zhangsan
  250
  lisi
  450
  

• 求交集，带aggregate

  127.0.0.1:6379> zinterstore key4 2 key key1 aggregate max
  2
  

• 查看求到的交集

  127.0.0.1:6379> zrange key4 0 -1 withscores
  zhangsan
  15
  lisi
  25
  

ZUNIONSTORE

• 求并集

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

• 哪些参数和上面的那个命令的参数相同

• 下面也就不多演示了

编码方式

• ziplist：如果当前集合中的元素比较少，或者元素体积小，就会使用 ziplist

• skiplist：如果当前元素个数比较多，或者是单个元素的提交较大，就会使用 skiplist