Redis 数据结构

简介

Redis存储的是键值对key-value数据，key都是字符串类型，value有如下几种数据结构：

• string字符串（strings），
• list 列表
• hash 散列
• set 集合
• sorted set 有序集合
• bitmaps 位图
• hyperloglogs 基数统计
• geospatial 地理空间

1. Redis key

Redis key 值是二进制安全的，这意味着可以用任何二进制序列作为key值，从形如“foo”的简单字符串到一个JPEG文件的内容都可以。空字符串也是有效key值

Key取值原则

1. 键值不需要太长，消耗内存，且在数据中查找这类键值的计算成本较高
2. 键值不宜过短，可读性较差

给key设置过期时间
EXPIRE key seconds：秒值
PEXPIRE key milliseconds：毫秒值
EXPIREAT key timestamp：设置在指定Unix时间戳过期，秒
PEXPIREAT key milliseconds-timestamp：毫秒值

PERSIST key：删除过期

TTL key
查看剩余生存时间，秒值
PTTL key
查看毫秒值
key存在但没有设置TTL，返回-1
key存在，但还在生存期内，返回剩余的秒或者毫秒
key曾经存在，但已经消亡，返回-2（2.8版本之前返回-1）

KEYS pattern：查找键
pattern取值：* 任意长度字符；? 任意一个字符；[] 字符集合，表示可以是集合中的任意一个
keys ?e*；keys ?e??；keys key[ab]

EXISTS key
键是否存在

RENAME key newkey
键重命名，有可能覆盖值
RENAMENX key newkey
新的名字不存在的时候再重命名

DEL key [key ...]
删除键

unlink key [key ...]

unlink和删除del命令很像，也是存在key删除，不存在则忽略；删除几个键值，则返回删除的个数
del和unlink区别:

del：它是线程阻塞的，当执行del命令是，del在没执行完时，其它后续的命令是无法进入的（要安全就使用del）
unlink:它不是线程阻塞的，当执行unlink命令时，它会将要删除的键移交给另外线程，然后将当前要删除的键与数据库空间断开连接, 后续则由其它线程异步删除这些键（要效率快就使用unlink）

randomkey
随机返回一个key名称

object encoding key
获取value底层存储的数据结构类型

TYPE key
获取键类型

flushdb
删除当前数据库的所有数据
flushall
删除所有数据库的所有数据

copy source destination [db destination-db] [replace]
拷贝当前某一个key的值，存放到新的key中（可以跨库拷贝）返回 1 成功 0 失败
例子：

copy name1 name2  -- 把 name1 的值 拷贝到 name2 里
copy name1 name2 db 5 -- 把 name1 的值拷贝到第6号数据库name2里
copy name1 name2 replace -- 把 name1 的值拷贝到name2里，存在则强行覆盖

move key db
把指定的键值移动到选定的数据库db当中。如果key在目标数据库中已存在，或者key在源数据库中不存，则key不会被移动。
例子：

move name 2 --把name移动到数据库2

touch key [key ...]
修改指定key的最后访问时间。忽略不存在的 key。（我的理解是这个键被设置/更新成功，并且被放到数据库则是成功，会返回1）
例子：

-- 返回被设置成功的键个数
touch name1 name2 name3

scan cursor [match pattern] [count count]
用于迭代当前数据库中的数据库键

cursor：游标（告诉迭代器从哪开始迭代）
[match pattern]：过滤筛选条件
[count count]：迭代的个数

需要注意的是count的使用:
COUNT 参数的默认值为 10 。
在迭代一个足够大的、由哈希表实现的数据库、集合键、哈希键或者有序集合键时， 如果用户没有使用 MATCH 选项， 那么命令返回的元素数量通常和 COUNT 选项指定的一样， 或者比 COUNT 选项指定的数量稍多一些。
在迭代一个编码为整数集合（intset，一个只由整数值构成的小集合）、 或者编码为压缩列表（ziplist，由不同值构成的一个小哈希或者一个小有序集合）时， 增量式迭代命令通常会无视 COUNT 选项指定的值， 在第一次迭代就将数据集包含的所有元素都返回给用户。
例子：

