1. Hash

Hash 类似Map数据结构，value由键值对组成

1.1基础操作

** HSET key field value [field value ...] **

设置 key 指定的hash 中的键值对
时间复杂度：O(1)

127.0.0.1:6379> HSET u1 name zs age 24 address Beijing
(integer) 3

** HSETNX key field value **

设置 key 指定的hash 中的键值对，key 不存在才操作
时间复杂度：O(1)

127.0.0.1:6379> HSETNX u1 name li
(integer) 0
127.0.0.1:6379> HSETNX u2 name ls
(integer) 1

** HMSET key field value [field value ...]**

设置 key 指定的hash 中的键值对，可设置多个
时间复杂度：O(N) N 是键值对的个数

127.0.0.1:6379> HMSET u3 name ww age 16 address Shanghai
OK

** HGET key field**

返回key所指 hash 中 field 的值
时间复杂度：O(1)

127.0.0.1:6379> HGET u2 name
"ls"

** HMGET key field [field ...]**

返回key所指 hash 中 field集的值
时间复杂度：O(N) N 是field的个数

127.0.0.1:6379> HMGET u1 name age address
1) "zs"
2) "24"
3) "Beijing"

** HGETALL key **

返回key所指hash中所有的键值对
时间复杂度：O(N) N hash长度

127.0.0.1:6379> HGETALL u3
1) "name"
2) "ww"
3) "age"
4) "16"
5) "address"
6) "Shanghai"

** HDEL key field [field ...]**

删除key所指hash 中 field集的值
时间复杂度：O(N) N 是field的个数

127.0.0.1:6379> HDEL u1 name age
(integer) 2
127.0.0.1:6379> HGETALL u1
1) "address"
2) "Beijing"

HEXISTS key field

判断 key所指hash 中 field 所否存在，存在返回1
时间复杂度：O(1)

127.0.0.1:6379> HGETALL u1
1) "address"
2) "Beijing"
127.0.0.1:6379> HEXISTS u1 name
(integer) 0
127.0.0.1:6379> HEXISTS u1 address
(integer) 1

** HLEN key **

返回key所指hash中包含field的数量
时间复杂度：O(1)

127.0.0.1:6379> HGETALL u1
1) "address"
2) "Beijing"
127.0.0.1:6379> HLEN u1
(integer) 1
127.0.0.1:6379> HLEN u3
(integer) 3

** HSTRLEN key field **

返回key所指hash中field的值的长度
时间复杂度：O(1)

127.0.0.1:6379> HGETALL u1
1) "address"
2) "Beijing"
127.0.0.1:6379> HSTRLEN u1 address
(integer) 7

** HKEYS key **

返回key所指hash中所有field的名称
时间复杂度：O(N) N hash长度

127.0.0.1:6379> HKEYS u3
1) "name"
2) "age"
3) "address"

** HVALS key **

返回key所指hash中所有field的值
时间复杂度：O(N) N hash长度

127.0.0.1:6379> HVALS u3
1) "ww"
2) "16"
3) "Shanghai"

** HSCAN key cursor [MATCH pattern] [COUNT count] **

迭代Hash类型中的键值对
MATCH：每次迭代的field 必须匹配 pattern
COUNT：每次迭代返回的个数
时间复杂度：O(1) 每次迭代 O(N) 完整迭代
** 注：当hash中数据量少时，count 命令不生效 **

127.0.0.1:6379> HSCAN u3 0 match n*
1) "0"
2) 1) "name"
   2) "ww"

1.2 对field 进行数值操作

应用场景：点赞、收藏、详情页

** HINCRBY key field increment key **

所指hash中field 的值加 increment
时间复杂度：O(1)

127.0.0.1:6379> HINCRBY u1 age 10
(integer) 10
127.0.0.1:6379> HGET u1 age
"10"

** HINCRBYFLOAT key field increment key **

所指hash中field 的值加 increment，可加浮点数
时间复杂度：O(1)

127.0.0.1:6379> HINCRBYFLOAT u1 age 9.5
"19.5"
127.0.0.1:6379> HGET u1 age
"19.5"

