redis基础指令及数据类型

全局指令
redis有5种数据类型，它们是键值对中的值，对于键来讲有些通用的命令。这里称之为全局指令。
set 建立一个键值对

127.0.0.1:6379> set a 1

mset 建立多个键值对

127.0.0.1:6379> mset a 1 b 2 c 3
OK

get 经过键来得到值

127.0.0.1:6379> get a

mget 获取多个键值

127.0.0.1:6379> mget a b c
1) "1"
2) "2"
3) "3"

dbsize 统计键的个数
注：dbsize是经过数据库内置的计数器来实现的，并非将全部键遍历后统计的，没必要担忧影响服务器的性能。

127.0.0.1:6379> dbsize

exists 检查某个键是否存在，存在返回1，不存在返回0

127.0.0.1:6379> exists a   # 键 a存在
(integer) 1
127.0.0.1:6379> exists d    # 键 d 不存在
(integer) 0

del 删除指定键，成功返回1，没有指定键返回0

127.0.0.1:6379> del mylist    # 删除单个键
127.0.0.1:6379> del a b       # 删除多个键

expire 设置键过时，以秒为单位

127.0.0.1:6379> set hello world   #设置一个键
127.0.0.1:6379> expire hello 50   #设置键50秒后过时
(integer) 1
127.0.0.1:6379> get hello   #在过时以前能够查询到键值
"world"
127.0.0.1:6379> ttl hello     # 使用ttl指令查看键的失效时间
(integer) 38
127.0.0.1:6379> ttl hello    # -2：表示键不存在
(integer) -2
127.0.0.1:6379> get hello    # 查询不到键值了
(nil)

关于ttl指令查询的返回值：

大于0：键剩余的过时时间；
-1：键没设置过时时间；
-2：键不存在或已过时；

expireat 设置过时时间，以unix时间戳为单位

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> expireat hello 1583478533   # 最后为unix时间戳
(integer) 1
127.0.0.1:6379> ttl hello
(integer) 1056
127.0.0.1:6379> ttl hello
(integer) 1052

rename 更改键名

127.0.0.1:6379> set  hello world
OK
127.0.0.1:6379> rename hello abc  # 将键名改成abc
OK
127.0.0.1:6379> get hello 
(nil)
127.0.0.1:6379> get abc
"world"

*keys 列出全部键**
这个指令生产中不建议使用，忘了就好。

127.0.0.1:6379> keys *

randomkey 随机返回一个键名

127.0.0.1:6379> randomkey 
"c"
127.0.0.1:6379> randomkey 
"user:1_2:sdiff"

type 查询键值的数据类型

127.0.0.1:6379> type a
string

数据类型有：

string：字符串。
hash：哈希。
list：列表。
set：集合。
zset：有序集合。

select 切换库

redis中默认有16个库，编号为：0–15，配置文件中下面配置决定了库的数量：

databases 16        # 16个库

默认登陆后处于编号为0的库中，使用select指令进行切库操做。

127.0.0.1:6379> select 12
OK
127.0.0.1:6379[12]> select 0
OK

迁移键
move 库和库内部迁移
注：move迁移后，源库将不存在被迁移走的键值对。

127.0.0.1:6379> get abc
"world"
127.0.0.1:6379> move abc 12    # 迁移到编号为12的库
(integer) 1
127.0.0.1:6379> get abc    # 当前库就没有这个键值了
(nil)
127.0.0.1:6379> select 12    # 切换到编号为12的库
OK
127.0.0.1:6379[12]> get abc    # 能够查看到键值
"world"

dump+restore 多个redis实例上进行迁移键值

• dump：进行序列化备份，格式是rdb。
• restore：是将dump产生的序列化的值复原，命令格式为：restore key ttl serialized-value，其中key表示定义的新键名；ttl：设置过时时间，设置为0表示永不过时；serialized-value则为dump产生的序列化值。

# redis01实例上
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> dump hello   # 获取下面的序列化编码
"\x00\x05world\t\x00\xc9#mH\x84/\x11s"
# redis02实例上
127.0.0.1:6379> restore new_hello 0 "\x00\x05world\t\x00\xc9#mH\x84/\x11s"
OK
127.0.0.1:6379> get new_hello
"world"

注：整个迁移过过程，并不是原子性。

migrate 具备原子性的迁移

命令格式：migrate host port key| destination-db timeout [COPY] [REPLACE]

