Redis的5种主要数据类型及相应的命令

1. 热身

1.1 获取符合规则的键名列表

keys pattern

pattern支持glob风格通配符格式

? 匹配一个字符
* 匹配任意个字符（包括0个）
[] 匹配括号间的任一字符，可以用‘-’符号表示一个范围，如a[b-d]可以匹配‘ab’、‘ac’、‘ad’
\x 匹配字符x，用于转义符号，如果要匹配“？”就需要输入\？

举栗子

# *
127.0.0.1:6379> set dog xiaohei
OK
127.0.0.1:6379> set chick xiaoji
OK
127.0.0.1:6379> set elephant daxiang
OK
127.0.0.1:6379> keys *
1) "elephant"
2) "chick"
3) "dog"
127.0.0.1:6379> keys d*
1) "dog"
# ?
127.0.0.1:6379> keys d?g
1) "dog"
127.0.0.1:6379> keys chic?
1) "chick"
127.0.0.1:6379> keys ?lephant
1) "elephant"
# []
127.0.0.1:6379> keys d[a-o]g
1) "dog"
127.0.0.1:6379> keys c[a-h]i[a-c]k
1) "chick"
# \
127.0.0.1:6379> set x aa
OK
127.0.0.1:6379> set ? aa
OK
127.0.0.1:6379> keys ?
1) "x"
2) "?"
127.0.0.1:6379> keys \?
1) "?"

注意： keys命令需要遍历redis中所有的键，当键的数量较多时会影响性能，不建议在生产环境中使用。
1.2 判断一个键是否存在

# 如果键存在则返回整数1，否则返回0，可以同时判断多个
exists key [key ...]

举栗子

127.0.0.1:6379> keys *
1) "elephant"
2) "x"
3) "chick"
4) "?"
5) "dog"
127.0.0.1:6379> exists dog
(integer) 1
127.0.0.1:6379> exists dog x chick
(integer) 3
127.0.0.1:6379> exists apple
(integer) 0

1.3 删除键

# 可以删除一个或多个键，返回值是删除的键的个数（del命令的参数不支持通配符）
del key [key ...]

举栗子

127.0.0.1:6379> keys *
1) "elephant"
2) "x"
3) "chick"
4) "?"
5) "dog"
127.0.0.1:6379> del chick ?
(integer) 2
127.0.0.1:6379> del apple
(integer) 0

技巧：del命令的参数不支持通配符，如果想使用通配符可以用下面的命令

127.0.0.1:6379> keys *
1) "elephant"
2) "x"
3) "dog"
127.0.0.1:6379> redis-cli keys e* | xargs redis-cli del
(error) ERR unknown command 'redis-cli'
# 删除所有e开头的键
[root@server01 ~]# redis-cli keys e* | xargs redis-cli del
(integer) 1
[root@server01 ~]# redis-cli
127.0.0.1:6379> keys *
1) "x"
2) "dog"
# 删除所有d开头的键
[root@server01 ~]# redis-cli del `redis-cli keys d*`
(integer) 1

1.4 获取键值的数据类型

type key

type命令用来获取键值的数据类型，返回值可能是string(字符串类型)、hash（散列类型）、list（列表类型）、set（集合类型）、zset（有序集合类型）

举栗子

127.0.0.1:6379> type x
string
127.0.0.1:6379> type oraneg
list

2. 字符串类型

字符串类型是redis中最基本的数据类型，他能存储任何形式的字符串，包括二进制数据。一个字符串类型键允许存储的数据的最大容量是512MB
2.1 赋值与取值

# 赋值
set key value
# 取值
get key

举栗子

127.0.0.1:6379> set app application
OK
127.0.0.1:6379> get app
"application"
# key不存在返回nil
127.0.0.1:6379> get aaaa
(nil)

2.2 递增数字

# 当存储的字符串是整数时，incr可以让当前的键值递增，并返回递增后的值
incr key

举栗子