2. Set

Set 是一个无序链表，元素不可重复

2.1 元素操作

** SADD key member [member ...]**

将指定成员添加到key指定的set 中
时间复杂度：O（N）要添加N个元素.

127.0.0.1:6379> sadd k1 m1 m2 m3 m4
(integer) 4

** SMEMBERS key **

返回key 中的所有元素
时间复杂度： O（N）其中N是设置的基数.

127.0.0.1:6379> SMEMBERS k1
1) "m4"
2) "m2"
3) "m3"
4) "m1"

** SCARD key **

返回set 元素个数
时间复杂度： O(1)

127.0.0.1:6379> SCARD k1
(integer) 4

** SMOVE source destination member **

将 member 从 source 中移除并存入 destination
时间复杂度： O(1)

127.0.0.1:6379> SMOVE k1 k2 m4
(integer) 1
127.0.0.1:6379> SMEMBERS k2
1) "m4"

** SPOP key [count]**

从key的设置值存储中删除并返回一个或多个随机元素.
时间复杂度： O(1)

127.0.0.1:6379> SPOP k1
"m2"
127.0.0.1:6379> SMEMBERS k1
1) "m3"
2) "m1"

SREM key member [member ...]

批量移除key中的元素
时间复杂度： O（N），其中N是要删除的成员数.

127.0.0.1:6379> SREM k1 m1 m2 m3
(integer) 2
127.0.0.1:6379> SCARD k1
(integer) 0

** SISMEMBER key member **

判断 key 中存在member，1 表示存在
时间复杂度： O(1)

127.0.0.1:6379> SMEMBERS k1
(empty array)
127.0.0.1:6379> SMEMBERS k2
1) "m4"
127.0.0.1:6379> SISMEMBER k1 m1
(integer) 0
127.0.0.1:6379> SISMEMBER k2 m4
(integer) 1

** SSCAN key cursor [MATCH pattern] [COUNT count]**

迭代Set类型中的元素
MATCH：每次迭代的元素必须匹配 pattern
COUNT：每次迭代返回的个数
时间复杂度：O(1) 每次迭代 O(N) 完整迭代
注：当Set中数据量少时，count 命令不生效

127.0.0.1:6379> SSCAN k1 0
1) "0"
2) 1) "1"
   2) "2"
   3) "3"
   4) "4"
   5) "5"
   6) "6"
   7) "7"
   8) "8"
127.0.0.1:6379> SSCAN k1 0 count 1
1) "0"
2) 1) "1"
   2) "2"
   3) "3"
   4) "4"
   5) "5"
   6) "6"
   7) "7"
   8) "8"
127.0.0.1:6379> SSCAN k1 0 match 1
1) "0"
2) 1) "1"

2.2 集合操作

** SINTER key [key ...]**

返回所有给定集合的交集
时间复杂度： O（N * M）最坏的情况，其中N是最小集合的基数，M是集合数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SINTER k1 k2
1) "3"
2) "4"

** SINTERSTORE destination key [key ...]**

将所有给定集合的交集存储到destination
时间复杂度： O（N * M）最坏的情况，其中N是最小集合的基数，M是集合数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SINTERSTORE interKey k1 k2
(integer) 2
127.0.0.1:6379> SMEMBERS interKey
1) "3"
2) "4"

** SUNION key [key ...]**

返回所有集合的并集
时间复杂度： O（N），其中N是所有给定集合中元素的总数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SUNION k1 k2
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"

** SUNIONSTORE destination key [key ...]**

将所有集合的并集储到destination
时间复杂度： O（N），其中N是所有给定集合中元素的总数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SUNIONSTORE unionKey k1 k2
(integer) 6
127.0.0.1:6379> SMEMBERS unionKey
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"

** SDIFF key [key ...] **

返回 key 与后续集合的差集
时间复杂度： O（N），其中N是所有给定集合中元素的总数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SDIFF k1 k2
1) "1"
2) "2"
127.0.0.1:6379> SDIFF k2 k1
1) "5"
2) "6"