host：主机IP
port：端口
key：要迁移的键
destination-db：要迁移到对端的哪一个编号的库？
timeout：超时时间，单位为毫秒
COPY：是否复制，默认为剪切的方式
replace：migrate无论目标redis是否存在该键都会正常迁移进行数据覆盖。

下面是模拟redis01主机迁移数据到redis02

# 主机redis01上，设置两个键值，以不一样的方式进行迁移
127.0.0.1:6379> set a move_test  
OK
127.0.0.1:6379> set b move_test_02
OK
127.0.0.1:6379> migrate 192.168.20.4 6379 a 0 2    # 这个不加copy，等同于剪切
OK
127.0.0.1:6379> migrate 192.168.20.4 6379 b 0 2 copy   # 加了copy，等同于复制
OK
127.0.0.1:6379> get a    # 剪切走后，本地就没有了
(nil)
127.0.0.1:6379> get b    # 但copy的，本地还有
"move_test_02"
# 主机redis02上进行查询，两个键值对都在
[root@redis03 ~]# redis-cli
127.0.0.1:6379> get a
"move_test"
127.0.0.1:6379> get b
"move_test_02"

info 查看redis实例的详细信息

127.0.0.1:6379> info

# Server
redis_version:5.0.5
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:94d37e8f5f58aed5
redis_mode:standalone
os:Linux 3.10.0-862.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
          ............. # 省略部份内容

redis-cli –stat 动态查看资源使用率

[root@redis ~]# redis-cli --stat   #动态刷新redis的资源使用状况
------- data ------ --------------------- load -------------------- - child -
keys       mem      clients blocked requests            connections          
20         840.41K  1       0       25 (+0)             2           
20         840.41K  1       0       26 (+1)             2           
20         840.41K  1       0       27 (+1)             2

redis的事务

• 事务的特色：要么都执行，要么都不执行。
• 场景：user_A关注了user_B，那么user_A的关注列表里应该有user_B，一样，user_B的粉丝列表中也须要有user_A，这就须要用到事务。

127.0.0.1:6379> multi   # 开启一个事务
OK
# 插入两条数据
127.0.0.1:6379> sadd user:a:follow user:b
QUEUED
127.0.0.1:6379> sadd user:b:follow user:a
QUEUED
# 在事务提交前，是查询不到上面插入的两条数据的
127.0.0.1:6379> exec    # 提交事务便可查看对应的数据
1) (integer) 1
2) (integer) 1

若是要中止事务，能够用discard指令代替exec指令。

数据结构和内部编码
type命令实际返回的是当前键的数据结构类型，但这些只是redis对外的数据结构，实际上每种数据结构都有本身底层的内部编码实现，并且是多种实现，这样redis会在合适的场景选择合适的内部编码。能够经过object encoding命令查询内部编码。

127.0.0.1:6379> object encoding a
"embstr"

内部编码以下：

• sting（字符串）有3种：raw、int、embstr。
• hash（哈希）有2种：hashtable、ziplist。
• list（列表）有2种：linkedlist、ziplist。
• set（集合）有2种：hashtable、intest。
• zset（有序集合）有2种：skiplist、ziplist。

redis的单线程架构
redis使用单线程架构和I/O多路复用模型来实现高性能的内存数据库服务。

redis为何这么快？

• 内存型数据库，这是redis达到每秒万级别访问的重要基础。
• 非阻塞I/O线程，Redis使用epoll做为I/O多路复用技术的实现，再加上redis自身的事件处理模型将epoll中的链接、读写、关闭都转换为事件，不在网络I/O上浪费过多的时间。
• 单线程避免了因线程切换和竞态产生的消耗。

.

单线程的好处：

• 能够简化数据结构和算法的实现。
• 单线程避免了线程切换和竞态产生的消耗。

.

单线程的问题：

• 当某一个指令执行的时间过长，其余命令等待时间过长，形成阻塞。

redis数据类型
string 字符串

127.0.0.1:6379> set a 1     #设置a的值为1

incr 自增（只能对数字自增）
若对值为字符串的进行自增，则会报错(error) ERR value is not an integer or out of range。若键不存在，按0开始自增。

127.0.0.1:6379> set a 1
OK
127.0.0.1:6379> incr a   # 返回自增后的值
(integer) 2
127.0.0.1:6379> get a   # 自增后a 的值为2
"2"

incrby 自增指定数字

127.0.0.1:6379> get a
"1"
127.0.0.1:6379> incrby a 5
(integer) 6
127.0.0.1:6379> get a
"6"