127.0.0.1:6379> set number 1
OK
127.0.0.1:6379> get number
"1"
127.0.0.1:6379> incr number
(integer) 2
127.0.0.1:6379> keys *
1) "number"
# 当键不存在时会默认值为0，所以第一次递增后的结果为1
127.0.0.1:6379> incr num
(integer) 1

2.3 增加指定的整数

# increment 指定每次增加多少数量
incrby key increment

举栗子

127.0.0.1:6379> get number
"4"
127.0.0.1:6379> incrby number 3
(integer) 7
127.0.0.1:6379> incrby number 4
(integer) 11

2.4 减少指定的整数

# 默认减1
decr key
# 减少指定整数
decrby key decrement

举栗子

127.0.0.1:6379> get number
"11"
127.0.0.1:6379> decr number
(integer) 10
127.0.0.1:6379> decrby number 2
(integer) 8
127.0.0.1:6379> decrby number 3
(integer) 5

2.5 增加指定浮点数

incrbyfloat key increment

举栗子

127.0.0.1:6379> get num
"1"
127.0.0.1:6379> incrbyfloat num 2.3
"3.3"
127.0.0.1:6379> incrbyfloat num 3.4
"6.7"

2.6 向尾部追加值

# appent的作用是向键值的末尾追加value，如果键不存在则将该键的值设置为value，返回值是追加后字符串总长度
append key value

举栗子

127.0.0.1:6379> set pig pigpig
OK
127.0.0.1:6379> get pig
"pigpig"
127.0.0.1:6379> append pig dog
(integer) 9
127.0.0.1:6379> get pig
"pigpigdog"

2.7 获取字符串的长度

# 返回值是键值的长度，键不存在则返回0
strlen key

举栗子

127.0.0.1:6379> set key 你好
OK
127.0.0.1:6379> get key
"\xe4\xbd\xa0\xe5\xa5\xbd"
127.0.0.1:6379> get pig
"pigpigdog"
127.0.0.1:6379> strlen pig
(integer) 9
# redis使用的是utf-8 一个中文对应3个字符
127.0.0.1:6379> strlen key
(integer) 6

2.8 同时获得/设置多个键值

# 获得
mget key [key ...]
# 设置
mset key value [key value ...]

举栗子

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v2
OK
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v2"

2.9 位操作

# 获取二进制某一位上的值
getbit key offset
# 设置二进制某一位上的值
setbit key offset value
# 获取字符串二进制键值中1的二进制位个数
bitcount key [start] [end]
# 对多个字符串类型键位运算，结果存储到destkey键中
bitop key destkey key [key ...]

举栗子

# bar三个字母对应的ASCII码分别为98、97、114，转换成二进制分别为01100010、01100001、01110010，存储的值就是二进制值的拼接
127.0.0.1:6379> set foo bar
OK
127.0.0.1:6379> get foo
"bar"
# 索引从0开始
127.0.0.1:6379> getbit foo 0
(integer) 0
127.0.0.1:6379> getbit foo 5
(integer) 0
127.0.0.1:6379> getbit foo 6
(integer) 1
127.0.0.1:6379> getbit foo 7
(integer) 0
# 如果超出实际二进制长度，则默认位值为0
127.0.0.1:6379> getbit foo 10000
(integer) 0
#####################################
127.0.0.1:6379> get foo
"bar"
# 返回值为位上的旧值
127.0.0.1:6379> setbit foo 5 1
(integer) 0
127.0.0.1:6379> get foo
"far"
127.0.0.1:6379> get foo
"far"
# 如果设置的位置超过了二进制的长度，setbit会自动将中间的二进制位设置为0
127.0.0.1:6379> setbit foo 30 1
(integer) 0
127.0.0.1:6379> getbit foo 29
(integer) 0
127.0.0.1:6379> get foo
"far\x02"
# 如果键不存在，也会自动将其前面的位赋值为0
127.0.0.1:6379> setbit nofoo 10 1
(integer) 0
127.0.0.1:6379> getbit nofoo 5
(integer) 0
127.0.0.1:6379> get nofoo
"\x00 "
##############################
127.0.0.1:6379> get foo
"far\x02"
# 获取字符串二进制键值中1的二进制位个数
127.0.0.1:6379> bitcount foo
(integer) 12
# 也可以设置参数来指定范围，比如要统计前两个字符fa
127.0.0.1:6379> bitcount foo 0 1
(integer) 7
###################################
127.0.0.1:6379> set foo1 bar
OK
127.0.0.1:6379> set foo2 aar
OK
# 将两个字符串进行位运算，将结果存在destkey参数指定的键中，操作符可以有and、or、xor、not，or运算就是二进制位上有1取1，没1取0
127.0.0.1:6379> bitop or res foo1 foo2
(integer) 3
127.0.0.1:6379> get res
"car"
# 获取键值中第一个二进制位为1的偏移量
127.0.0.1:6379> bitpos foo 1
(integer) 2
# 获取范围在1~2字节中（ar）二进制位为1的偏移量
127.0.0.1:6379> bitpos foo 1 1 2
(integer) 9

