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