Redis之数据结构

Bertha 。 2023-06-22 08:30 2阅读 0赞

### 文章目录 ###

*  Redis实战
 *   *  概念
     *  Redis与其他数据库对比
     *  Redis数据结构
     *   *  字符串String
         *  列表List
         *  集合Set
         *  散列Hash
         *  有序集合Zset
     *

# Redis实战 #

## 概念 ##

Redis是一个速度非常快的非关系型数据库(non-relational database),他可以存储键(key)与五中不同类型的值(value)之间的映射，可以将存储到内存的键值对数据持久化到硬盘，可以使用复制特性类扩展读性能，还可以使用客户端分片来扩展写性能，

`注：分片是一种将数据划分为多个部分的方法，对数据的划分可以基于键包含的ID、基于键的散列值，或者基于以上两者的某种组合。通过对数据进行分片，用户可以将数据存储到多台机器里面，也可以从多台机器里面获取数据，这种方法在解决某些问题时可以获得线性级别的性能提升。`

## Redis与其他数据库对比 ##

高性能简直缓存服务器memcached经常用来和Redis进行比较，两者都用于存储键值映射，memcached只能存储普通的字符串键，而redis除了能存储普通的字符串键以外，还可以存储其他四中数据结构，分别为list列表，set集合，hash散列，zset有序集合，并且redis能自动以两种不同的方式将数据写入硬盘，除此之外redis既可以用作主数据库使用，又可以作为其他存储系统的辅助数据库使用。

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>类型</th> 
   <th>存储类型</th> 
   <th>查询类型</th> 
   <th>附加功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Redis</td> 
   <td>使用内存存储的非关系数据库</td> 
   <td>字符串，列表，集合，散列，有序集合</td> 
   <td>每种数据类型都有自己的专属命令，另外还有批量操作和不完全的事务支持</td> 
   <td>发布与订阅，主从复制持久化，脚本</td> 
  </tr> 
  <tr> 
   <td>memcached</td> 
   <td>使用内存存储的键值缓存</td> 
   <td>键值之间的映射</td> 
   <td>创建命令，读取命令，更新命令，删除命令以及其他几个命令</td> 
   <td>为提升性能而设的多线程服务器</td> 
  </tr> 
  <tr> 
   <td>MySQL</td> 
   <td>关系型数据库</td> 
   <td>每个数据库包含多个表，每个表包含多个行，可以处理多个表的视图，支持空间和第三方扩展</td> 
   <td>SELECT,INSERT,UPDATE,DELETE,函数，存储过程</td> 
   <td>支持ACID性质，主从复制和主主复制</td> 
  </tr> 
  <tr> 
   <td>PostgreSQL</td> 
   <td>关系型数据库</td> 
   <td>每个数据库包含多个表，每个表包含多个行，可以处理多个表的视图，支持空间和第三方扩展，支持定制类型</td> 
   <td>SELECT,INSERT,UPDATE,DELETE,内置函数，自定义的存储过程</td> 
   <td>支持ACID性质，主从复制，有第三方支持的多主复制</td> 
  </tr> 
  <tr> 
   <td>MongoDB</td> 
   <td>使用硬盘存储的非关系型数据库</td> 
   <td>每个数据库包含多个表，每个表包含多个schema的BSON文档</td> 
   <td>创建命令，读取命令，更新命令，删除命令以及条件查询命令</td> 
   <td>支持map-reduce操作，主从复制，分片，空间索引</td> 
  </tr> 
 </tbody> 
</table>

## Redis数据结构 ##

Redis可以存储键与五种不同数据结构类型之间的映射分别为字符串String ，列表List，集合Set，散列Hash，有序集合Zset