3. 散列类型

Redis是采用字典结构以键值对的形式存储数据的，而散列类型（hash）的键值也是一种字典结构，其存储了字段和字段值的映射，但字段值只能是字符串，不支持其他数据类型，一个散列类型键可以包含至多2的32次-1个字段。

3.1 赋值和取值

# 赋值
hset key field value
# 取值
hget key field 
# 同时赋值多个
hmset key field value [field value ...]
# 同时取多个值
hmget key field [field ...]
# 获取所有的字段和值
hgetall key 

hset的方便之处在于不区分插入和更新操作，当执行插入操作时返回1，更新操作时返回0。
举栗子

# 设值
127.0.0.1:6379> hset car:1 price 10000
(integer) 1
127.0.0.1:6379> hset car:1 name geely
(integer) 1
127.0.0.1:6379> hset car:1 color red
(integer) 1
# 取值
127.0.0.1:6379> hget car:1 name
"geely"
# 同时设多个值
127.0.0.1:6379> hmset car:1 tyre four engine three
OK
# 同时取多个值
127.0.0.1:6379> hmget car:1 name price color tyre engine
1) "geely"
2) "10000"
3) "red"
4) "four"
5) "three"
# 取所有的字段和值，返回的是字段和值一一对应的列表
127.0.0.1:6379> hgetall car:1
 1) "price"
 2) "10000"
 3) "name"
 4) "geely"
 5) "color"
 6) "red"
 7) "tyre"
 8) "four"
 9) "engine"
10) "three"

3.2 判断字段是否存在

# 该命令用来判断一个字段是否存在，如果存在返回1，否则返回0,如果键不存在也会返回0
hexists key field

举栗子

# 键和字段存在
127.0.0.1:6379> hexists car:1 name
(integer) 1
# 字段不存在
127.0.0.1:6379> hexists car:1 model
(integer) 0
# 键不存在
127.0.0.1:6379> hexists car:2 name
(integer) 0

3.3 当字段不存在时赋值

# 该命令与hset类似，区别在于如果字段已经存在，该命令不做任何操作
hsetnx key field value

举栗子

127.0.0.1:6379> hsetnx car:1 name dongfeng
(integer) 0
127.0.0.1:6379> hsetnx car:1 model xingyue
(integer) 1

3.4 增加数字

# 与字符串中incrby类似，使字段值增加指定的整数，散列中没有hincr，可以用hincrby key field 1来实现
hincrby key field increment

举栗子

# student键不存在，该命令会自动建立键并默认值为0，返回值为增值后的值
127.0.0.1:6379> hincrby student score 60
(integer) 60

3.5 删除字段

# 删除一个或多个字段，返回值是被删除的字段个数
hdel key field [field ...]

举栗子

127.0.0.1:6379> hgetall car:1
 1) "price"
 2) "10000"
 3) "name"
 4) "geely"
 5) "color"
 6) "red"
 7) "tyre"
 8) "four"
 9) "engine"
