Redis系列(2)之数据类型

<Redis系列(1)之安装>中介绍了Redis支持以下几种数据类型，那么本节主要介绍学习下这几种数据类型的基本操作

字符串类型，string
散列类型，hash
列表类型，list
集合类型，set
有序集合类型，zset

1. 字符串类型

赋值与取值 SET 与 GET。当键不存在时候返回为空。

1 127.0.0.1:6379> set key hello
2 OK
3 127.0.0.1:6379> get key 
4 "hello"

递增数字INCR。如果键(字符串类型)是整数形式的可以用INCR进行自增，如果键不存在则默认为0，如果键不是整数形式的会报错。这里需要说明的是，Redis的所有操作都是原子操作。

1 127.0.0.1:6379> incr num
2 (integer) 1
3 127.0.0.1:6379> incr num
4 (integer) 2
5 127.0.0.1:6379> get num
6 "2"
7 127.0.0.1:6379> incr key
8 (error) ERR value is not an integer or out of range

增加指定整数INCRBY

1 127.0.0.1:6379> incrby num 2
2 (integer) 4
3 127.0.0.1:6379> incrby num 3
4 (integer) 7
5 127.0.0.1:6379> get num
6 "7"

递减整数DECR

1 127.0.0.1:6379> decr num
2 (integer) 6
3 127.0.0.1:6379> decr num
4 (integer) 5
5 127.0.0.1:6379> get num
6 "5"

减去指定的整数DECRBY

1 127.0.0.1:6379> decrby num 2
2 (integer) 3

增加指定浮点数INCRBYFLOAT

1 127.0.0.1:6379> incrbyfloat num 2.7
2 "5.7"
3 127.0.0.1:6379> incrbyfloat num 5e+4
4 "50005.69999999999999929"

向尾部追加值APPEND。如果键不存在则将键的值设为value，相当于set key value。返回值是追加后的字符串长度，否则就是两个value的链接。

1 127.0.0.1:6379> append str hello
2 (integer) 5
3 127.0.0.1:6379> get str
4 "hello"
5 127.0.0.1:6379> append str ' world'
6 (integer) 11
7 127.0.0.1:6379> get str
8 "hello world"

获取字符串长度STRLEN，这里"你好"是utf-8编码，每一个字长度为3

1 127.0.0.1:6379> strlen str
2 (integer) 11
3 127.0.0.1:6379> set hello 你好
4 OK
5 127.0.0.1:6379> strlen hello
6 (integer) 6

同时获取/设置多个键值MGET/MSET key value key value key value ......

1 127.0.0.1:6379> mset a 1 b 2 c 3 d 4
2 OK
3 127.0.0.1:6379> mget a b c d
4 1) "1"
5 2) "2"
6 3) "3"
7 4) "4"

位操作
- GETBIT key offset ，获取第offset位的值。如果offset大于位长，则默认位值0
- SETBIT key offset value ，设置第offset位的值为value
- BITCOUNT key start end ，计算第start个字节到end个字节的值为1的个数
- BITOP operation destkey key [key ...]

//假设字符串bar的二进制为01100010 01100001 01110010
127.0.0.1:6379> set foo bar   
OK
127.0.0.1:6379> getbit foo 0
(integer) 0
127.0.0.1:6379> getbit foo 1
(integer) 1
127.0.0.1:6379> getbit foo 1000
(integer) 0

如果要设置的位置超过了键值二进制位的长度，setbit命令会自动将中间的二进制位设置为0，同理设置一个不存在的键的指定二进制位的值会自动将其前面的位赋值为0

1 127.0.0.1:6379> setbit foo 6 0
2 (integer) 1
3 127.0.0.1:6379> setbit foo 7 1
4 (integer) 0
5 127.0.0.1:6379> get foo
6 "aar"
7 127.0.0.1

1 127.0.0.1:6379> bitcount foo
2 (integer) 10
3 127.0.0.1:6379> bitcount foo 0 1
4 (integer) 6