** SDIFFSTORE destination key [key ...]**

将 key 与后续集合的差集存储到destination
时间复杂度： O（N），其中N是所有给定集合中元素的总数.

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> sadd k2 3 4 5 6
(integer) 4
127.0.0.1:6379> SDIFFSTORE diffK1K2 k1 k2
(integer) 2
127.0.0.1:6379> SMEMBERS diffK1K2
1) "1"
2) "2"

2.3 随机事件

应用：抽奖

SRANDMEMBER key [count]

从key 中取出结果集，count 默认为 1
count 正数：取出一个去重的结果集，不超过已有集
count 负数：取出一个重复的结果集
count = 0：不返回
时间复杂度：没有count参数O（1），否则为O（N），其中N是传递的计数的绝对值.

127.0.0.1:6379> SADD k1 1 2 3 4 5 6 7 8 
(integer) 8
127.0.0.1:6379> SRANDMEMBER k1 0
(empty array)
127.0.0.1:6379> SRANDMEMBER k1 6
1) "2"
2) "4"
3) "7"
4) "1"
5) "6"
6) "5"
127.0.0.1:6379> SRANDMEMBER k1 -6
1) "8"
2) "5"
3) "3"
4) "5"
5) "3"
6) "1"

3. Sorted_Set

有序集合，通过分值排序，默认通过字典序排序

Sorted_set 中排序是由 skip list 实现的

注意：
时间复杂度中 N表示排序集中元素个数 
M 表示查询返回元素个数

3.1 元素操作

** ZADD key [NX|XX] [CH] [INCR] score member [score member ...] **

添加一个或者多个元素+分值到有序集，如果元素已经存在，则修改分值
XX：仅更新已经存在的元素. 切勿添加元素.
NX：不要更新现有元素. 始终添加新元素.
CH：返回新增+修改的总数量
ZADD的返回值仅计算添加的新元素的数量.
INCR ：类似于ZINCRBY，只能指定一对得分元素.
时间复杂度：添加的每一项的O（log（N））

127.0.0.1:6379> ZADD k1 1 m1
(integer) 1
127.0.0.1:6379> ZADD k1 xx ch 2 m1 3 m2
(integer) 1
127.0.0.1:6379> ZADD k1 nx ch 1 m1 2 m2
(integer) 1
127.0.0.1:6379> ZRANGE k1 0 -1 withscores
1) "m1"
2) "2"
3) "m2"
4) "2"

** ZINCRBY key increment member **

添加元素并设置分值，如果元素已存在，增加分值
时间复杂度： O（log（N）），N是排序集中的元素数.

127.0.0.1:6379> ZINCRBY k2 2 m1
"2"
127.0.0.1:6379> ZINCRBY k2 3 m1
"5"

** ZRANGE key start stop [WITHSCORES]**

返回存储在key处的排序集中的元素的指定范围得分从低到高排序
WITHSCORES：将元素的分数与元素一起返回
时间复杂度： O（log（N）+ M）

127.0.0.1:6379> ZRANGE k1 0 -1 withscores
 1) "m1"
 2) "1"
 3) "m3"
 4) "1"
 5) "m6"
 6) "1.5"
 7) "m2"
 8) "2"
 9) "m5"
10) "3"
11) "m4"
12) "9"

** ZREVRANGE key start stop [WITHSCORES] **

返回存储在key处的排序集中的元素的指定范围.得分从高到低排序
时间复杂度： O（log（N）+ M）

127.0.0.1:6379> ZREVRANGE k1 0 -1 withscores
 1) "m4"
 2) "9"
 3) "m5"
 4) "3"
 5) "m2"
 6) "2"
 7) "m6"
 8) "1.5"
 9) "m3"
10) "1"
11) "m1"
12) "1"

** ZRANGEBYLEX key min max [LIMIT offset count]**