incrbyfloat 自增浮点数
注：若当前值为浮点数，则不能够自增或自减整数，必须使用incrbyfloat将其改变为一个整数才能够自增或自减整数。

127.0.0.1:6379> get a
"2"
127.0.0.1:6379> incrbyfloat a 5.5
"7.5"
127.0.0.1:6379> get a
"7.5"

decr 自减

127.0.0.1:6379> decr a
(integer) 2
127.0.0.1:6379> decr a
(integer) 1
127.0.0.1:6379> get a
"1"

decrby 自减指定数值

127.0.0.1:6379> get a
"6"
127.0.0.1:6379> decrby a 4
(integer) 2
127.0.0.1:6379> get a
"2"

append 追加值
至关于把追加的值合并在原有值后面。若键不存在或没有值，则会生成新的值。

127.0.0.1:6379> set a hello
OK
127.0.0.1:6379> append a " world"  # 在原有值后面追加world。
(integer) 11
127.0.0.1:6379> get a
"hello world"

strlen 统计值的长度

127.0.0.1:6379> get a
"hello world"
127.0.0.1:6379> strlen a
(integer) 11   # 由于值中间有空格，也算一位
127.0.0.1:6379> set a 张三
OK
127.0.0.1:6379> strlen a   # 一个中文占三个字节
(integer) 6

setrange 设置指定位置的字符

127.0.0.1:6379> set redis pest
OK
127.0.0.1:6379> setrange redis 0 b   # 0表示值的第一位，将第一位换为b
(integer) 4
127.0.0.1:6379> get redis
"best"
127.0.0.1:6379> setrange redis 2 d   # 2表示值的第三位，将第三位换为d
(integer) 4
127.0.0.1:6379> get redis
"bedt"

getrange 获取部分字符串
起始数字为0，-1表示最后一位，-2表示倒数第二位…..

127.0.0.1:6379> get redis
"bedt"
127.0.0.1:6379> getrange redis 1 -1   
"edt"
127.0.0.1:6379> getrange redis 1 2
"ed"

关于字符串的内部编码，redis根据键对应的值，用如下规则选择相应的编码：

• int：8字节长度的整数。
• embstr：小于等于39个字节的字符串。
• raw：大于39个字节的字符串。

hash 哈希类型
几乎全部的编程语言都提供了哈希类型，它们的叫法多是哈希、字典、关联属组。

在redis中，哈希类型是指键值自己又是一种键值对结构，例如：value=field1，value1 …. fiedN,valueN。

哈希类型中的映射关系叫作：field-value，这里的value是指field对应的值，不是键对应的值。

hset key field value 建立hash类型的数据类型

127.0.0.1:6379> hset user name tom
(integer) 1   # 返回1表示成功，0表示不成功

hget key field 获取值

127.0.0.1:6379> hget user name
"tom"

hdel key field 删除field

127.0.0.1:6379> hdel user name

hmset及hmget批量设置及获取field

127.0.0.1:6379> hmset user name zhangsan age 18 hobby play city beijing
OK
127.0.0.1:6379> hmget user name age hobby age city
1) "zhangsan"
2) "18"
3) "play"
4) "18"
5) "beijing"

hexists 判断是否存在
存在返回1，不然返回0。

127.0.0.1:6379> hexists user name
(integer) 1
127.0.0.1:6379> hexists user addr
(integer) 0

hkeys 获取全部的field

127.0.0.1:6379> hkeys user  
1) "name"
2) "age"
3) "hobby"
4) "city"

hvals 获取全部的value

127.0.0.1:6379> hvals user
1) "zhangsan"
2) "18"
3) "play"
4) "beijing"

hgetall 获取全部的field及value值
注：元素越多，越容易形成阻塞。

127.0.0.1:6379> hgetall user
1) "name"
2) "zhangsan"
3) "age"
4) "18"
5) "hobby"
6) "play"
7) "city"
8) "beijing"

hincrby key field 自增数字

127.0.0.1:6379> hincrby user age 2   # age增长2
(integer) 20
127.0.0.1:6379> hget user age   
"20"

hstrlen key field 计算哈希值的长度

127.0.0.1:6379> hget user name
"zhangsan"
127.0.0.1:6379> hstrlen user name
(integer) 8   # 长度为8