BITOP支持AND OR XOR NOT操作。

 1 127.0.0.1:6379> set foo1 bar
 2 OK
 3 127.0.0.1:6379> set foo2 aar
 4 OK
 5 127.0.0.1:6379> bitop or res foo1 foo2
 6 (integer) 3
 7 127.0.0.1:6379> get res
 8 "car"
 9 127.0.0.1:6379> bitop not res1 foo1
10 (integer) 3
11 127.0.0.1:6379> get res1
12 "x9dx9ex8d"
13 127.0.0.1:6379> bitop and res2 foo1 foo2
14 (integer) 3
15 127.0.0.1:6379> get res2
16 "`ar"

2. 散列类型hash

散列类型的结构如下图所示，它的好处就是可以自由的任意的增减字段而不影响其他键。

赋值与取值
- HSET key field value 。 HSET无论是更新还是插入都是有效地，前者返回0，后者返回1，如果键本身不存在，还会自动创建。注意散列类型的操作不能用字符串操作的命令。
- HGET key field
- HMSET key filed value field value ......
- HMGET key field field field ......
- HGETALL key

 1 127.0.0.1:6379> hset car price 100 
 2 (integer) 1
 3 127.0.0.1:6379> hmset car color blue name audi
 4 OK
 5 127.0.0.1:6379> hget car price
 6 "100"
 7 127.0.0.1:6379> hmget car peice color name
 8 1) (nil)
 9 2) "blue"
10 3) "audi"
11 127.0.0.1:6379> hgetall car
12 1) "price"
13 2) "100"
14 3) "color"
15 4) "blue"
16 5) "name"
17 6) "audi"

判断字段是否存在HEXISTS key field .存在返回1，不存在返回0

1 127.0.0.1:6379> hexists car price
2 (integer) 1
3 127.0.0.1:6379> hexists car model
4 (integer) 0

当字段不存在时候赋值，HSETNX key field value

1 127.0.0.1:6379> hsetnx car model 11
2 (integer) 1
3 127.0.0.1:6379> hsetnx car model 22
4 (integer) 0
5 127.0.0.1:6379> hget car model
6 "11"

增加数字，HINCRBY key field increment

1 127.0.0.1:6379> hincrby person score 60
2 (integer) 60
3 127.0.0.1:6379> hincrby person score 15
4 (integer) 75
5 127.0.0.1:6379> get person score
6 (error) ERR wrong number of arguments for 'get' command
7 127.0.0.1:6379> hget person score
8 "75"

删除一个或多个字段，HDEL key field field ...

1 127.0.0.1:6379> hdel car color model
2 (integer) 2
3 127.0.0.1:6379> hgetall car
4 1) "name"
5 2) "audi"

只获取字段的键或者值，HKEYS key ，HVALS key

1 127.0.0.1:6379> hkeys cat
2 1) "name"
3 127.0.0.1:6379> hvals cat
4 1) "audi"

获取字段数量 HLEN key

1 127.0.0.1:6379> hlen cat
2 (integer) 1

3. 列表类型list

列表类型可以存储一个有序的字符串列表，常用的操作就是向列表两端添加元素或者获取列表的其中一个片段。列表的内部其实是一个双向链表数据结构。所以向两边添加数据的复杂度是o(1)，获取的数据越接近两端，速度越快。但是这种结构的代价就是通过索引访问会很慢，需要从头到尾的遍历。列表的这种数据结构一个很好的用处就是微博的新鲜事，始终把最新鲜的事情放到两端。一个列表最多能容纳2³²-1个元素。