<table> 
 <thead> 
  <tr> 
   <th>结构类型</th> 
   <th>存储的值</th> 
   <th>读写能力</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String</td> 
   <td>可以是字符串、整数、或者浮点数</td> 
   <td>对整个字符串或者字符串的其中一部分执行操作，对整数和浮点数执行自增或者自减</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>一个链表，链表上的每个节点都包含了一个字符串</td> 
   <td>从链表的两端推入或者弹出元素，根据偏移量对链表进行修剪，读取单个或者多个元素，根据值查找或者移除元素</td> 
  </tr> 
  <tr> 
   <td>Set</td> 
   <td>包含字符串的无序收集器，并且被包含的字符串都是独一无二的，各不相同</td> 
   <td>添加、获取，移除单个元素，检查一个元素是否存在于集合中，计算交集，并集，差集，从集合里面随机获取元素</td> 
  </tr> 
  <tr> 
   <td>Hash</td> 
   <td>包含键值对的无序散列表</td> 
   <td>添加、获取、移除单个键值对，获取所有键值对</td> 
  </tr> 
  <tr> 
   <td>Zset</td> 
   <td>字符串成员与浮点数分支之间的有序映射，元素的排列顺序由分支大小决定</td> 
   <td>添加、获取、移除单个元素，根据分支范围或者成员获取元素</td> 
  </tr> 
 </tbody> 
</table>

在这里介绍每种结构类型的一些常用的命令

### 字符串String ###

String类型是**二进制安全的**。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。

String类型是 Redis 最基本的数据类型，string 类型的值最大能存储 **512MB**。

**使用场景**

*  缓存功能：字符串可以存储的类型包括简单的字符串，xml，json，数字，二进制(图片，视频等)，常用redis作为缓存层，将数据存储到redis中，减少数据库压力，而且redis支持高并发，可以降低读写速度
 *  共享session：分布式服务经用户信息存储到redis中，可以集中管理，常用的功能就是单点登录，不论哪一个服务器都可以通过redis获取用户信息。

**常用命令**

`set key-name value ：创建key并且为key添加value，当然如果重复添加那么就会覆盖前面的value`

`get key-name ：通过key获取value值`

127.0.0.1:6379> set mykey '13'
    OK
    127.0.0.1:6379> get mykey
    "13"
    127.0.0.1:6379> set mykey hehe
    OK
    127.0.0.1:6379> get mykey
    "hehe"

`append key-name value：将值value追加到给定key当前存储值得末尾，返回此刻key的长度，与get相似，如果key-name不存在，那么就创建key并且存储value`

127.0.0.1:6379> append otherkey word
    (integer) 4
    127.0.0.1:6379> get otherkey
    "word"

`getrange key-name start end：通过指定字符串的下标获取下标start到end的子字符串，且包含start和end的字符，若start为0，end为-1，那么获取到的是key所存储的字符串`

127.0.0.1:6379> get mykey
    "hehehello"
    127.0.0.1:6379> getrange mykey 1 3
    "ehe"
    127.0.0.1:6379> getrange mykey 0 -1
    "hehehello"

`setrange key-name offset value：通过指定的偏移量offset开始将key存储的value值替换，设置为指定的value`

127.0.0.1:6379> get mykey
    "hehehello"
    127.0.0.1:6379> setrange mykey 2 aaa
    (integer) 9
    127.0.0.1:6379> get mykey
    "heaaaello"

`incr kye-name：将key存储的值加1，如果value是字符串且能转换成整数也可以加1`

`decr key-name：将key存储的值减1，如果value是字符串且能转换成整数也可以减1`

127.0.0.1:6379> set mykey '13'
    OK
    127.0.0.1:6379> get mykey
    "13"
    127.0.0.1:6379> incr mykey
    (integer) 14

`incrby key-name amount：将key存储的值加amount，如果value是字符串且能转换成整数也可以加amount`

`decr key-name amount：将key存储的值减amount，如果value是字符串且能转换成整数也可以减amount`

127.0.0.1:6379> set other '4'
    OK
    127.0.0.1:6379> incr other
    (integer) 5
    127.0.0.1:6379> get other
    "5"
    127.0.0.1:6379> incrby other 5
    (integer) 10
    127.0.0.1:6379>

`incrbyfloat key-name amount：将key存储的值加浮点amount，这个命令在Redis2.6版本以及以上可以使用`