127.0.0.1:6379> keys *
1) "name8"
2) "name3"
3) "name5"
4) "name1"
5) "name2"
6) "name9"
7) "name7"
8) "name4"
9) "name6"
127.0.0.1:6379> scan 0 match name* count 2
-- 迭代开始，从游标0开始（开头），筛选带 name* 并且查2个
-- 执行后，会返回两个键，并且还返回游标现在指向的位置 2 ，那我们下次迭代就可以从 2 开始继续
1) "2"
2) 1) "name8"
   2) "name7"
127.0.0.1:6379> scan 2 match name* count 2
 -- 设置游标从 2 开始 并查询 2 个键
1) "5"
2) 1) "name3"
   2) "name2"
   3) "name9"

migrate host port key|"" destination-db timeout [copy] [replace] [auth password] [auth2 username password] [keys key [key ...]]
将key原子性的从当前实例库传送到目标实例的指定数据库上，一旦迁移成功，key会在目标实例上，而当前实例上的key会被删除（默认删除）

host：设置迁移的IP地址
port：设置迁移的端口号
key|“”：如果要迁移单个key则可以在这设置key，如果是多个key则在这里只需要设置 “” 在后面设置更多的key
destination-db：迁移到目标Redis服务器的哪个实例数据库
timeout：超时时间
[copy]：设置此属性代表复制迁移，不删除源实例中的key。
[replace]：强行替换，如果目标数据库存在则更新值，不存在则添加；如果不设置replace则代表对方数据库存在迁移的key则不成功
[auth password]：请求对方数据库的密码
[auth2 username password]：请求对方数据库的用户名和密码
[keys key [key …]]：如果前面没设置 key为""，则在后面可以设置多个key迁移，如keys aaa bbb ccc

例子：

set name zhangsan
-- 设置一个普通的键值
migrate 127.0.0.1 6380 name 1 2000
-- 把name键值迁移到指定IP和端口的Redis服务器上，并且放在2号实例数据库上，超时时间2秒（超时关闭）
migrate 127.0.0.1 6380 name 0 2000 copy
-- 和上面一个命令一样，但是不同的是上一个命令成功则删除原始键值，而当前命令加上copy则只是复制到对方数据库
migrate 127.0.0.1 6380 name 0 2000 copy replace
-- 加上replace则代表目地数据库存在此键则会强行更新，不存在则添加
migrate 127.0.0.1 6380 name 0 2000 copy replace auth 1234
-- 加上密码验证
migrate 127.0.0.1 6380 "" 0 2000 copy replace auth 1234 name age address
-- 一次性迁移多个keys

sort key [by pattern] [limit offset count] [get pattern [get pattern ...]] [asc|desc] [alpha] [store destination]
sort是用来对list,set或sorted中元素排序；默认是按照数值排序的；并且按照两个元素的双精度浮点数类型值进行比较

key：排序的key
[by pattern]：通过引用外部key来排序
[limit offset count]：分页，limit 2,3 从0开始偏移到第2条数据，并查询3条数据
[get pattern [get pattern …]]：获取外部key的值
[asc|desc]：排序的规则
[alpha]：当排序的集合中存在字符串则需要使用此属性，按照字典顺序排序；因为默认按照两个元素的双精度浮点数类型值进行比较
[store destination]：把处理好的结果存放到指定的key容器中

例子：

-- 创建两个集合：（后面会说list集合命令）
lpush listNumber 8.4 13 14 10.5 4 19.6 10 14 5.2 10 3 2.5 7 4.7 10 11.2 8 2.2 15.7 20.9
lpush listString  remini Momen Pledg Memo Tende Biode Revie silen Romanti AusL Simpl Promis Romanti Bautifu smil Initiall sunse lemo firs Chaffere
-- 查看添加的命令：
lrange listNumber 0 -1
lrange listString 0 -1

-- 基本使用：
sort listNumber         -- 默认排序是按照双精度浮点数类型从小到大升序
sort listNumber desc    -- 按照从降序排列
sort listString alpha   -- 如果排序中包含字符串类型则必须使用 alpha 修饰；则会使用字节排序
sort listString limit 2 5 alpha     -- 排序并分页，分页从0开始数到2，再从2的位置往后数5个元素
sort listString  alpha limit 2 5 store newliststring    -- 排序分页，并把排序好的数据存放到另外一个集合中