左边插入元素 LPUSH key value [ value ... ]
右边插入元素 RPUSH key value [ value ... ]
左边弹出元素 LPOP key ，返回弹出的值，列表内已删除弹出的值
右边弹出元素 RPOP key ，返回弹出的值，列表内已删除弹出的值
可以用以上4个命令来实现列表模拟栈和队列的操作。如果把列表当做栈就可以用RPUSH 和 RPOP或者LPUSH 和LPOP，如果把列表当做队列的话就可以用RPUSH和LPOP或者LPUSH和RPOP
获取列表个数LLEN key
获取列表片段 LRANGE key start stop. 其中支持start和stop为负数，比如stop为-1表示最后一位。
- 如果start的索引比stop的靠后则返回空列表
- 如果stop大于实际的索引范围，则会返回到列表最右边的元素。
- 这里的stop是包含的。
删除列表指定的值， LREM key count value ，删除列表中前count个值为value的元素，返回实际删除的个数。如果count大于0表示从左边开始，如果count小于1则表示从右开始。

 1 127.0.0.1:6379> lpush key 1
 2 (integer) 1
 3 127.0.0.1:6379> lpush key 2 3 4
 4 (integer) 4
 5 127.0.0.1:6379> rpush key 0
 6 (integer) 5
 7 127.0.0.1:6379> rpush key 0 -1 -2
 8 (integer) 8
 9 127.0.0.1:6379> lrange key 0 -1
10 1) "4"
11 2) "3"
12 3) "2"
13 4) "1"
14 5) "0"
15 6) "0"
16 7) "-1"
17 8) "-2"
18 127.0.0.1:6379> llen key
19 (integer) 8
20 127.0.0.1:6379> lpop key 
21 "4"
22 127.0.0.1:6379> rpop key
23 "-2"
24 127.0.0.1:6379> lrange key 0 -1
25 1) "3"
26 2) "2"
27 3) "1"
28 4) "0"
29 5) "0"
30 6) "-1"
31 127.0.0.1:6379> lrange key -2 -1
32 1) "0"
33 2) "-1"
34 127.0.0.1:6379> llen key
35 (integer) 6
36 127.0.0.1:6379> lrem key 1 2
37 (integer) 1
38 127.0.0.1:6379> lrem key -2 0
39 (integer) 2
40 127.0.0.1:6379> lrange key 0 -1
41 1) "3"
42 2) "1"
43 3) "-1"

返回指定元素的索引，LINDEX key index。如果index小于0则从右边开始索引
通过索引进行赋值，LSET key index value。
只保留列表指定片段，LTRIM key start end ，删除除start和end范围(包含end)以外的所有元素(注意索引是从0开始)，LTRIM命令常和LPUSH命令一起来限制列表中的数量。比如记录日志但只希望保留最新的100条。

1 LPUSH log $newlog
2 LTRIM log 0 99

向列表中插入元素，LINSERT key BEFORE|AFTER pivot value . 从左到右查找值为pivot的元素，根据BEFORE还是AFTER来决定将value插入在pibot前面还是后面。
将元素从一个列表转到另一个列表 RPOPLPUSH source destination 。 RPOPLPUSH命名会从source列表右边弹出一个元素，再将其加入到destination列表的左边，并返回这个元素的值，整个过程是原子的。当source和destination相同时候，列表就会进行不停地循环。

 1 127.0.0.1:6379> lpush key 1 2 3 4 5 6
 2 (integer) 6
 3 127.0.0.1:6379> rpush key 0 -1 -2 -3 -4
 4 (integer) 11
 5 127.0.0.1:6379> lrange key 0 -1
 6  1) "6"
 7  2) "5"
 8  3) "4"
 9  4) "3"