127.0.0.1:6379> set other 2.2
    OK
    127.0.0.1:6379> incrbyfloat other 2.2
    "4.4"
    127.0.0.1:6379> set other '2.2'
    OK
    127.0.0.1:6379> incr other 2
    (error) ERR wrong number of arguments for 'incr' command
    127.0.0.1:6379> incrbyfloat other 3.3
    "5.5"
    127.0.0.1:6379>

### 列表List ###

Redis的列表允许用户从序列的两端推入或者弹出元素，获取列表元素，以及执行各种常见的列表操作。除此之外，列表还可以用于存储任务信息、最近浏览过的文章或者常用联系人信息。列表的元素是有序且可重复的。

**使用场景**

*  消息队列： redis的lpush+brpop命令组合即可实现阻塞队列，生产者客户端是用lpush从列表左侧插入元素，多个消费者客户端使用brpop命令阻塞式的“抢”列表尾部的元素，多个客户端保证了消费的负载均衡和高可用性
 *  数据分页：比如每一个用户保存的图书，可以通过分页展示，由于列表是有序的，而且可以通过下标查询一定范围内的元素
 *  模拟队列和栈：lpush+lpop = stack 栈；lpush + rpop = queue 队列；；lpush + brpop = message queue 消息队列；lpush + ltrim = capped collection 有限集合

**常用命令**

`rpush key-name value [value ...]： 将一个或多个值推入列表的右端，返回列表长度`

`lpush key-name value [value ...]： 将一个或多个值推入列表的左端，返回列表长度`

127.0.0.1:6379> rpush  key a b c d e
    (integer) 5
    127.0.0.1:6379> lrange key 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    5) "e"
    127.0.0.1:6379> lpush key f h j
    (integer) 8
    127.0.0.1:6379> lrange key 0 -1
    1) "j"
    2) "h"
    3) "f"
    4) "a"
    5) "b"
    6) "c"
    7) "d"
    8) "e"

`rpop key-name ：移除并返回列表最右端的元素`

`lpop key-name：移除并返回列表最左端的元素`

127.0.0.1:6379> rpop key
    "e"
    127.0.0.1:6379> lpop key
    "j"

lindex key-name offset：返回列表指定下标的元素，从最左端开始

127.0.0.1:6379> lrange key 0 -1
    1) "h"
    2) "f"
    3) "a"
    4) "b"
    5) "c"
    6) "d"
    127.0.0.1:6379> lindex key 3
    "b"

`ltrim key-name start end：对列表进行修剪，只保留start到end之间的元素，包含start和end的元素`

`lrange key-name start end：返回指定key的value下标从start到end之间的所有元素，包含start和end的元素，若start为0，end为-1那么返回的是key的所有value元素`

127.0.0.1:6379> ltrim key 2 6
    OK
    127.0.0.1:6379> lrange key 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"

`blpop key-name [key-name ...] timeout：从第一个非空列表中弹出最左端的元素并返回列表key和弹出的元素或者timeout秒内阻塞并等待可弹出的元素出现`

`brpop key-name [key-name ...] timeout：从第一个非空列表中弹出最右端的元素并返回列表key和弹出的元素或者timeout秒内阻塞并等待可弹出的元素出现`

127.0.0.1:6379> lrange key 0 -1
    1) "a"
    127.0.0.1:6379> lrange key1 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    5) "e"
    6) "w"
    7) "q"
    127.0.0.1:6379> blpop key1 key 1
    1) "key1"
    2) "a"
    127.0.0.1:6379> blpop key2 key1 1
    1) "key1"
    2) "b"

rpoplpush source-key dec-key：从source列表的最右端弹出元素推入到dec列表的最左端，并返回这个元素

127.0.0.1:6379> lrange key 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    127.0.0.1:6379> lrange key1 0 -1
    1) "e"
    2) "w"
    3) "q"
    127.0.0.1:6379> brpoplpush key key1 1
    "d"
    127.0.0.1:6379> lrange key1 0 -1
    1) "d"
    2) "e"
    3) "w"
    4) "q"

`brpoplpush source-key dec-key timeout：从source列表的最右端弹出元素推入到dec列表的最左端，并返回这个元素，如果source-key为空，那么在timout秒内阻塞并等待可弹出的元素出现，所超时没有等到元素，那么返回nil和等待的时间`