-- by属性的使用（通过外部key排序）：
lpush mylist 20 15 18
set n_20 b
set n_15 a
set n_18 c
sort mylist by n_* alpha
1) "15"
3) "20"
5) "18"
-- 如果使用了by属性，那么sort就会先取出mylist的全部值，也就是20，15，18，
-- 然后再去跟by里设置的pattern进行组合（n_*，里面的*必须要和mylist的值有个一一对应关系，要不无法组合）；
-- 所以就变为了n_20,n_15,n_18 ,再按照这些拼装出的键里面的值进行排序（默认升序，从小到大）；
-- 这些键排完序规则为
-- n_15 a
-- n_20 b
-- n_18 c
-- 对应好之后，程序就会按照键后面的权重值来排序，所以最终排序a,b,c起作用，那么反过来推算
-- n_15代表mylist的15，n_20代表mylist的20，n_18代表mylist的18，
-- 所以15对应排序的权重a；20对应排序的权重b；18对应排序的权重c；

-- 练习：现在有zhangsan（salary=5200），lisi（salary=3000），wangwu（salary=4500），
-- mazi（salary=3200）四人，但是他们想比较谁的工资高，该如何设计排序
lpush names zhangsan lisi wangwu mazi
set name_zhangsan 5200
set name_lisi 3000
set name_wangwu 4500
set name_mazi 3200
sort names by name_* desc

-- get是使用则是先加载出mylist，并且再拼装到n_*（一一对应）然后会直接输出那个键的权重（根据mylist里面排序）
-- get属性使用（获取外部key）：
lpush mylist 20 15 18
set n_20 b
set n_15 a
set n_18 c

-- 1：获取外部key
127.0.0.1:6379> sort mylist get n_*
1) "a"
2) "c"
3) "b"

-- 2：获取外部key并获取当前结合的集合值
127.0.0.1:6379> sort mylist get n_* get #
1) "a"
2) "15"
3) "c"
4) "18"
5) "b"
6) "20"

-- 3：如果有多个get也是可以的，会依次匹对返回
127.0.0.1:6379> sort mylist get n_* get # get nn_* get #

2. string

一种最基本的Redis值类型（字节数组）。

Redis字符串是二进制安全的，一个Redis字符串能包含任意类型的数据。

例如： 一张JPEG格式的图片或者一个序列化的Ruby对象。

一个字符串类型的值最多能存储512M字节的内容

SET key value [EX seconds] [PX milliseconds] [NX|XX]
设置字符串值：

• EX：设置过期时间，秒；等同于SETEX key seconds value
  set hello world ex 10
• PX：设置过期时间，毫秒；等同于PSETEX key milliseconds value
  set hello world px 5000
• NX：键不存在，才能设置，等同于SETNX key value
  set hello bjsxt nx
• XX：键存在时，才能设置
  set hello sxt xx

setex key seconds value
将键key的值设置为value ，并将键key的过期时间设置为seconds秒钟，如果key存在则覆盖原有值
例子：

setex name 60 xiexie -- 设置key为name，并且设置60秒过期时间

psetex key milliseconds value
将键key的值设置为value ，并将键key的过期时间设置为milliseconds毫秒，如果key存在则覆盖原有值
例子：

psetex name 70000 xiexie -- 设置key为name，并且设置70秒过期时间

MSET key value [key value ...]
设置多个键的字符串值
mset keya valuea keyb valueb keyc valuec keyd valud

MSETNX key value [key value ...]
键不存在时，设置字符串值
msetnx a valua b valueb c valuec

注意Redis一条命令是一个原子操作，对多个kv，要不成功都不成功

GET key
获取键的值

MGET key [key ...]
获取多个给定的键的值

getdel key
先获取到指定的key后，再删除获取的那个key；最终返回被删除的值

GETSET key value
返回旧值并设置新值；如果键不存在，就创建并赋值

getex key [ex seconds|px milliseconds|exat timestamp|pxat milliseconds-timestamp|persist]
获取指定的key值，并且获取后可以对当前key设置超时时间或者清除超时时间
参数 说明

• ex seconds 设置键key的过期时间，单位时秒
• px milliseconds 设置键key的过期时间，单位时毫秒
• exat timestamp 设置键过期的指定Unix时间，以秒为单位
• pxat milliseconds-timestamp 设置键过期的指定Unix时间，以毫秒为单位
• persist 清除超时时间