10  5) "2"
11  6) "1"
12  7) "0"
13  8) "-1"
14  9) "-2"
15 10) "-3"
16 11) "-4"
17 127.0.0.1:6379> lindex key 1
18 "5"
19 127.0.0.1:6379> lindex key -1
20 "-4"
21 127.0.0.1:6379> lset key 1 -1
22 OK
23 127.0.0.1:6379> lset key -1 1
24 OK
25 127.0.0.1:6379> lrange key 0 -1
26  1) "6"
27  2) "-1"
28  3) "4"
29  4) "3"
30  5) "2"
31  6) "1"
32  7) "0"
33  8) "-1"
34  9) "-2"
35 10) "-3"
36 11) "1"
37 127.0.0.1:6379> ltrim key 4 8
38 OK
39 127.0.0.1:6379> lrange key 0 -1
40 1) "2"
41 2) "1"
42 3) "0"
43 4) "-1"
44 5) "-2"
45 127.0.0.1:6379> linsert key before 0 3
46 (integer) 6
47 127.0.0.1:6379> linsert key after 0 -3
48 (integer) 7
49 127.0.0.1:6379> lrange key 0 -1
50 1) "2"
51 2) "1"
52 3) "3"
53 4) "0"
54 5) "-3"
55 6) "-1"
56 7) "-2"
57 127.0.0.1:6379> lrange key 0 -1
58 1) "-2"
59 2) "2"
60 3) "1"
61 4) "3"
62 5) "0"
63 6) "-3"
64 7) "-1"

4. 集合类型set

在集合中每个元素是不同的且没有顺序的，一个集合类型同样可以最多存放2³²-1个元素。由于集合在redis内部是使用值为空的散列表实现的，所以时间复杂度是0(1)。我们可以使用多个集合类型键之间还可以进行并集，交集，和差集运算。

增加/删除元素
- SADD key member [ member ... ] .返回add成功的个数。如果add的元素在集合中已有则忽略该元素的add。
- SREM key member [ member ... ]
获取集合的所有元素 SMEMBERS letters
判断元素是否在集合中 SISMEMBER key member 。无论数据量多大，该操作计算复杂度为o(1).

 1 127.0.0.1:6379> sadd key a b c d e f
 2 (integer) 6
 3 127.0.0.1:6379> smembers key
 4 1) "b"
 5 2) "a"
 6 3) "e"
 7 4) "f"
 8 5) "c"
 9 6) "d"
10 127.0.0.1:6379> sismember key a
11 (integer) 1
12 127.0.0.1:6379> sismember key ag
13 (integer) 0
14 127.0.0.1:6379> sadd key a
15 (integer) 0
16 127.0.0.1:6379> sadd key g
17 (integer) 1

集合间运算
- SDIFF key [ key ... ] 多个集合的差值运算，表示A-B，代表有属于A的且不属于B的元素构成的集合
- SINTER key [ key ... ] 多个集合求交集，表示A∩B, 代表属于A且属于B的元素构成的集合
- SUNION key [ key ... ] 多个集合求并集，表示AυB, 代表属于A或属于B的元素构成的集合

 1 127.0.0.1:6379> sadd seta 1 2 3
 2 (integer) 3
 3 127.0.0.1:6379> sadd setb 2 3 4
 4 (integer) 3
 5 127.0.0.1:6379> sadd setc 2 3
 6 (integer) 2
 7 127.0.0.1:6379> sdiff seta setb
 8 1) "1"
 9 127.0.0.1:6379> sdiff seta setb setc
10 1) "1"
11 127.0.0.1:6379> sinter seta setb
12 1) "2"
13 2) "3"
14 127.0.0.1:6379> sinter seta setb setc
15 1) "2"
16 2) "3"
17 127.0.0.1:6379> sunion seta setb
18 1) "1"
19 2) "2"
20 3) "3"
21 4) "4"
22 127.0.0.1:6379> sunion seta setb setc
23 1) "1"
24 2) "2"
25 3) "3"
26 4) "4"