127.0.0.1:6379> lrange key1 0 -1
    1) "d"
    2) "e"
    3) "w"
    4) "q"
    127.0.0.1:6379> lrange key 0 -1
    1) "a"
    2) "b"
    3) "c"
    127.0.0.1:6379> brpoplpush key key1 1
    "c"
    127.0.0.1:6379> brpoplpush key key1 1
    "b"
    127.0.0.1:6379> brpoplpush key key1 1
    "a"
    127.0.0.1:6379> brpoplpush key key1 5
    (nil)
    (5.17s)

对于阻塞弹出命令和弹出并推入命令，最常见的用例就是消息传递和任务队列。

### 集合Set ###

Redis的集合以无序的方式存储多个各不相同的元素，用户可以快速地对集合执行添加元素操作、移除元素操作以及检查一个元素是否存在于集合里。

**使用场景**

*  标签：集合类型比较典型的使用场景，如一个用户对娱乐、体育比较感兴趣，另一个可能对新闻感兴 趣，这些兴趣就是标签，有了这些数据就可以得到同一标签的人，以及用户的共同爱好的标签，这些数据对于用户体验以及增强用户粘度比较重要。（用户和标签的关系维护应该放在一个事物内执行，防止部分命令失败造成数据不一致）
 *  社交软件中功能好友sadd + sinter 即求交集
 *  随机数如：从一个集合中随机抽取一个元素，spop/srandmember

**常用命令**

`sadd key-name item [item ...] ：将一个或者多个元素添加到集合里，并且返回被添加元素当中原本不存在与集合中的数量`

`smembers key-name：返回集合里所有元素，因为集合是无序的，所以使用smembers返回的所有元素的顺序不一定相同`

127.0.0.1:6379> smembers key6
    1) "h"
    2) "a"
    3) "b"
    4) "r"
    5) "t"
    6) "n"
    7) "w"
    8) "q"
    9) "g"
    127.0.0.1:6379> sadd key6 h
    (integer) 0
    127.0.0.1:6379> sadd key6 m l h
    (integer) 2
    127.0.0.1:6379> sadd key7 u i
    (integer) 2

`srem key-name item [item ...]：从集合里面移除一个或者多个元素，并且返回被移除元素的数量`

127.0.0.1:6379> sadd key2 a b c
    (integer) 3
    127.0.0.1:6379> srem key2 a
    (integer) 1

`sismember key-name item：检查元素是否存在于集合里，若存在返回1，若不存在返回0`

127.0.0.1:6379> smembers key2
    1) "c"
    2) "b"
    127.0.0.1:6379> sismember key2 a
    (integer) 0
    127.0.0.1:6379> sismember key2 c
    (integer) 1

`scard key-name ： 返回集合包含元素的数量`

127.0.0.1:6379> scard key2
    (integer) 2
    127.0.0.1:6379> sadd key2 q w r t
    (integer) 4
    127.0.0.1:6379> scard key2
    (integer) 6

`srandmember key-name [count]：从集合里面随机地返回一个或者多个元素，当count为整数的时候返回的元素不会重复，当count为负数的时候，返回的元素可能会重复`

127.0.0.1:6379> srandmember key2 -6
    1) "c"
    2) "t"
    3) "c"
    4) "w"
    5) "t"
    6) "r"
    127.0.0.1:6379> srandmember key2 6
    1) "r"
    2) "b"
    3) "q"
    4) "w"
    5) "t"
    6) "c"

`spop key-name ：随机的移除集合中一个元素，并且返回移除元素`

127.0.0.1:6379> smembers key2
    1) "c"
    2) "b"
    3) "q"
    4) "w"
    5) "r"
    6) "t"
    127.0.0.1:6379> spop key2
    "c"
    127.0.0.1:6379> smembers key2
    1) "q"
    2) "w"
    3) "b"
    4) "r"
    5) "t"

`smove source-key dest-key item：如果集合source包含元素item，那么从source集合中移除元素item，并且将元素item添加到dest中，如果item被移除成功，返回1，否则返回0`