10) "three"
11) "model"
12) "xingyue"
127.0.0.1:6379> hdel car:1 tyre engine model
(integer) 3
127.0.0.1:6379> hdel car:1 model
(integer) 0
127.0.0.1:6379> hgetall car:1
1) "price"
2) "10000"
3) "name"
4) "geely"
5) "color"
6) "red"

3.6 只获取字段名或字段值

# 只获取字段名
hkeys key 
# 只获取值
hvals key

举栗子

127.0.0.1:6379> hkeys car:1
1) "price"
2) "name"
3) "color"
127.0.0.1:6379> hvals car:1
1) "10000"
2) "geely"
3) "red"

3.7 获取字段数量

hlen key
# 获取key中字段的数量
127.0.0.1:6379> hlen car:1
(integer) 3

4. 列表类型

列表类型（list）可以存储一个有序的字符串列表，常用的操作是向列表两端添加元素或者获得列表的某一个片段。list内部是使用双向链表实现的，所以向两端添加元素的时间复杂度为O(1)，获得越接近两端的元素速度越快，一个列表类型键最多能容纳2的32次-1个元素。

4.1 向列表两端增加元素

# 向列表左边增加元素，返回值表示增加元素后列表的长度
lpush key value [value ...]
# 向列表右边增加元素，返回值表示增加元素后列表的长度
rpush key value [value ...]

举栗子

# 向左侧加一个元素
127.0.0.1:6379> lpush numbers 1
(integer) 1
# 向左侧加多个元素
127.0.0.1:6379> lpush numbers 2 3 4
(integer) 4
# 向右侧加多个元素
127.0.0.1:6379> rpush numbers 0 -1 -2
(integer) 7
# 添加完之后列表排列 4 3 2 1 0 -1 -2

4.2 从列表两端弹出元素

# 列表左侧弹出一个元素，返回被移除的元素值
lpop key 
# 列表右侧弹出一个元素，返回被移除的元素值
rpop key 

举栗子

127.0.0.1:6379> lrange numbers 0 10
1) "4"
2) "3"
3) "2"
4) "1"
5) "0"
6) "-1"
7) "-2"
127.0.0.1:6379> lpop numbers
"4"
127.0.0.1:6379> rpop numbers
"-2"
127.0.0.1:6379> lrange numbers 0 10
1) "3"
2) "2"
3) "1"
4) "0"
5) "-1"

4.3 获取列表中元素的个数

# 当键不存在时llen会返回0
llen key

举栗子

127.0.0.1:6379> llen numbers
(integer) 5

4.4 获取列表片段

# 获取列表中的某一片段，返回索引从start-stop之间的所有元素（包含两端），索引从0开始，同时还支持负索引
lrange key start stop

举栗子

127.0.0.1:6379> lrange numbers 0 10
1) "3"
2) "2"
3) "1"
4) "0"
5) "-1"
127.0.0.1:6379> lrange numbers 0 2
1) "3"
2) "2"
3) "1"
127.0.0.1:6379> lrange numbers -2 0
(empty list or set)
# 支持负索引，表示从右边开始计算序数，-1表示最右边第一个元素，-2表示最右边第二个，依次类推
127.0.0.1:6379> lrange numbers -2 -1
1) "0"
2) "-1"
# 0 -1可以获取所有元素
127.0.0.1:6379> lrange numbers 0 -1
1) "3"
2) "2"
3) "1"
4) "0"
5) "-1"
# 还有一些特殊情况
# 1.如果start的索引位置比stop的索引位置靠后，则会返回空列表
127.0.0.1:6379> lrange numbers 2 1
(empty list or set)
# 2.如果stop大于实际的索引范围，则会返回到列表最右边的元素
127.0.0.1:6379> lrange numbers 1 999
1) "2"
2) "1"
3) "0"
4) "-1"

4.5 删除列表中指定的值
删除列表中前count个值为value的元素，返回值是实际删除的数据。根据count值的不同，lrem命令的执行方式会略有差异
（1）当count > 0时，lrem命令会从列表左侧开始删除前count个值为value的元素
（2）当count < 0时，lrem命令会从列表右边开始删除前|count|个值为value的元素
（3）当count = 0时，lrem命令会删除所有值为value的元素