hash内部编码
当哈希类型元素个数小于 hash-max-ziplist-entries配置（默认512个）、同时全部的值都小于hash-max-ziplist-value配置（默认64字节）时，Redis会使用ziplist做为哈希的内部实现，ziplist使用更加紧凑的结构实现多个元素的连续存储，因此在节省内存方面比hashtable更加优秀。

127.0.0.1:6379> hmset hashkey f1 v1 f2 v2
OK
127.0.0.1:6379> object encoding hashkey
"ziplist"

list 列表
列表是用来存储多个有序的字符串，好比a、b、c、d、e五个元素从左到右组成了一个有序的列表，列表中的每一个字符串称为元素，一个列表最多能够存储2的32次方-1个元素。在redis中，能够对列表两端插入（push）和弹出（pop），还能够获取指定范围的元素列表、获取指定索引下标的元素等，列表是一种比较灵活的数据结构，能够充当栈和队列的角色，在实际开发上有不少应用场景。

列表类型如下有两个特色：

• 列表中的元素是有序的，这意味着能够经过索引下标获取某个元素或者某个范围内的元素列表。
• 列表中的元素是能够重复的。

rpush、lpush 添加操做

127.0.0.1:6379> rpush listk c b a  # r表示右（right），从右面开始插入
(integer) 3
127.0.0.1:6379> lpush listk d e f  # l表示左（left），从左面开始插入
(integer) 6
127.0.0.1:6379> lrange listk 0 -1  # 从左到右查看第一个到最后一个全部的元素
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"

向某个元素前或者后插入元素

127.0.0.1:6379> lrange listk 0 -1   # 查看原有数据
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> linsert listk before b redis  # 向b后面插入redis
(integer) 7
127.0.0.1:6379> linsert listk after b python   # 向b前面插入python
(integer) 8
127.0.0.1:6379> lrange listk 0 -1   # 查看确认
1) "f"
2) "e"
3) "d"
4) "c"
5) "redis"
6) "b"
7) "python"
8) "a"

lrange 查看某个范围内的值
下标从前日后0开始，从后往前是从-1开始。

127.0.0.1:6379> lrange listk 0 -3
1) "f"
2) "e"
3) "d"
4) "c"
5) "redis"
6) "b"

lindex 获取列表指定索引下标的元素

127.0.0.1:6379> lindex listk 0
"f"
127.0.0.1:6379> lindex listk -3
"b"
127.0.0.1:6379> lindex listk -2
"python"

llen 获取列表的长度

127.0.0.1:6379> llen listk
(integer) 8

lpop、rpop 删除列表中的元素

127.0.0.1:6379> lrange listk 0 -1    # 查看原有元素
1) "f"
2) "e"
3) "d"
4) "c"
5) "redis"
6) "b"
7) "python"
8) "a"
127.0.0.1:6379> lpop listk   # 从左起，删除一个
"f"
127.0.0.1:6379> rpop listk    # 从右起，删除一个
"a"
127.0.0.1:6379> lrange listk 0 -1   # 最后查看数据
1) "e"
2) "d"
3) "c"
4) "redis"
5) "b"
6) "python"

lrem key count value 指定范围内删除指定元素

注：

• count > 0：从左往右删，删多少看count的值，若是指定的count范围内没有指定的值，则不删。
• count < 0：从右往左删，其他同上。
• 返回0表示没有删除，1表示有删除操做。

127.0.0.1:6379> lrange listk 0 -1  # 查看现有的集合
1) "e"
2) "d"
3) "c"
4) "redis"
5) "b"
6) "python"
127.0.0.1:6379> lrem listk 4 a   # 从左往右删4个元素，若是这4个元素中没有a，则不删
(integer) 0   
127.0.0.1:6379> lrange listk 0 -1   # 由于从左往右，4个元素内没有a，因此不执行删除
1) "e"
2) "d"
3) "c"
4) "redis"
5) "b"
6) "python"
127.0.0.1:6379> lrem listk 4 d   # 换个条件
(integer) 1
127.0.0.1:6379> lrange listk 0 -1   # 由于从左往右，4个元素内有d，因此执行删除操做
1) "e"
2) "c"
3) "redis"
4) "b"
5) "python"

ltrim key start stop 保留指定下标内的值，其他都删除

下标：

• 从左往右，第一个元素的下标为0，依次为0、一、2….
• 从右往左，第一个元素的下标为-1，依次为-一、-二、-3….