STRLEN key
获取键的值的字符串长度

APPEND key value
追加字符串；如果键存在就追加；如果不存在就等同于SET key value

GETRANGE key start end
获取子字符串；
索引值从0开始，负数表示从字符串右边向左数起， -1表示最右一个字符，负号减轻复杂度

SETRANGE key offset value
覆盖字符串

步长1的增减
INCR key：value值+1
DECR key：value值-1

string类型的，底层实现是int，实际上操作的还是数字。
字符串值会被解释成64位有符号的十进制整数来操作，结果依然转成字符串

INCRBY key decrement：自定义步长
DECRBY key decrement
incrbyfloat key decrement ：操作浮点数，可以是负数

3. list

• 基于Linked List实现，双向无环链表
• 元素是字符串类型
• 列表头尾增删快，中间增删慢，增删元素是常态
• 元素可以重复出现
• 最多包含2^32-1元素

列表可以实现堆栈、队列、阻塞队列等。

列表的索引

• 从左至右，从0开始
• 从右至左，从-1开始

LPUSH key value [value ...]
从左边（或头部）添加元素
LPUSHX key value
要求key必须存在

RPUSH key value [value ...]
从右边（或尾部）添加元素
RPUSHX key value
要求key必须存在

LPOP key
从左边（头部）弹出元素
RPOP key
从右边（尾部）弹出元素

RPOPLPUSH source destination
从一个列表尾部弹出元素压入到另一个列表的头部

LRANGE key start stop
返回列表中指定范围元素
LRANGE key 0 -1
返回所有元素

LINDEX key index
获取指定位置的元素

LSET key index value
设置指定位置元素的值

LLEN key
获取列表长度，元素个数

LREM key count value
移除元素

• count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count
• count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值
• count = 0 : 移除表中所有与 value 相等的值

LTRIM key start stop
去除指定范围 外 的元素

LINSERT key BEFORE|AFTER val value
在列表中某个存在的值（pivot）前或后插入元素

BLPOP key [key ...] timeout
从左边或者头部阻塞弹出元素

BRPOP key [key ...] timeout
从右边或者尾部阻塞弹出元素

如果弹出的列表不存在或者为空，就会阻塞；
超时时间设置为0，就是永久阻塞，直到有数据可以弹出；
如果多个客户端阻塞在同一个列表上，使用First In First Service原则，先到先服务。

BRPOPLPUSH source destination timeout
从一个列表尾部阻塞弹出元素压入到另一个列表的头部

lmove source destination left|right left|right
用于原子地从source集合左边或者右边弹出一个元素，添加到destination新集合里的左边或右边

source：源集合
destination：目标集合
left|right left|right：
第一个：代表从源集合的左边或者右边弹出元素
第二个：代表从目标集合的左边或者右边添加

例子：

lmove listString mylist left right   -- 从listString源集合的左边弹出个元素，添加到mylist目标集合的右边

blmove source destination left|right left|right timeout
用于原子地从source集合左边或者右边弹出一个元素，添加到destination新集合里的左边或右边，但是它时lmove的阻塞版本
例子：

blmove listString mylist left right 60 
-- 从集合listString左边弹出一个元素放到目标集合mylist的尾部, 存在60秒的超时时间，超过60秒没有弹出元素则自动失败，返回(nil)

lpos key element [rank rank] [count num-matches] [maxlen len]
返回集合key中匹配给定element成员的索引

key：要查询的集合key
element：要查询索引的元素
[rank rank]：选择匹配上的第几个元素，若超出集合指定元素的个数则返回(nil)
[count num-matches]：返回匹配上元素的索引个数，默认返回1个
[maxlen len]：告知lpos命令查询集合的前len个元素，限制查询个数

lpos listString Romanti     -- 查询集合listString里的Romanti出现的索引位置（0开始索引）
    lpos listString Romanti rank 2  -- 查询Romanti元素的第二个索引位置
    lpos listString Romanti rank 1 count 3  -- 查询Romanti索引的三条记录
    lpos listString Romanti rank 1 count 3 maxlen 20    -- 限制查询下标为0~20
    1) (integer) 7
    2) (integer) 11

4. hash

• 由field和关联的value组成的map键值对
• field和value是字符串类型
• 一个hash中最多包含2^32-1键值对