lrem key count value

举栗子

127.0.0.1:6379> lrange numbers 0 -1
1) "3"
2) "2"
3) "1"
4) "0"
5) "-1"
127.0.0.1:6379> lrem numbers 1 3
(integer) 1
127.0.0.1:6379> lrem numbers -1 -1
(integer) 1
127.0.0.1:6379> lrem numbers 0 0
(integer) 1
127.0.0.1:6379> lrange numbers 0 -1
1) "2"
2) "1"
127.0.0.1:6379>

4.6 获得/设置指定索引的元素值

# 返回指定索引的元素
lindex key index
lset key index value

举栗子

127.0.0.1:6379> lrange numbers 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
6) "-1"
7) "-2"
8) "-3"
# index>=0时，从左边开始，索引从0开始
127.0.0.1:6379> lindex numbers 0
"5"
127.0.0.1:6379> lindex numbers -2
"-2"
# index是负数时从右边开始计算索引，最右边的索引是-1
127.0.0.1:6379> lindex numbers -1
"-3"
# 修改指定索引处的元素值
127.0.0.1:6379> lset numbers -2 2
OK
127.0.0.1:6379> lindex numbers -2
"2"

4.7 只保留列表指定片段
该命令可以删除指定索引范围之外的所有元素

ltrim key start end

举栗子

127.0.0.1:6379> lrange numbers 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"
6) "-1"
7) "2"
8) "-3"
127.0.0.1:6379> lrange numbers 0 1
1) "5"
2) "4"
127.0.0.1:6379> ltrim numbers 3 4
OK
127.0.0.1:6379> lrange numbers 0 -1
1) "2"
2) "1"

ltrim命令常和lpush命令一起使用来限制列表中的元素，比如记录日志希望只保留100条日志

lpush logs $newLogs
ltrim 0 99

4.8 向列表中插入元素
linsert 命令首先会在列表中从左到右查找值为pivot的元素，然后根据第二个参数是before还是after来决定将value插入到该元素的前面还是后面，返回值是插入后列表的元素个数

linsert key before|after pivot value

举栗子

127.0.0.1:6379> lrange numbers 0 -1
1) "9"
2) "8"
3) "7"
4) "2"
5) "1"
127.0.0.1:6379> linsert numbers after 7 4
(integer) 6
127.0.0.1:6379> lrange numbers 0 -1
1) "9"
2) "8"
3) "7"
4) "4"
5) "2"
6) "1"
127.0.0.1:6379> linsert numbers before 7 11
(integer) 7
127.0.0.1:6379> lrange numbers 0 -1
1) "9"
2) "8"
3) "11"
4) "7"
5) "4"
6) "2"
7) "1"

4.9 将元素从一个列表转到另一个列表

# 该命令会先从source列表右边弹出一个元素，然后添加到destination列表的左边，并返回这个元素的值，整个过程是原子的
rpoplpush source destination

5. 集合类型

集合中的每个元素都是不同的，且没有顺序。一个集合类型(set)键可以存储至多2的32次-1个字符串。

5.1 增加/删除元素
sadd 命令用来向集合中增加一个或多个元素，如果键不存在则会自动创建。如果加入的元素集合中已经存在则会忽略这个元素，返回值是成功加入的元素数量。
srem 命令用来删除集合中一个或者多个元素，并返回删除成功的个数。

# 增加元素
sadd key member [member ...]
# 删除元素
srem key member [member ...]

举栗子

127.0.0.1:6379> sadd letters a
(integer) 1
127.0.0.1:6379> sadd letters a b c
(integer) 2
127.0.0.1:6379> srem letters c d
(integer) 1

5.2 获得集合中的所有元素

smembers key
# 返回集合中所有的元素
127.0.0.1:6379> smembers letters
1) "a"
2) "b"

5.3 判断元素是否在集合中
判断一个元素是否在集合中，当值存在，返回1，当值不存在或者键不存在返回0

sismember key member