获取集合中元素的个数 SCARD key
进行集合运算并将结果存储
- SDIFFSTORE destination key [ key ... ]
- SINTERSTORE destination key [ key ... ]
- SUNIONSTORE destination key [ key ... ]
随机获取集合的元素 SRANDMEMBER key [ count]
- count表示一次随机获取的元素个数。
- 如果count大于0，SRANDMEMBER 会随机获取count个不重复的元素。
- 如果count小于0，SRANDMEMBER 会随机获取count个重复的元素。
- 如果count大于集合的元素个数，则SRANDMEMBER会返回集合中全部元素。
- 需要说明这里的随机并非真正的随机。这是由于集合类型采用的存储结构是散列表，散列函数将元素映射到不同的存储位置(桶)上以实现复杂度为o(1)的查找，当两个不同的元素的的散列值相同时会出现冲突，Redis采用拉链表法解决冲突，即将散列值冲突的元素以链表形式放在同一个桶中，查找时候先查桶，再从桶的链表中找到对应的元素。Redis在随机获取元素时候，先随机选择桶，再从桶从随机选择一个元素，所以元素所在的桶元素越少，选中的几率越高。
从集合中随机弹出一个值 SPOP key

 1 127.0.0.1:6379> sadd seta 1 2 3
 2 (integer) 3
 3 127.0.0.1:6379> sadd setb 2 3 4
 4 (integer) 3
 5 127.0.0.1:6379> sadd setc 2 3
 6 (integer) 2
 7 127.0.0.1:6379> scard seta
 8 (integer) 3
 9 127.0.0.1:6379> scard setb
10 (integer) 3
11 127.0.0.1:6379> scard setc
12 (integer) 2
13 127.0.0.1:6379> sdiffstore setaa seta setb setc
14 (integer) 1
15 127.0.0.1:6379> smembers setaa
16 1) "1"
17 127.0.0.1:6379> sinterstore setbb seta setb setc
18 (integer) 2
19 127.0.0.1:6379> smembers setbb
20 1) "2"
21 2) "3"
22 127.0.0.1:6379> sunionstore setcc seta setb setc
23 (integer) 4
24 127.0.0.1:6379> smembers setc
25 1) "2"
26 2) "3"
27 127.0.0.1:6379> smembers setcc
28 1) "1"
29 2) "2"
30 3) "3"
31 4) "4"
32 127.0.0.1:6379> srandmember setcc 
33 "4"
34 127.0.0.1:6379> srandmember setcc 
35 "3"
36 127.0.0.1:6379> srandmember setcc  2
37 1) "1"
38 2) "2"
39 127.0.0.1:6379> srandmember setcc  2
40 1) "1"
41 2) "3"
42 127.0.0.1:6379> srandmember setcc  -2
43 1) "2"
44 2) "2"
45 127.0.0.1:6379> srandmember setcc  -10
46  1) "3"
47  2) "3"
48  3) "3"
49  4) "4"
50  5) "4"
51  6) "1"
52  7) "4"
53  8) "4"
54  9) "1"
55 10) "3"
56 127.0.0.1:6379> spop setcc
57 "2"
58 127.0.0.1:6379> smembers setcc
59 1) "1"
60 2) "3"
61 3) "4"

5. 有序集合类型sorted set

最后介绍Redis里面最高级的数据类型有序集合sorted set。有序集合在集合的基础上为每个元素关联了一个分数，这使得我们不仅可以完成插入，删除和判断元素是否存在等集合操作，还能够获取分数最高或者最低的前N个元素，获取指定分数范围内的元素等跟分数有关的相关操作。虽然集合中的元素是不同的，但是分数可以相同。

有序集合类型在某些方面跟列表相似：

两者都有序。
两者都可以获取一定范围内的元素。

但是两者还是有很大的区别的：

列表是采用双向链表的结构，获取靠近两端的数据速度非常快，当数据量多的时候访问中间的数据的速度会比较慢，它比较适合“新鲜事”“日志”这样很少访问中间数据的应用。
有序集合类型是使用散列表和跳跃表实现的，所以即使读取中间的数据也比较快，时间复杂度为O(logN)。
列表中不能简单的调整某个元素的位置，但是有序集合可以通过更改这个元素的分数来实现。
有序集合要比列表更耗内存。