返回key处排序集中的所有元素，其值介于min和max之间得分从低到高排序
LIMIT offset count：类似 MySQL 分页查询
时间复杂度： O（log（N）+ M）
*** 有序集合中分数必须相同! 如果有序集合中的成员分数有不一致的,结果就不准。***

127.0.0.1:6379> ZADD k1 0 a 0 aa 0 abc 0 apple 0 b 0 c 0 d 0 d1 0 dd 0 dobble 0 z 0 z1
(integer) 12
127.0.0.1:6379> ZRANGEBYLEX k1 (a [d
1) "aa"
2) "abc"
3) "apple"
4) "b"
5) "c"
6) "d"
127.0.0.1:6379> ZRANGEBYLEX k1 (a [d limit 1 4
1) "abc"
2) "apple"
3) "b"
4) "c"

** ZREVRANGEBYLEX key max min [LIMIT offset count] **

返回key处排序集中的所有元素，其值介于max和min之间. 得分从高到低排序
LIMIT offset count：类似 MySQL 分页查询
时间复杂度： O（log（N）+ M）
*** 分数必须相同! 如果有序集合中的成员分数有不一致的,返回的结果就不准。***

127.0.0.1:6379> ZADD k1 0 a 0 aa 0 abc 0 apple 0 b 0 c 0 d 0 d1 0 dd 0 dobble 0 z 0 z1
(integer) 12
127.0.0.1:6379> ZREVRANGEBYLEX k1 [d [a
1) "d"
2) "c"
3) "b"
4) "apple"
5) "abc"
6) "aa"
7) "a"
127.0.0.1:6379> ZREVRANGEBYLEX k1 [d [a limit 0 3
1) "d"
2) "c"
3) "b"

** ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] **

返回key在min和max之间的排序集中的所有元素（包括得分等于min或max元素）.得分从低到高排序
WITHSCORES：将元素的分数与元素一起返回
LIMIT：用于获取一定范围的匹配元素，负数count返回offset所有元素
时间复杂度： O（log（N）+ M），

127.0.0.1:6379> ZADD k2 1 m1 2 m2 3 m3 4 m4 7 m5 5 m6 10 m7 8 m8 6 m9
(integer) 9
127.0.0.1:6379> ZRANGEBYSCORE k2 (3  5
1) "m4"
2) "m6"
127.0.0.1:6379> ZRANGEBYSCORE k2 3  5 withscores
1) "m3"
2) "3"
3) "m4"
4) "4"
5) "m6"
6) "5"
127.0.0.1:6379> ZRANGEBYSCORE k2 3  5 withscores limit 0 1
1) "m3"
2) "3"

** ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count] **

返回key排序集中的所有元素，其得分在max和min之间得分从高到低排序
时间复杂度： O（log（N）+ M）

127.0.0.1:6379> ZADD k2 1 m1 2 m2 3 m3 4 m4 7 m5 5 m6 10 m7 8 m8 6 m9
(integer) 9
127.0.0.1:6379> ZREVRANGEBYSCORE k2 9 (4
1) "m8"
2) "m5"
3) "m9"
4) "m6"
127.0.0.1:6379> ZREVRANGEBYSCORE k2 9 (4 withscores
1) "m8"
2) "8"
3) "m5"
4) "7"
5) "m9"
6) "6"
7) "m6"
8) "5"
127.0.0.1:6379> ZREVRANGEBYSCORE k2 9 (4 withscores limit 0 1
1) "m8"
2) "8"

** ZRANK key member **

返回存储在key中的排序集中的member的排名，得分从低到高排序，最小值为0
时间复杂度： O(log(N))

127.0.0.1:6379> Zrank k2 m3
(integer) 2
127.0.0.1:6379> ZRANGE k2 0 -1 withscores
 1) "m1"
 2) "1"
 3) "m2"
 4) "2"
 5) "m3"
 6) "3"
 7) "m4"
 8) "4"
 9) "m6"
10) "5"
11) "m9"
12) "6"
13) "m5"
14) "7"
15) "m8"
16) "8"
17) "m7"
18) "10"

** ZREVRANK key member **