127.0.0.1:6379> lrange listk 0 -1    # 查看初始值
1) "e"
2) "c"
3) "redis"
4) "b"
5) "python"
127.0.0.1:6379> ltrim listk 1 3   # 保留下标1到3的值
OK
127.0.0.1:6379> lrange listk 0 -1   # 只剩下原来下标1到3的值了
1) "c"
2) "redis"
3) "b"

lset 修改列表中的元素值

127.0.0.1:6379> lrange listk 0 -1
1) "c"
2) "redis"
3) "b"
127.0.0.1:6379> lset listk 2 python   # 修改下标为2的值为python
OK
127.0.0.1:6379> lrange listk 0 -1
1) "c"
2) "redis"
3) "python"

list内部编码

列表的内部编码有两种：

• ziplist：压缩列表，当列表的元素个数小于list-max-ziplistentries配置（默认512个），同时列表中每一个元素的值都小于list-max-ziplist-value配置时（默认64字节），Redis会选用ziplist来做为表的内部实现来减小内存的使用。
• Linkedlist：链表，当列表类型没法知足ziplist的条件时，Redis会使用linkedlist做为列表的内部实现。

list使用场景：消息队列、文章列表……

set 集合
集合类型也是用来保存多个字符串元素，但和列表类型不同的是，集合中不容许有重复的元素，而且集合中的元素是无序的，不能经过索引下标获取元素。一个集合最多能够存储2的32次方-1个元素，redis除了支持集合内的增删改查，同时还支持多个集合取交集、并集、差集。

sadd 插入元素

127.0.0.1:6379> sadd myset a b c   # 建立一个新的集合
(integer) 3
127.0.0.1:6379> sadd myset a b d    # a b 这两个元素已存在，因此不会添加到集合中
(integer) 1   # 只添加了一个元素

srem 删除元素

127.0.0.1:6379> srem myset a b
(integer) 2

scard 统计集合中的元素总数

127.0.0.1:6379> scard myset   
(integer) 2    # myset集合中元素总数为2

sismember 判断元素是否在这个集合中

127.0.0.1:6379> sismember myset a
(integer) 0   # 0表示不在
127.0.0.1:6379> sismember myset c
(integer) 1    # 1表示在

srandmember 随机从集合中返回指定个数的元素，默认返回1个

127.0.0.1:6379> srandmember myset 2   # 返回2个
1) "c"
2) "d"
127.0.0.1:6379> srandmember myset     # 不指定则返回1个
"d"

spop 从集合随机删除元素(默认删除1个)

127.0.0.1:6379> spop myset
"d"    # 元素d被删除

smembers 查看集合内全部元素

127.0.0.1:6379> smembers myset
1) "c"
2) "three"
3) "two"
4) "one"
5) "four"

sinter 求多个集合交集

# 定义两个集合，这两个集合在后面会屡次用到
127.0.0.1:6379> sadd user:1 follow it music his sports
(integer) 5
127.0.0.1:6379> sadd user:2 follow it news ent sports
(integer) 5
127.0.0.1:6379> sinter user:1 user:2   # 返回的是两个集合共有的元素
1) "it"
2) "follow"
3) "sports"

sdiff 求多个集合不一样的元素
注：在求不一样的元素时，返回的结果是第一个集合有，而第二个集合中没有的元素。

127.0.0.1:6379> sdiff user:1 user:2   
1) "music"
2) "his"
127.0.0.1:6379> sdiff user:2 user:1
1) "news"
2) "ent"

sunion 求多个集合之间的并集（至关于去重后显示）

127.0.0.1:6379> sunion user:1 user:2
1) "sports"
2) "news"
3) "music"
4) "his"
5) "ent"
6) "it"
7) "follow"

xxxxx+store 差集/并集/交集的结果保存

# 将两个集合中共有的元素保存到集合user:1_2:inter
127.0.0.1:6379> sinterstore user:1_2:inter user:1 user:2
(integer) 3
127.0.0.1:6379> smembers user:1_2:inter
1) "sports"
2) "it"
3) "follow"

# 将两个集合中不一样的元素保存到集合user:1_2:sdiff
127.0.0.1:6379> sdiffstore user:1_2:sdiff user:1 user:2
(integer) 2
127.0.0.1:6379> smembers user:1_2:sdiff
1) "his"
2) "music"

# 将两个集合的并集保存到集合user:1_2:sunion
127.0.0.1:6379> smembers user:1_2:sunion
1) "sports"
2) "news"
3) "music"
4) "his"
5) "ent"
6) "it"
7) "follow"

集合的内部编码

集合的内部编码有两种：