127.0.0.1:6379> smove key6 key7 h
    (integer) 1
    127.0.0.1:6379> smembers key6
     1) "b"
     2) "r"
     3) "t"
     4) "l"
     5) "m"
     6) "n"
     7) "a"
     8) "w"
     9) "q"
    10) "g"
    127.0.0.1:6379> smembers key7
    1) "i"
    2) "u"
    3) "h"

`sdiff key-name [key-name]：返回存在第一个集合中的元素，但是不存在与其他集合中的元素，也就是差集`

127.0.0.1:6379> smembers key2
    1) "c"
    2) "b"
    3) "q"
    4) "w"
    5) "r"
    6) "t"
    127.0.0.1:6379> sadd key3 a g h q w r t n
    (integer) 8
    127.0.0.1:6379> sdiff key3 key2
    1) "g"
    2) "n"
    3) "h"
    4) "a"

`sdiffstore dest-key key-name [key-name]：将那些存在第一个集合中的元素，但不存在于其他集合中的元素，保存到dest集合中`

127.0.0.1:6379> sdiffstore key4 key3 key2
    (integer) 4
    127.0.0.1:6379> smembers key4
    1) "g"
    2) "n"
    3) "h"
    4) "a"

`sinter key-name [key-name]：返回同时存在所有集合中的元素，也就是交集`

127.0.0.1:6379> sinter key2 key3
    1) "q"
    2) "w"
    3) "r"
    4) "t"

`sinterstore dest-key key-name [key-name]：将同时存在所有集合中的元素，存储到集合dest中`

127.0.0.1:6379> sinterstore key5 key3 key2
    (integer) 4
    127.0.0.1:6379> smembers key5
    1) "t"
    2) "w"
    3) "q"
    4) "r"

`sunion key-name [key-name]：返回那些至少存在一个集合中的元素，也就是求集合的并集`

127.0.0.1:6379> sunion key3 key2
    1) "h"
    2) "a"
    3) "b"
    4) "r"
    5) "t"
    6) "n"
    7) "w"
    8) "q"
    9) "g"

`sunionstore dest-key key-name [key-name] ：返回那些至少存在一个集合中的元素，并存储到dest集合中`

127.0.0.1:6379> sunionstore key6 key3 key2
    (integer) 9
    127.0.0.1:6379> smembers key6
    1) "h"
    2) "a"
    3) "b"
    4) "r"
    5) "t"
    6) "n"
    7) "w"
    8) "q"
    9) "g"

### 散列Hash ###

Redis的散列可以让用户将多个键值对存储到一个Redis键里面。从功能上来说，Redis为散列提供了一些与字符串值相同的特性，是的散列非常适用于将一些相关的数据存储到一起。

**使用场景**

*  用户信息：hash类型将一些相关的数据存储到了一起，比如用户信息，key是用户姓名，value的键值对可以是住址信息，年龄信息，家庭信息等等。

**常用命令**

`hset key-name key value：为散列里面添加一个键值对`

`hmset key-name key value [key value ....]：为散列里面添加一个或者多个键值对`

`返回值不同`

127.0.0.1:6379> hset key name Tome
    (integer) 1
    127.0.0.1:6379> hmset key age 28 address US
    OK

`hget key-name key：从散列中获得一个key的值`

`hmget key-name key [key ...]：从散列中获取多个key的值`

127.0.0.1:6379> hget key name
    "Tome"
    127.0.0.1:6379> hmget key name age address
    1) "Tome"
    2) "28"
    3) "US"

`hexists key-name key：检查给定键是否存在于散列中，如果存在返回1，如果不存在返回0`

127.0.0.1:6379> hexists key name
    (integer) 1
    127.0.0.1:6379> hexists key id
    (integer) 0

`hkeys key-name：获取散列中所有的key`

127.0.0.1:6379> hkeys key
    1) "name"
    2) "age"
    3) "address"

`hvals key-name：获取散列中所有的值`

127.0.0.1:6379> hvals key
    1) "Tome"
    2) "28"
    3) "US"

`hgetall key-name：获取散列包含的所有键值对`