返回存储在key中的排序集中的member的排名，得分从高到低排序，最小值为0
时间复杂度： O(log(N))

127.0.0.1:6379> ZREVRANK k2 m6
(integer) 4
127.0.0.1:6379> ZREVRANGE k2 0 -1 withscores
 1) "m7"
 2) "10"
 3) "m8"
 4) "8"
 5) "m5"
 6) "7"
 7) "m9"
 8) "6"
 9) "m6"
10) "5"
11) "m4"
12) "4"
13) "m3"
14) "3"
15) "m2"
16) "2"
17) "m1"
18) "1"

** ZREM key member [member ...]**

从存储在key的排序集中删除指定的成员
时间复杂度： O（M * log（N））

127.0.0.1:6379> ZREM k2 m3 m5 m7
(integer) 3

** ZREMRANGEBYLEX key min max **

删除存储在由min和max指定的字典范围之间的key处的排序集中的所有元素
时间复杂度： O（log（N）+ M）
*** 有序集合中分数必须相同! 如果有序集合中的成员分数有不一致的,结果就不准。***

127.0.0.1:6379> ZREMRANGEBYLEX k1 [b [d
(integer) 3

** ZREMRANGEBYRANK key start stop **

删除存储在key ，其排序在start和stop之间的排序集中的所有元素.
时间复杂度： O（log（N）+ M

127.0.0.1:6379> ZRANGE k2 0 -1 withscores
 1) "m1"
 2) "1"
 3) "m2"
 4) "2"
 5) "m4"
 6) "4"
 7) "m6"
 8) "5"
 9) "m9"
10) "6"
11) "m8"
12) "8"
127.0.0.1:6379> ZREMRANGEBYRANK k2 3 -1
(integer) 3
127.0.0.1:6379> ZRANGE k2 0 -1 withscores
1) "m1"
2) "1"
3) "m2"
4) "2"
5) "m4"
6) "4"

** ZREMRANGEBYSCORE key min max **

删除存储在key中的排序集中的所有元素，其分数介于min和max （含）之间.
时间复杂度： O（log（N）+ M）

127.0.0.1:6379> ZREMRANGEBYSCORE k2 1 2
(integer) 2
127.0.0.1:6379> ZRANGE k2 0 -1 withscores
1) "m4"
2) "4"

** ZPOPMAX key [count] **

移除并弹出 counnt 个最大值
时间复杂度： O（log（N）* M）

127.0.0.1:6379> ZRANGE k1 0 -1
1) "a"
2) "aa"
3) "abc"
127.0.0.1:6379> ZPOPMAX k1
1) "abc"
2) "0"
127.0.0.1:6379> ZPOPMIN k1
1) "a"
2) "0"

** ZPOPMIN key [count] **

移除并弹出 counnt 个最小值
时间复杂度： O（log（N）* M）

127.0.0.1:6379> ZRANGE k1 0 -1
1) "a"
2) "aa"
127.0.0.1:6379> ZPOPMIN k1
1) "a"
2) "0"

** BZPOPMAX key [key ...] timeout **

移除并弹出最大值,无值时阻塞，直到timeout时间后
时间复杂度： O（log（N））
*** 操作与 ZPOPMIN 相似***

** BZPOPMIN key [key ...] timeout **

移除并弹出最小值,无值时阻塞，直到timeout时间后
时间复杂度： O（log（N）），其中N为排序集中元素的数量
*** 操作与 ZPOPMIN 相似 ***

** ZSCAN key cursor [MATCH pattern] [COUNT count] **

迭代sorted_Set类型中的元素
MATCH：每次迭代的元素必须匹配 pattern
COUNT：每次迭代返回的个数
时间复杂度：O(1) 每次迭代 O(N) 完整迭代
*** 注：当sorted_Set中数据量少时，count 命令不生效 ***

** ZSCORE key member**

返回key排序集中的member得分.
时间复杂度： O(1)

127.0.0.1:6379> ZSCORE k2 m4
"4"

** ZLEXCOUNT key min max**