增加元素 ZADD key score member [ member ... ]. ZADD向有序集合中添加一个元素和该元素的分数，如果该元素存在则用新的分数代替旧的分数。分数不但支持整数，还支持浮点数(-inf表示负无穷，+inf正无穷)。
获取元素的分数 ZSCORE key member
获取排名在某个范围的元素列表
- ZRANGE key start stop [ WITHSCORES ] 按照元素分数从小到大顺序返回start和stop之间的所有元素(包括两端)，支持start和stop为负数。如果在命令后面追加WITHSCORES则会连带分数一起输出。ZRANGE的时间复杂度为O(logn+m),其中n为有序集合的基数，m为返回的个数。如果分数相同则会根据元素的字典序。
- ZREVRANGE key start stop [ WITHSCORES ] 按照元素分数从大到小顺序返回start和stop之间的所有元素(包括两端)，其他同ZRANGE

 1 127.0.0.1:6379> zadd scoreboard 89 tom 67 peter 100 david
 2 (integer) 3
 3 127.0.0.1:6379> zrange scoreboard 0 -1
 4 1) "peter"
 5 2) "tom"
 6 3) "david"
 7 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
 8 1) "peter"
 9 2) "67"
10 3) "tom"
11 4) "89"
12 5) "david"
13 6) "100"
14 127.0.0.1:6379> zadd scoreboard 76 peter
15 (integer) 0
16 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
17 1) "peter"
18 2) "76"
19 3) "tom"
20 4) "89"
21 5) "david"
22 6) "100"
23 127.0.0.1:6379> zrevrange scoreboard 0 -1 withscores
24 1) "david"
25 2) "100"
26 3) "tom"
27 4) "89"
28 5) "peter"
29 6) "76"
30 127.0.0.1:6379> zscore scoreboard peter
31 "76"
32 127.0.0.1:6379> zadd scoreboard 76.00 peter
33 (integer) 0
34 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
35 1) "peter"
36 2) "76"
37 3) "tom"
38 4) "89"
39 5) "david"
40 6) "100"
41 127.0.0.1:6379> zadd scoreboard 76.01 peter
42 (integer) 0
43 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
44 1) "peter"
45 2) "76.010000000000005"
46 3) "tom"
47 4) "89"
48 5) "david"
49 6) "100"
50 127.0.0.1:6379> zadd scoreboard -inf peter
51 (integer) 0
52 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
53 1) "peter"
54 2) "-inf"
55 3) "tom"
56 4) "89"
57 5) "david"
58 6) "100"

获取指定分数范围的元素
- ZRANGESCOREBYSCORE key min max [ WITHSCORES] [ LIMIT offset count] 按照元素分数从小到大顺序返回分数在minx和max之间的元素。
  - 如果不希望包含两个端点可以在分数之前加( 。
  - 分数支持无限大和无限小，分别用+inf 和 -inf。
  - [ LIMIT offset count] 在返回的结果中偏移offset 并只返回count个数。
- ZREVRANGESCOREBYSCORE key max min [ WITHSCORES] [ LIMIT offset count] .用法与ZRANGESCOREBYSCORE类似，只是从大到小，注意max和min的位置已经发生互换。

 1 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
 2  1) "jerry"
 3  2) "56"
 4  3) "yvonne"
 5  4) "67"
 6  5) "peter"
 7  6) "76"
 8  7) "tom"
 9  8) "89"