举栗子

127.0.0.1:6379> sismember letters a
(integer) 1
127.0.0.1:6379> sismember letters c
(integer) 0

5.4 集合间运算

sdiff key [key ...]
sinter key [key ...]
sunion key [key ...]

(1) sdiff 命令用来对多个集合执行差集运算，集合A与集合B的差集表示为A-B，代表所有属于A且不属于B的元素构成的集合.

举栗子

127.0.0.1:6379> sadd setA 1 2 3
(integer) 3
127.0.0.1:6379> sadd setB 2 3 4 5
(integer) 4
127.0.0.1:6379> sdiff setA setB
1) "1"
127.0.0.1:6379> sdiff setB setA
1) "4"
2) "5"
127.0.0.1:6379> sadd setC 2 3
(integer) 2
# 支持传入多个集合，计算顺序是先计算A和B集合的，再计算结构与C的差集
127.0.0.1:6379> sdiff setA setB setC
1) "1"

(2) sinter 命令用来对多个集合执行交集运算，交集代表所有属于A且属于B的元素构成的集合

127.0.0.1:6379> sinter setA setB
1) "2"
2) "3"
127.0.0.1:6379> sinter setA setB setC
1) "2"
2) "3"

(3) sunion 命令用来对多个集合进行并集运算，并集就是所有集合不重复的元素合成一个集合

127.0.0.1:6379> sunion setA setB
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
127.0.0.1:6379> sunion setA setB setC
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"

5.5 获得集合中元素个数

scard key 
# 获得集合中元素的个数
127.0.0.1:6379> scard setB
(integer) 4

5.6 进行集合运算并将结果存储

# 差集，并将返回的结果存入destination集合中
sdiffstore destination key [key ...]
# 交集，并将返回的结果存入destination集合中
sinterstore destination key [key ...]
# 并集，并将返回的结果存入destination集合中
sunionstore destination key [key ...]

5.7 随机获得集合中的元素

# 随机从集合中获取一个元素
srandmember key [count]

127.0.0.1:6379> srandmember letters
"b"
127.0.0.1:6379> srandmember letters
"b"
127.0.0.1:6379> srandmember letters
"a"
# 可以传递count参数来一次随机获取多个元素
# 当count为正数时，随机从集合中获取count个不重复的元素，如果count大于集合的元素个数，返回集合中全部元素
# 当count为负数时，随机从集合中获取|count|个元素，这些元素有可能相同
127.0.0.1:6379> srandmember letters 3
1) "f"
2) "a"
3) "e"
127.0.0.1:6379> srandmember letters 3
1) "f"
2) "a"
3) "d"
127.0.0.1:6379> srandmember letters 300
1) "c"
2) "b"
3) "f"
4) "a"
5) "d"
6) "e"
127.0.0.1:6379> srandmember letters -3
1) "c"
2) "b"
3) "e"
127.0.0.1:6379> srandmember letters -3
1) "b"
2) "b"
3) "e"
127.0.0.1:6379> srandmember letters -10
1) "e"
2) "b"
3) "e"
4) "f"
5) "a"
6) "a"
7) "f"
8) "e"
9) "b"
10) "e"

5.8 从集合中弹出一个元素

# 随机选择一个元素弹出
spop key

127.0.0.1:6379> smembers letters
1) "f"
2) "a"
3) "d"
4) "e"
5) "c"
6) "b"
# 可以随机弹出多个，count代表数量
127.0.0.1:6379> spop letters 2
1) "e"
2) "d"
127.0.0.1:6379> spop letters
"b"
127.0.0.1:6379> smembers letters
1) "f"
2) "a"
3) "c"

6. 有序集合类型

有序集合和无序集合的区别在于有序集合为集合中的每个元素否关联了一个分数。这使得集合可以根据分数进行排序操作，不同元素的分数也是可以一样的，集合可以进行分数相关的操作。

6.1 增加元素
zadd 命令用来向有序集合中加入一个元素和该元素的分数，如果该元素已存在，则用新的分数替换原有的分数，返回值是新加入到集合中的元素个数（不包含之前已经存在的元素）