返回key处排序集中的元素个数，其值介于min和max之间
时间复杂度： O（log（N））

127.0.0.1:6379> ZADD k2 1 m1 2 m2 3 m3 4 m4 7 m5 5 m6 10 m7 8 m8 6 m9
(integer) 8
127.0.0.1:6379> ZLEXCOUNT k2 [m3 [m5
(integer) 2

** ZCARD key**

返回有序集元素个数
时间复杂度： O(1)

127.0.0.1:6379> ZRANGE k1 0 -1
1) "aa"
127.0.0.1:6379> ZCARD k1
(integer) 1

** ZCOUNT key min max **

返回key排序集中的元素数，其分数介于min和max之间.
时间复杂度： O（log（N））

127.0.0.1:6379> ZADD k2 1 m1 2 m2 3 m3 4 m4 7 m5 5 m6 10 m7 8 m8 6 m9
(integer) 8
127.0.0.1:6379> ZCOUNT k2 (3  5
(integer) 2
127.0.0.1:6379> ZCOUNT k2 3  5
(integer) 3

3.2 集合操作

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

计算指定键给定的numkeys排序集的交集，并将结果存储在destination
numkeys：键的数量
WEIGHTS：为每个输入排序集指定一个乘数
AGGREGATE：指定如何合并并集的结果
此选项默认为SUM ，其中元素的分数在存在的输入中求和. 当此选项设置为MIN或MAX
时间复杂度：最差情况为O（N * K）+ O（M * log（M））， >>N是最小的输入排序集，K是输入排序集的数量，M是结果排序集的元素数量

127.0.0.1:6379> ZADD k1 10 zs 30 ww 34 ls 66 zq 80 ooxx
(integer) 5
127.0.0.1:6379> ZADD k2 13 zs 25 ww  70 li 99 zk 
(integer) 4
127.0.0.1:6379> ZINTERSTORE interKey 2 k1 k2 weights 2 3 
(integer) 2
127.0.0.1:6379> ZRANGE interKey 0 -1 withscores
1) "zs"
2) "59"
3) "ww"
4) "135"
127.0.0.1:6379> ZINTERSTORE interKey 2 k1 k2 weights 2 3  aggregate min
(integer) 2
127.0.0.1:6379> ZRANGE interKey 0 -1 withscores
1) "zs"
2) "20"
3) "ww"
4) "60"

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

计算指定键给定的numkeys排序集的并集，并将结果存储在destination
numkeys：键的数量
WEIGHTS：为每个输入排序集指定一个乘数
AGGREGATE：指定如何合并并集的结果
此选项默认为SUM ，其中元素的分数在存在的输入中求和. 当此选项设置为MIN或MAX
时间复杂度： O（N）+ O（M log（M））

N是输入已排序集合的大小之和，M是所得已排序集合中元素的数目.

127.0.0.1:6379> ZADD k1 10 zs 30 ww 34 ls 66 zq 80 ooxx
(integer) 5
127.0.0.1:6379> ZADD k2 13 zs 25 ww  70 li 99 zk 
(integer) 4
127.0.0.1:6379> ZUNIONSTORE unionKey 2 k1 k2 weights 5 7 
(integer) 7
127.0.0.1:6379> ZRANGE unionKey 0 -1 withscores
 1) "zs"
 2) "141"
 3) "ls"
 4) "170"
 5) "ww"
 6) "325"
 7) "zq"
 8) "330"
 9) "ooxx"
10) "400"
11) "li"
12) "490"
13) "zk"
14) "693"
127.0.0.1:6379> ZUNIONSTORE unionKey 2 k1 k2 weights 5 7  aggregate min
(integer) 7
127.0.0.1:6379> ZRANGE unionKey 0 -1 withscores
 1) "zs"
 2) "50"
 3) "ww"
 4) "150"
 5) "ls"
 6) "170"
 7) "zq"
 8) "330"
 9) "ooxx"
10) "400"
11) "li"
12) "490"
13) "zk"
14) "693"

Redis 数据结构学习--Hash,Set,Sorted_Set