127.0.0.1:6379> hgetall key
    1) "name"
    2) "Tome"
    3) "age"
    4) "28"
    5) "address"
    6) "US"

`hdel key-name key：删除散列中指定的键值对，如果删除成功返回1，如果删除失败返回0`

127.0.0.1:6379> hdel key address
    (integer) 1
    127.0.0.1:6379> hdel key a
    (integer) 0

`hlen key-name：返回散列的长度`

127.0.0.1:6379> hlen key
    (integer) 2

`hincrby key-name key increment：将键key存储的值上添加整数increment，key存储的值必须能转换成整数才能添加，否则报错`

127.0.0.1:6379> hincrby key age 5
    (integer) 33
    127.0.0.1:6379> hincrby key name 2
    (error) ERR hash value is not an integer
    127.0.0.1:6379>

`hincrbyfloat key-name key increment：将键key存储的值上添加浮点数increment`

127.0.0.1:6379> hincrbyfloat key age 3.0
    "36"
    127.0.0.1:6379> hincrbyfloat key age 0.5
    "36.5"
    127.0.0.1:6379> hincrbyfloat key name 1.0
    (error) ERR hash value is not a valid float

### 有序集合Zset ###

有序集合和散列一样，都用于存储键值对：有序集合的键被称为成员member，每个成员都是各不相同的，而有序集合的值则被称为分支score，分值必须为浮点数，有序集合是Redis里面唯一一个既可以根据成员访问元素，又可以根据分值以及分值的排列顺序来访问元素的结构。

**使用场景**

*  排行榜：有序集合顾名思义就是可以排序，与散列相似存储的也是键值对，比如博客排行榜，key是技术类，value根据时间排序的文章信息或者评论多少，点赞多少排序的文章信息。

**常用命令**

`zadd key-name score member [score member ...]：将带有给定分值的成员添加有序集合里面，返回添加成功的数量`

127.0.0.1:6379> zadd yourkey 1 a
    (integer) 1

zcard key-name ：返回有序集合包含的成员数量

127.0.0.1:6379> zadd yourkey 1 a
    (integer) 1
    127.0.0.1:6379> zadd yourkey 2 'b'
    (integer) 1
    127.0.0.1:6379> zcard yourkey
    (integer) 2

`zrem key-name meber [member ...]：从有序集合里面移除给定成员，并返回被移除成员数量`

`zremrangebyscore key-name min max ：移除有序集合中分值介于min和max之间的所有成员`

`zremrangebyrank key-name start stop :移除有序集合排名介于start和stop之间的所有成员`

127.0.0.1:6379> zrem yourkey a
    (integer) 1
    127.0.0.1:6379> zcard yourkey
    (integer) 1
    127.0.0.1:6379> zremrangebyscore yourkey 0 5
    (integer) 2
    127.0.0.1:6379> zrange yourkey 0 10 withscores
    1) "b"
    2) "7"
    127.0.0.1:6379>

`zincrby key-name increment member：将member成员的分值加上increment，如果member不存在，那么会将member存储到有序集合中，score为0，从0加increment`

127.0.0.1:6379> zincrby yourkey 5 a
    "5"
    127.0.0.1:6379> zincrby yourkey 5 b
    "7"

`zcount key-name min max：返回分值介于min和max之间的成员数量`

127.0.0.1:6379> zcount yourkey 2 5
    (integer) 1
    127.0.0.1:6379> zcount yourkey 0 4
    (integer) 0

`zrank key-name member：返回成员member在有序集合中的排名，每次添加一个新的成员，都会通过分值排序`

`zscore key-name member：返回成员member的分值`

`zrange key-name start stop [WITHSCORES]：返回有序集合中排名介于start和stop之间的成员，如果给定了可选的WITHSCORES选项，那么命令会将成员的分值也一并返回`

127.0.0.1:6379> zrank yourkey a
    (integer) 0
    127.0.0.1:6379> zrank yourkey b
    (integer) 1
    127.0.0.1:6379> zadd yourkey 4 c
    (integer) 1
    127.0.0.1:6379> zrank yourkey c
    (integer) 0
    127.0.0.1:6379> zrange yourkey 0 5
    1) "c"
    2) "a"
    3) "b"
    127.0.0.1:6379> zrange yourkey 0 5 WITHSCORES
    1) "c"
    2) "4"
    3) "a"
    4) "5"
    5) "b"
    6) "7"
    127.0.0.1:6379>