10  9) "wendy"
11 10) "92"
12 11) "david"
13 12) "100"
14 127.0.0.1:6379> zrangebyscore scoreboard 56 92 
15 1) "jerry"
16 2) "yvonne"
17 3) "peter"
18 4) "tom"
19 5) "wendy"
20 127.0.0.1:6379> zrangebyscore scoreboard (56 92 
21 1) "yvonne"
22 2) "peter"
23 3) "tom"
24 4) "wendy"
25 127.0.0.1:6379> zrangebyscore scoreboard 56 (92 
26 1) "jerry"
27 2) "yvonne"
28 3) "peter"
29 4) "tom"
30 127.0.0.1:6379> zrangebyscore scoreboard 56 +inf
31 1) "jerry"
32 2) "yvonne"
33 3) "peter"
34 4) "tom"
35 5) "wendy"
36 6) "david"
37 127.0.0.1:6379> zrangebyscore scoreboard -inf 56
38 1) "jerry"
39 127.0.0.1:6379> zrangebyscore scoreboard -inf 67 withscores
40 1) "jerry"
41 2) "56"
42 3) "yvonne"
43 4) "67"
44 127.0.0.1:6379> zrangebyscore scoreboard (60 +inf limit 1 3
45 1) "peter"
46 2) "tom"
47 3) "wendy"
48 127.0.0.1:6379> zrangebyscore scoreboard (60 +inf limit 1 2
49 1) "peter"
50 2) "tom"
51 127.0.0.1:6379> zrangebyscore scoreboard (60 +inf limit 2 2
52 1) "tom"
53 2) "wendy"
54 127.0.0.1:6379> zrangebyscore scoreboard (60 +inf limit 0 2
55 1) "yvonne"
56 2) "peter"
57 127.0.0.1:6379> zrevrangebyscore scoreboard 100 60 withscores
58  1) "david"
59  2) "100"
60  3) "wendy"
61  4) "92"
62  5) "tom"
63  6) "89"
64  7) "peter"
65  8) "76"
66  9) "yvonne"
67 10) "67"
68 127.0.0.1:6379> zrevrangebyscore scoreboard 100 60 limit 2 2
69 1) "tom"
70 2) "peter"

增加某个元素的分数 ZINCRBY key increment member。可以增加(increment为正)减小(increment为负)一个元素的分数，并返回修改后的元素的分数。

 1 127.0.0.1:6379> zscore scoreboard peter
 2 "76"
 3 127.0.0.1:6379> zincrby scoreboard 4 peter
 4 "80"
 5 127.0.0.1:6379> zscore scoreboard peter
 6 "80"
 7 127.0.0.1:6379> zincrby scoreboard -10 peter
 8 "70"
 9 127.0.0.1:6379> zscore scoreboard peter
10 "70"

获取有序集合中元素的数量 ZCARD key
获取指定范围内的元素个数 ZCOUNT key min max ，其中min与max的特性与ZRANGEBYSCORE中的一样。
删除一个或多个元素 ZREM key member [ member member]
按照排名范围删除元素 ZREMRANGEBYRANK key start stop。这里是按照元素从小到大的排名，即索引值。
按照分数范围删除元素 ZREMEANGEBYSCORE key min max。这里是按照元素从小到大的分数。
返回元素的排名
- ZRANK key member 从小到大顺序排序的排名
- ZREVRANK key member 从大到小顺序排序的排名

 1 127.0.0.1:6379> zcard scoreboard
 2 (integer) 6
 3 127.0.0.1:6379> zcount scoreboard -inf +inf
 4 (integer) 6
 5 127.0.0.1:6379> zcount scoreboard 60 +inf
 6 (integer) 5
 7 127.0.0.1:6379> zrange scoreboard 0 -1 withscores
 8  1) "jerry"
 9  2) "56"