• intset：整数集合，当集合中的元素都是整数且元素个数小于set-max-intest-entries配置(默认512个)时，Redis会选用intset来做为集合的内部实现，从而减小内存的使用。
• hashtable：哈希表，当集合类型没法知足intset的条件时，Redis会使用hashtable做为集合的内部实现。

127.0.0.1:6379> sadd setkey 1 2 3 4
(integer) 4
127.0.0.1:6379> object encoding setkey   # 内部编码为intset
"intset"
127.0.0.1:6379> sadd setkey a
(integer) 1
127.0.0.1:6379> object encoding setkey     # 内部编码为hashtable
"hashtable"

集合的使用场景
集合类型比较典型的使用场景是标签(tag)。好比一个用户可能对娱乐、体育比较感兴趣，另外一个用户可能对历史、新闻比较感兴趣，这些兴趣点就是标签。有了这些数据就能够获得喜欢同一个标签的人，以及用户的共同喜爱的标签，这些数据对于用户体验以及加强用户黏度比较重要。例如一个电子商务的网站会对不一样标签的用户作不一样类型的推荐，好比对数码产品比较感兴趣的人，在各个页面或者经过邮件的形式给他们推存最新的数码产品，一般会为网站带来史多的利益。

有序集合
Redis 有序集合和集合同样也是string类型元素的集合，且不容许重复的成员。

不一样的是每一个元素都会关联一个double类型的分数。redis正是经过分数来为集合中的成员进行从小到大的排序。

有序集合的成员是惟一的,但分数(score)却能够重复。

集合是经过哈希表实现的，因此添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 – 1 (4294967295, 每一个集合可存储40多亿个成员)。

zadd 集合内添加成员
格式为：ZADD key score1 member1 [score2 member2]…..

127.0.0.1:6379> zadd javapoint 1 redis 4 mysql 2 python 3 shell

zcard 计算集合内成员个数

127.0.0.1:6379> zcard javapoint
(integer) 4

zscore 求某个成员的分数

127.0.0.1:6379> zscore javapoint shell
"3"

zrank 求集合内元素的排名（由低到高，从0开始排名）

127.0.0.1:6379> zrank javapoint mysql
(integer) 3
127.0.0.1:6379> zrank javapoint redis
(integer) 0
127.0.0.1:6379> zrank javapoint shell
(integer) 2

zrevrange 同求排名（由高到低，从0开始排名）

127.0.0.1:6379> zrevrank javapoint mysql
(integer) 0
127.0.0.1:6379> zrevrank javapoint shell
(integer) 1

还有不少我就不举例了，列个表吧，以下：

序号	命令	描述
1	ZADD key score1 member1 [score2 member2]	向有序集合添加一个或多个成员，或者更新已存在成员的分数
2	ZCARD key	获取有序集合的成员数
3	ZCOUNT key min max	计算在有序集合中指定区间分数的成员数
4	ZINCRBY key increment member	有序集合中对指定成员的分数加上增量 increment
5	ZINTERSTORE destination numkeys key [key …]	计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
6	ZLEXCOUNT key min max	在有序集合中计算指定字典区间内成员数量
7	ZRANGE key start stop [WITHSCORES]	经过索引区间返回有序集合成指定区间内的成员
8	ZRANGEBYLEX key min max [LIMIT offset count]	经过字典区间返回有序集合的成员
9	ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]	经过分数返回有序集合指定区间内的成员
10	ZRANK key member	返回有序集合中指定成员的索引
11	ZREM key member [member …]	移除有序集合中的一个或多个成员
12	ZREMRANGEBYLEX key min max	移除有序集合中给定的字典区间的全部成员
13	ZREMRANGEBYRANK key start stop	移除有序集合中给定的排名区间的全部成员
14	ZREMRANGEBYSCORE key min max	移除有序集合中给定的分数区间的全部成员
15	ZREVRANGE key start stop [WITHSCORES]	返回有序集中指定区间内的成员，经过索引，分数从高到底
16	ZREVRANGEBYSCORE key max min [WITHSCORES]	返回有序集中指定分数区间内的成员，分数从高到低排序
17	ZREVRANK key member	返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
18	ZSCORE key member	返回有序集中，成员的分数值
19	ZUNIONSTORE destination numkeys key [key …]	计算给定的一个或多个有序集的并集，并存储在新的 key 中
20	ZSCAN key cursor [MATCH pattern] [COUNT count]	迭代有序集合中的元素（包括元素成员和元素分值）