`zrevrank key-name member ：返回有序集合成员member的排名，成员按照分值从大到小排序`

127.0.0.1:6379> zrange yourkey 0 10 WITHSCORES
    1) "c"
    2) "4"
    3) "a"
    4) "5"
    5) "b"
    6) "7"
    127.0.0.1:6379> zrevrank yourkey a
    (integer) 1
    127.0.0.1:6379> zrevrank yourkey b
    (integer) 0
    127.0.0.1:6379>

`zrevrange key-name start stop [WITHSCORES]：返回有序集合给定排序范围内的成员，成员按照分值从大到小排序`

127.0.0.1:6379> zrange yourkey 0 10 WITHSCORES
    1) "c"
    2) "4"
    3) "a"
    4) "5"
    5) "b"
    6) "7"
    127.0.0.1:6379> zrevrange yourkey 0 10 WITHSCORES
    1) "b"
    2) "7"
    3) "a"
    4) "5"
    5) "c"
    6) "4"
    127.0.0.1:6379>

`zrangebyscore key min max [WITHSCORES] [LIMIT offset count]：返回有序集合中分值介于min和max之间的所有成员，使用limit进行分页，offset设置偏移量即下标，count设置返回结果的数量`

`zervrangebyscore key min max [WITHSCORES] [LIMIT offset count]：返回有序集合中分值介于min和max之间的所有成员,并按照分值从大到小排序`

127.0.0.1:6379> zrangebyscore yourkey 0 10 withscores limit 0 10
    1) "c"
    2) "4"
    3) "a"
    4) "5"
    5) "b"
    6) "7"
    127.0.0.1:6379> zrangebyscore yourkey 0 10 withscores limit 1 3
    1) "a"
    2) "5"
    3) "b"
    4) "7"
    127.0.0.1:6379> zrangebyscore yourkey 0 10 withscores limit 0 3
    1) "c"
    2) "4"
    3) "a"
    4) "5"
    5) "b"
    6) "7"
    127.0.0.1:6379>

`zinterstore dest-key key-count key [key ... ] [WEIGHTS weight [weight]] [AGGREGATE SUM|MIN|MAX] ：对给定的有序集合执行类似于集合的交集运算，其中dest-key将交集存储的集合key，key-count表示要有几个集合求交集，key就是要求交集的集合key，weight表示为集合的分值乘以一个乘法因子，aggregate指定结果集的聚合方式，默认为sum即将分值相加`

`zunionstore dest-key key-count key [key ... ] [WEIGHTS weight [weight]] [AGGREGATE SUM|MIN|MAX] ：对给定的有序集合执行类似于集合的并集运算`

127.0.0.1:6379> zinterstore 13 2 12 yourkey
    (integer) 2
    127.0.0.1:6379> zrange 13 0 3 withscores
    1) "a"
    2) "2"
    3) "c"
    4) "4"
    127.0.0.1:6379> zinterstore 14 2 12 yourkey weights 2 3
    (integer) 2
    127.0.0.1:6379> zrange 14 0 3 withscores
    1) "a"
    2) "5"
    3) "c"
    4) "10"
    127.0.0.1:6379> zrange 12 0 10 withscores
    1) "a"
    2) "1"
    3) "c"
    4) "2"
    5) "g"
    6) "3"
    7) "h"
    8) "4"
    127.0.0.1:6379> zrange yourkey 0 10 withscores
     1) "a"
     2) "1"
     3) "c"
     4) "2"
     5) "d"
     6) "3"
     7) "f"
     8) "4"
     9) "b"
    10) "7"
    127.0.0.1:6379> zinterstore 15 2 12 yourkey weights 2 3 aggregate min
    (integer) 2
    127.0.0.1:6379> zrange 15 0 10 withscores
    1) "a"
    2) "2"
    3) "c"
    4) "4"

##  ##