10  3) "yvonne"
11  4) "67"
12  5) "peter"
13  6) "70"
14  7) "tom"
15  8) "89"
16  9) "wendy"
17 10) "92"
18 11) "david"
19 12) "100"
20 127.0.0.1:6379> zrangebyscore scoreboard -inf +inf withscores
21  1) "jerry"
22  2) "56"
23  3) "yvonne"
24  4) "67"
25  5) "peter"
26  6) "70"
27  7) "tom"
28  8) "89"
29  9) "wendy"
30 10) "92"
31 11) "david"
32 12) "100"
33 127.0.0.1:6379> zrem scoreboard jerry yvonne
34 (integer) 2
35 127.0.0.1:6379> zrangebyscore scoreboard -inf +inf withscores
36 1) "peter"
37 2) "70"
38 3) "tom"
39 4) "89"
40 5) "wendy"
41 6) "92"
42 7) "david"
43 8) "100"
44 127.0.0.1:6379> zcard scoreboard
45 (integer) 4
46 127.0.0.1:6379> zrank scoreboard peter
47 (integer) 0
48 127.0.0.1:6379> zrevrank scoreboard peter
49 (integer) 3
50 127.0.0.1:6379> zremrangebyrank scoreboard 0 1
51 (integer) 2
52 127.0.0.1:6379> zrangebyscore scoreboard -inf +inf withscores
53 1) "wendy"
54 2) "92"
55 3) "david"
56 4) "100"
57 127.0.0.1:6379> zremrangebyscore scoreboard 0 92
58 (integer) 1
59 127.0.0.1:6379> zrangebyscore scoreboard -inf +inf withscores
60 1) "david"
61 2) "100"

有序集合的交集与并集
- ZINTERSTORE destination numkeys key [ key ... ] [ WEIGHTS weight [weight ...]] [ AGGREGATE SUM|MIN|MAX] 用来计算多个有序集合的交集并将结果存放在destination键中(同样以有序集合存储)，返回值为destination的个数。destination的分数是有AGGREGATE参数决定的
- ZUNIONSTORE destination numkeys key [ key ... ] [ WEIGHTS weight [weight ...]] [ AGGREGATE SUM|MIN|MAX]用来计算多个有序集合的并集并将结果存放在destination键中(同样以有序集合存储)，返回值为destination的个数。destination的分数是有AGGREGATE参数决定的
  - 如果当AGGREGATE是sum时候(默认情况)，destination的元素的分数是每个参与计算的集合中该元素的和。
  - 如果当AGGREGATE是min时候，destination的元素的分数是每个参与计算的元素的分数最小值。
  - 如果当AGGREGATE是max时候，destination的元素的分数是每个参与计算的元素的分数最大值。
  - 还可以通过WEIGHTS参数设置每个集合的权重，每个集合在参与计算时候元素的分数都会乘上该集合的权重。

127.0.0.1:6379> zadd sortedset1 1 a 2 b
(integer) 2
127.0.0.1:6379> zadd sortedset2 10 a 20 b
(integer) 2
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "11"
3) "b"
4) "22"
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2 aggregate min
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "1"
3) "b"
4) "2"
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2 aggregate max
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2 aggregate max weights 1 0.1
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "1"
3) "b"
4) "2"
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2 aggregate max weights 2 0.5
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "5"
3) "b"
4) "10"
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset2 aggregate sum weights 2 0.5
(integer) 2
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "7"
3) "b"
4) "14"
127.0.0.1:6379> zadd sortedset 11 a 12 c
(integer) 2
127.0.0.1:6379> zinterstore sortedsetsresult 2 sortedset1 sortedset aggregate sum weights 2 1
(integer) 1
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "a"
2) "13"
127.0.0.1:6379> zunionstore sortedsetsresult 2 sortedset1 sortedset aggregate su(integer) 3 1
127.0.0.1:6379> zrange sortedsetsresult 0 -1 withscores
1) "b"
2) "4"
3) "c"
4) "12"
5) "a"
6) "13"
127.0.0.1:6379> zrevrange sortedsetsresult 0 -1 withscores
1) "a"
2) "13"
3) "c"
4) "12"
5) "b"
6) "4"

总结：

本节主要介绍了Redis的5中数据类型，并给出具体的例子。通过学习发现，Redis的数据类型非常丰富，其中有序集合sortedset是比较高级灵活实用的数据类型，当然它需要更多的内存空间。