zadd key score member [score member ...]

127.0.0.1:6379> zadd scoreboard 89 Jack 99 Tom 30 David
(integer) 3
# 修改分数
127.0.0.1:6379> zadd scoreboard 100 Tom
(integer) 0
# 不仅支持整数，还支持双精度浮点数
127.0.0.1:6379> zadd testboard 17E+307 a
(integer) 1
127.0.0.1:6379> zadd testboard 1.8 b
(integer) 1
# 还支持正无穷负无穷
127.0.0.1:6379> zadd testboard +inf c -inf d
(integer) 2

6.2 获得元素的分数

zscore key member
# 获取Tom的分数
127.0.0.1:6379> zscore scoreboard Tom
"100"

6.3 获得排名在某个范围的元素列表

zrange key start stop [withscores]
zrevrange key start stop [withscores]

zrange 命令会按照元素分数从小到大的顺序返回索引从start-stop之间的所有元素（包含两端的元素），索引从0开始，如果索引是负数，则从右边开始，最右边的索引是-1.

127.0.0.1:6379> zrange scoreboard 0 2
1) "David"
2) "Jack"
3) "Tom"
127.0.0.1:6379> zrange scoreboard 0 1
1) "David"
2) "Jack"
127.0.0.1:6379> zrange scoreboard 1 -1
1) "Jack"
2) "Tom"
# 如果获得元素的同时还需要获得分数的话，命令尾部加上withscores
127.0.0.1:6379> zrange scoreboard 0 -1 withscores
1) "David"
2) "30"
3) "Jack"
4) "89"
5) "Tom"
6) "100"

如果两个元素相同，redis会按照字典顺序（0<9<A<Z<a<z）来进行排序的，如果是中文会按照utf-8编码来，zrevrange和zrange的不同是元素从大到小排列的。

6.4 获得指定分数范围的元素

# 该命令按照元素分数从小到大的顺序返回分数在min和max之间（包含）的元素
zrangebyscore key min max [withscores] [limit offset count]

举栗子

127.0.0.1:6379> zrangebyscore scoreboard 80 100
1) "Jack"
2) "Tom"
# 如果不想包含端点值，可以在分数前面+(
127.0.0.1:6379> zrangebyscore scoreboard 80 (100
1) "Jack"
# min和max支持无穷小无穷大
127.0.0.1:6379> zrangebyscore scoreboard 80 +inf
1) "Jack"
2) "Tom"
127.0.0.1:6379> zadd scoreboard 66 Jerry 77 Wendy 88 Yvonne
(integer) 3
127.0.0.1:6379> zrange scoreboard 0 -1 withscores
 1) "David"
 2) "30"
 3) "Jerry"
 4) "66"
 5) "Wendy"
 6) "77"
 7) "Yvonne"
 8) "88"
 9) "Jack"
10) "89"
11) "Tom"
12) "100"
# 可以获取列表的基础上向后偏移offset个元素，并且只获得count个元素
127.0.0.1:6379> zrangebyscore scoreboard 60 +inf withscores limit 1 3
1) "Wendy"
2) "77"
3) "Yvonne"
4) "88"
5) "Jack"
6) "89"
# 该命令和上面相反，元素按分数从大到小排，min和max位置互换
127.0.0.1:6379> zrevrangebyscore scoreboard 100 0 withscores limit 0 3
1) "Tom"
2) "100"
3) "Jack"
4) "89"
5) "Yvonne"
6) "88"

6.5 增加某个元素的分数

# 给某个元素的分数再加分，返回值是更改后的分数
zincrby key increment member

举栗子

# 加5分
127.0.0.1:6379> zincrby scoreboard 5 Jack
"94"
# 减5分
127.0.0.1:6379> zincrby scoreboard -5 Tom
"95"
# 如果元素不存在，则默认给0 再减分
127.0.0.1:6379> zincrby scoreboard -5 Toms
"-5"

6.6 获得集合中元素的数量