HSET key field value
设置单个字段
HSETNX key field value
key的filed不存在的情况下执行，key不存在直接创建

HMSET key field value [field value ...]
设置多个字段

HLEN key
返回字段个数

hstrlen key field
返回存储在key中给定field相关联的值的字符串长度（string length）

HEXISTS key field
判断字段是否存在； key或者field不存在，返回0

HGET key field
返回字段值
HMGET key field [field ...]
返回多个字段值
HGETALL key
返回所有的键值对

HKEYS key
返回所有字段名
HVALS key
返回所有值

HINCRBY key field increment
在字段对应的值上进行整数的增量计算
HINCRBYFLOAT key field increment
在字段对应的值上进行浮点数的增量计算

HDEL key field [field ...]
删除指定的字段

hscan key cursor [match pattern] [count count]
用于遍历哈希表中的键值对 cursor：游标（告诉迭代器从哪开始迭代） [match pattern]：过滤筛选条件 [count count]：迭代的个数
需要注意的是count的使用:

• COUNT 参数的默认值为 10 。
• 在迭代一个足够大的、由哈希表实现的数据库、集合键、哈希键或者有序集合键时， 如果用户没有使用 MATCH 选项， 那么命令返回的元素数量通常和 COUNT 选项指定的一样， 或者比 COUNT 选项指定的数量稍多一些。
• 在迭代一个编码为整数集合（intset，一个只由整数值构成的小集合）、 或者编码为压缩列表（ziplist，由不同值构成的一个小哈希或者一个小有序集合）时， 增量式迭代命令通常会无视 COUNT 选项指定的值， 在第一次迭代就将数据集包含的所有元素都返回给用户。
  hscan student 0 match * count 2 – 迭代student里的field字段，下标0开始，过滤条件*全部，但是因为其编码为压缩列表, 所以countr 2不起作用

hash的优点：

• 节约内存空间
• 每创建一个键，它都会为这个键储存一些附加的管理信息（比如这个键的类型，这个键最后一次被访问的时间等等）
• 所以数据库里面的键越多，redis数据库服务器在储存附加管理信息方面耗费的内存就越多，花在管理数据库键上的CPU也会越多在字段对应的值上进行浮点数的增量计算

不适合hash的情况

• 使用二进制位操作命令：
  因为Redis目前支持对字符串键进行SETBIT、GETBIT、BITOP等操作，如果你想使用这些操作，那么只能使用字符串键，虽然散列也能保存二进制数据
• 使用过期键功能：
  Redis的键过期功能目前只能对键进行过期操作，而不能对散列的字段进行过期操作，因此如果你要对键值对数据使用过期功能的话，那么只能把键值对储存在字符串里面

使用案例：

• 微博的好友关注
  用户ID为key，Field为好友ID，Value为关注时间
  user:1000 user:606 20150808 （hlen user:1000得到粉丝数）

• 用户维度统计
  统计数包括：关注数、粉丝数、喜欢商品数、发帖数
  用户为Key，不同维度为Field，Value为统计数

  比如关注了5人
  HSET user:100000 follow 5
HINCRBY user:100000 follow 1

5. set

• 无序的、去重的
• 元素是字符串类型
• 最多包含2^32-1元素

SADD key member [member ...]
增加一个或多个元素；如果元素已经存在，则自动忽略

SREM key member [member ...]
移除一个或者多个元素；元素不存在，自动忽略

SMEMBERS key
返回集合包含的所有元素；
如果集合元素过多，例如百万个，需要遍历，可能会造成服务器阻塞，生产环境应避免使用
注意， SMEMBERS 有可能返回不同的结果，所以，如果需要存储有序且不重复的数据使用有序集合，存储有序可重复的使用列表

SISMEMBER key member
检查给定元素是否存在于集合中

SRANDMEMBER key [count]
随机返回集合中指定个数的，适合抽奖

• 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合 最多返回整个集合 conut>=0
• 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值 count < 0 长度为count绝对值，元素可能重复
• 如果 count 为 0，返回空
• 如果 count 不指定，随机返回一个元素

SCARD key
返回集合中元素的个数
键的结果会保存信息，集合长度就记录在里面，所以不需要遍历

SPOP key
随机从集合中移除并返回这个被移除的元素

SMOVE source destination member
把元素从源集合移动到目标集合

SDIFF key [key ...]，
取差集，具有方向性
从第一个key的集合中去除其他集合和自己的交集部分

SDIFFSTORE destination key [key ...]
取差集；将差集结果存储在目标key中

SINTER key [key ...]
取所有集合交集部分

SINTERSTORE destination key [key ...]
将交集结果存储在目标key中

SUNION key [key ...]
取所有集合并集

SUNIONSTORE destination key [key ...]
将并集结果存储在目标key中

新浪微博的共同关注
需求：当用户访问另一个用户的时候，会显示出两个用户共同关注哪些相同的用户

设计：将每个用户关注的用户放在集合中，求交集即可

实现如下：
peter={‘john’,‘jack’,‘may’}
ben={‘john’,‘jack’,‘tom’}
那么peter和ben的共同关注为：
SINTER peter ben
结果为 {‘john’,‘jack’}

sscan key cursor [match pattern] [count count]
用于遍历集合中键的元素，sscan继承自scan，具体可以参考scan，上面第三章有说明

• key：迭代指定元素
• cursor：游标（告诉迭代器从哪开始迭代）
• [match pattern]：过滤筛选条件
• [count count]：迭代的个数

例子(每次迭代两个)：

127.0.0.1:6379> sscan setA 0 match * count 2
        1) "1"
        2) 1) "zhangsan"
           2) "lisi"
127.0.0.1:6379> sscan setA 1 match * count 2
        1) "0"
        2) 1) "wangwu"
           2) "baobao"

6. SortedSet

• 类似Set集合
• 有序的、去重的
• 元素是字符串类型
• 每一个元素都关联着一个浮点数分值（Score），并按照分值从小到大的顺序排列集合中的元素。分值可以相同
• 最多包含2^32-1元素

ZADD key score member [score member ...]
增加一个或多个元素；如果元素已经存在，则使用新的score值

ZREM key member [member ...]
移除一个或者多个元素；元素不存在，自动忽略

ZSCORE key member
显示分值

ZINCRBY key increment member
增加或者减少分值 浮点值；increment为负数就是减少

ZRANK key member
返回元素的排名（索引）

ZREVRANK key member
返回元素的逆序排名
首先按照分值从大到小排列，然后再看索引。

ZRANGE key start stop [WITHSCORES]
返回指定索引区间元素；start和stop是按照排名来分割的。
如果score相同，则按照字典序lexicographical order 排列；
默认按照score从小到大，如果需要score从大到小排列，使用ZREVRANGE

ZREVRANGE key start stop [WITHSCORES]
返回指定索引区间元素
如果score相同，则按照字典序lexicographical order 的 逆序 排列
默认按照score从大到小，如果需要score从小到大排列，使用ZRANGE

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
返回指定分值区间元素
返回score默认属于[min,max]之间，元素按照score升序排列，score相同字典序
LIMIT中offset代表跳过多少个元素，count是返回几个。类似于Mysql
使用小括号，修改区间为开区间，例如(5、(10、5
-inf和+inf表示负无穷和正无穷

ZREVRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
返回指定分值区间元素
返回score默认属于[min,max]之间，元素按照score降序排列，score相同字典降序
LIMIT中offset代表跳过多少个元素，count是返回几个。类似于Mysql
使用小括号，修改区间为开区间，例如(5、(10
-inf和+inf表示负无穷和正无穷

ZREMRANGEBYRANK key start stop
移除指定排名范围的元素

ZREMRANGEBYSCORE key min max
移除指定分值范围的元素

ZCARD key
返回集合中元素个数

ZCOUNT key min max
返回指定范围中元素的个数

ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
求并集
ZUNIONSTORE scores-all2 2 scores1 scores2 WEIGHTS 1 0.5 AGGREGATE SUM

• numkeys
  指定key的数量，必须
• WEIGHTS
  与前面设定的key对应，对应key中每一个score都要乘以这个权重
• AGGREGATE
  指定并集结果的聚合方式
• SUM：
  将所有集合中某一个元素的score值之和作为结果集中该成员的score值
• MIN：
  将所有集合中某一个元素的score值中最小值作为结果集中该成员的score值
• MAX：
  将所有集合中某一个元素的score值中最大值作为结果集中该成员的score值

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
求交集