zcard key
# 获取集合中元素个数
127.0.0.1:6379> zcard scoreboard
(integer) 7

6.7 获得指定分数范围内的元素个数

zcount key min max

127.0.0.1:6379> zcount scoreboard 90 100
(integer) 2
127.0.0.1:6379> zcount scoreboard (94 +inf
(integer) 1

6.8 删除一个或者多个元素

zrem key member [member ...]

127.0.0.1:6379> zrem scoreboard Wendy
(integer) 1
# 不存在的元素不算个数
127.0.0.1:6379> zrem scoreboard aa
(integer) 0
127.0.0.1:6379> zcard scoreboard
(integer) 6

6.9 按照排名范围删除元素

# 该命令按照元素分数从小到大的顺序删除指定排名范围内的所有元素，并返回删除的元素数量
zremrangebyrank key start stop

举栗子

127.0.0.1:6379> zadd testrem 1 a 2 b 3 c 4 d 5 e 6 f
(integer) 6
127.0.0.1:6379> zremrangebyrank testrem 0 2
(integer) 3
127.0.0.1:6379> zrange testrem 0 -1
1) "d"
2) "e"
3) "f"

6.10 按照分数范围删除元素

# 删除指定分数范围内的所有元素，返回值是删除的元素数量
zremrangebyscore key min max 

127.0.0.1:6379> zremrangebyscore testrem (4 5
(integer) 1
127.0.0.1:6379> zrange testrem 0 -1
1) "d"
2) "f"

6.11 获得元素的排名

# 元素从小到大
zrank key member 
# 元素从大到小
zrevrank key member

127.0.0.1:6379> zrangebyscore scoreboard 0 100 withscores
 1) "David"
 2) "30"
 3) "Jerry"
 4) "66"
 5) "Yvonne"
 6) "88"
 7) "Jack"
 8) "94"
 9) "Tom"
10) "95"
127.0.0.1:6379> zrank scoreboard Jack
(integer) 4
127.0.0.1:6379> zrevrank scoreboard Jack
(integer) 1

6.12 计算有序集合的交集

zinterstore destination numkeys key [key ...] [weights weight [weight ...]] [aggregate sum|min|max]

该命令用来计算多个有序集合的交集并将结果存储在destination有序集合中，返回值为新的集合的元素个数，元素的分数由aggregate参数决定的。
（1）当aggregate是sum时（默认值就是这个），destination集合元素的分数是每个参与计算的集合中该元素分数的和

127.0.0.1:6379> zadd sortedSetsA 1 a 4 b
(integer) 2
127.0.0.1:6379> zadd sortedSetsB 10 a 20 b
(integer) 2
127.0.0.1:6379> zinterstore sumRedult 2 sortedSetsA sortedSetsB
(integer) 2
127.0.0.1:6379> zrange sumRedult 0 -1 withscores
1) "a"
2) "11"
3) "b"
4) "24"

（2）当aggregate是min时，estination集合元素的分数是每个参与计算的集合中该元素分数的最小值

127.0.0.1:6379> zinterstore sortedResult 2 sortedSetsA sortedSetsB aggregate min
(integer) 2
127.0.0.1:6379> zrange sortedResult 0 -1 withscores
1) "a"
2) "1"
3) "b"
4) "4"

（3）当aggregate是max时，estination集合元素的分数是每个参与计算的集合中该元素分数的最大值

127.0.0.1:6379> zinterstore sortedResult 2 sortedSetsA sortedSetsB aggregate max
(integer) 2
127.0.0.1:6379> zrange sortedResult 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"

zinterstore 命令还能够通过weights参数设置每个集合的权重，每个集合在参与计算时元素的分数会被乘上该集合的权重

127.0.0.1:6379> zinterstore sortedResult 2 sortedSetsA sortedSetsB  weights 1 0.1
(integer) 2
127.0.0.1:6379> zrange sortedResult 0 -1 withscores
1) "a"
2) "2"
3) "b"
4) "6"

另外一个命令zunionstore 用法和zinterstore一样，只不过是计算集合之间的并集。