5.1.3 NoSQL数据库-Redis（键值key-value）-五大数据类型

太过爱你忘了你带给我的痛 2023-01-02 14:26 204阅读 0赞

**目录**

1.写在前面

2.Redis-key

3.五大数据类型

3.1 String(字符串)

3.2 List(列表)

3.3 Set(集合)

3.4 Hash（哈希）

3.5 Zset（有序集合）

--------------------

# 1.写在前面 #

Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作**数据库**，**高速缓存**和**消息队列代理**。它支持[字符串][Link 1]、[哈希表][Link 2]、[列表][Link 3]、[集合][Link 4]、[有序集合][Link 5]，[位图][Link 1]，[hyperloglogs][]等数据类型。内置复制、[Lua脚本][Lua]、LRU收回、[事务][Link 6]以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动[分区][Link 7]。

# 2.Redis-key #

在redis中无论什么数据类型，在数据库中都是以key-value形式保存，通过进行对Redis-key的操作，来完成对数据库中数据的操作。

下面学习的命令(redis不区分大小写)：

*  **`exists key`**：判断键是否存在
 *  **`del key`**：删除键值对
 *  **`move key db`**：将键值对移动到指定数据库
 *  **`expire key second`**：设置键值对的过期时间
 *  **`type key`**：查看value的数据类型

127.0.0.1:6379> keys * # 查看当前数据库所有key
    (empty list or set)
    127.0.0.1:6379> set name qinjiang # set key
    OK
    127.0.0.1:6379> set age 20
    OK
    127.0.0.1:6379> keys *
    1) "age"
    2) "name"
    127.0.0.1:6379> move age 1 # 将键值对移动到指定数据库
    (integer) 1
    127.0.0.1:6379> EXISTS age # 判断键是否存在
    (integer) 0 # 不存在
    127.0.0.1:6379> EXISTS name
    (integer) 1 # 存在
    127.0.0.1:6379> SELECT 1
    OK
    127.0.0.1:6379[1]> keys *
    1) "age"
    127.0.0.1:6379[1]> del age # 删除键值对
    (integer) 1 # 删除个数
    
    
    127.0.0.1:6379> set age 20
    OK
    127.0.0.1:6379> EXPIRE age 15 # 设置键值对的过期时间
    
    (integer) 1 # 设置成功 开始计数
    127.0.0.1:6379> ttl age # 查看key的过期剩余时间
    (integer) 13
    127.0.0.1:6379> ttl age
    (integer) 11
    127.0.0.1:6379> ttl age
    (integer) 9
    127.0.0.1:6379> ttl age
    (integer) -2 # -2 表示key过期，-1表示key未设置过期时间
    
    127.0.0.1:6379> get age # 过期的key 会被自动delete
    (nil)
    127.0.0.1:6379> keys *
    1) "name"
    
    127.0.0.1:6379> type name # 查看value的数据类型
    string

**关于`TTL`命令**

Redis的key，通过TTL命令返回key的过期时间，一般来说有3种：

1.  当前key没有设置过期时间，所以会返回-1.
2.  当前key有设置过期时间，而且key已经过期，所以会返回-2.
3.  当前key有设置过期时间，且key还没有过期，故会返回key的正常剩余时间.

**关于重命名`RENAME`和`RENAMENX`**

*  `RENAME key newkey`修改 key 的名称
 *  `RENAMENX key newkey`仅当 newkey 不存在时，将 key 改名为 newkey

更多命令学习：https://www.redis.net.cn/order/

# 3.五大数据类型 #

## 3.1 String(字符串) ##

> String类似的使用场景：value除了是我们的字符串还可以是我们的数字！ 计数器、统计多单位的数量、粉丝数（uid:123666:follow 0）、对象缓存存储！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 6][]

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>APPEND key value</code></td> 
   <td>向指定的key的value后追加字符串</td> 
   <td>127.0.0.1:6379&gt; set msg hello OK 127.0.0.1:6379&gt; append msg " world" (integer) 11 127.0.0.1:6379&gt; get msg “hello world”</td> 
  </tr> 
  <tr> 
   <td><code>DECR/INCR key</code></td> 
   <td>将指定key的value数值进行-1/+1(仅对于数字)</td> 
   <td>127.0.0.1:6379&gt; set age 20 OK 127.0.0.1:6379&gt; incr age (integer) 21 127.0.0.1:6379&gt; decr age (integer) 20</td> 
  </tr> 
  <tr> 
   <td><code>INCRBY/DECRBY key n</code></td> 
   <td>按指定的步长对数值进行加减</td> 
   <td>127.0.0.1:6379&gt; INCRBY age 5 (integer) 25 127.0.0.1:6379&gt; DECRBY age 10 (integer) 15</td> 
  </tr> 
  <tr> 
   <td><code>INCRBYFLOAT key n</code></td> 
   <td>为数值加上浮点型数值</td> 
   <td>127.0.0.1:6379&gt; INCRBYFLOAT age 5.2 “20.2”</td> 
  </tr> 
  <tr> 
   <td><code>STRLEN key</code></td> 
   <td>获取key保存值的字符串长度</td> 
   <td>127.0.0.1:6379&gt; get msg “hello world” 127.0.0.1:6379&gt; STRLEN msg (integer) 11</td> 
  </tr> 
  <tr> 
   <td><code>GETRANGE key start end</code></td> 
   <td>按起止位置获取字符串（闭区间，起止位置都取）</td> 
   <td>127.0.0.1:6379&gt; get msg “hello world” 127.0.0.1:6379&gt; GETRANGE msg 3 9 “lo worl”</td> 
  </tr> 
  <tr> 
   <td><code>SETRANGE key offset value</code></td> 
   <td>用指定的value 替换key中 offset开始的值</td> 
   <td>127.0.0.1:6379&gt; SETRANGE msg 2 hello (integer) 7 127.0.0.1:6379&gt; get msg “tehello”</td> 
  </tr> 
  <tr> 
   <td><code>GETSET key value</code></td> 
   <td>将给定 key 的值设为 value ，并返回 key 的旧值(old value)。</td> 
   <td>127.0.0.1:6379&gt; GETSET msg test “hello world”</td> 
  </tr> 
  <tr> 
   <td><code>SETNX key value</code></td> 
   <td>仅当key不存在时进行set</td> 
   <td>127.0.0.1:6379&gt; SETNX msg test (integer) 0 127.0.0.1:6379&gt; SETNX name sakura (integer) 1</td> 
  </tr> 
  <tr> 
   <td><code>SETEX key seconds value</code></td> 
   <td>set 键值对并设置过期时间</td> 
   <td>127.0.0.1:6379&gt; setex name 10 root OK 127.0.0.1:6379&gt; get name (nil)</td> 
  </tr> 
  <tr> 
   <td><code>MSET key1 value1 [key2 value2..]</code></td> 
   <td>批量set键值对</td> 
   <td>127.0.0.1:6379&gt; MSET k1 v1 k2 v2 k3 v3 OK</td> 
  </tr> 
  <tr> 
   <td><code>MSETNX key1 value1 [key2 value2..]</code></td> 
   <td>批量设置键值对，仅当参数中所有的key都不存在时执行</td> 
   <td>127.0.0.1:6379&gt; MSETNX k1 v1 k4 v4 (integer) 0</td> 
  </tr> 
  <tr> 
   <td><code>MGET key1 [key2..]</code></td> 
   <td>批量获取多个key保存的值</td> 
   <td>127.0.0.1:6379&gt; MGET k1 k2 k3 1) “v1” 2) “v2” 3) “v3”</td> 
  </tr> 
  <tr> 
   <td><code>PSETEX key milliseconds value</code></td> 
   <td>和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>getset key value</code></td> 
   <td>如果不存在值，则返回nil，如果存在值，获取原来的值，并设置新的值</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

## 3.2 List(列表) ##

> Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
> 
> 一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。
> 
> 在redis中，list 可以经过规则定义将其变为队列、栈、双端队列等
> 
> Redis中List是可以进行双端操作的，所以命令也就分为了LXXX和RLLL两类，有时候L也表示List例如LLEN

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 15][]

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>LPUSH/RPUSH key value1[value2..]</code></td> 
   <td>从左边/右边向列表中PUSH值(一个或者多个)。</td> 
  </tr> 
  <tr> 
   <td><code>LRANGE key start end</code></td> 
   <td>获取list 起止元素==（索引从左往右 递增）==</td> 
  </tr> 
  <tr> 
   <td><code>LPUSHX/RPUSHX key value</code></td> 
   <td>向已存在的列名中push值（一个或者多个）</td> 
  </tr> 
  <tr> 
   <td><code>LINSERT key BEFORE|AFTER pivot value</code></td> 
   <td>在指定列表元素的前/后 插入value</td> 
  </tr> 
  <tr> 
   <td><code>LLEN key</code></td> 
   <td>查看列表长度</td> 
  </tr> 
  <tr> 
   <td><code>LINDEX key index</code></td> 
   <td>通过索引获取列表元素</td> 
  </tr> 
  <tr> 
   <td><code>LSET key index value</code></td> 
   <td>通过索引为元素设值</td> 
  </tr> 
  <tr> 
   <td><code>LPOP/RPOP key</code></td> 
   <td>从最左边/最右边移除值 并返回</td> 
  </tr> 
  <tr> 
   <td><code>RPOPLPUSH source destination</code></td> 
   <td>将列表的尾部(右)最后一个值弹出，并返回，然后加到另一个列表的头部</td> 
  </tr> 
  <tr> 
   <td><code>LTRIM key start end</code></td> 
   <td>通过下标截取指定范围内的列表</td> 
  </tr> 
  <tr> 
   <td><code>LREM key count value</code></td> 
   <td>List中是允许value重复的&nbsp;<code>count &gt; 0</code>：从头部开始搜索 然后删除指定的value 至多删除count个&nbsp;<code>count &lt; 0</code>：从尾部开始搜索…&nbsp;<code>count = 0</code>：删除列表中所有的指定value。</td> 
  </tr> 
  <tr> 
   <td><code>BLPOP/BRPOP key1[key2] timout</code></td> 
   <td>移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td><code>BRPOPLPUSH source destination timeout</code></td> 
   <td>和<code>RPOPLPUSH</code>功能相同，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
 </tbody> 
</table>

> 小结

*  list实际上是一个链表，before Node after , left, right 都可以插入值
 *  **如果key不存在，则创建新的链表**
 *  如果key存在，新增内容
 *  如果移除了所有值，空链表，也代表不存在
 *  在两边插入或者改动值，效率最高！修改中间元素，效率相对较低
 *  **应用：消息排队！消息队列（Lpush Rpop）,栈（Lpush Lpop）**

## 3.3 Set(集合) ##

> Redis的Set是**string类型**的**无序集合**。集合成员是唯一的，这就意味着**集合中不能出现重复的数据**。
> 
> Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
> 
> 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

<table> 
 <thead> 
  <tr> 
   <th>命令（key表示一个set的名字）</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>SADD key member1[member2..]</code></td> 
   <td>向集合中无序增加一个/多个成员</td> 
  </tr> 
  <tr> 
   <td><code>SCARD key</code></td> 
   <td>获取集合的成员数</td> 
  </tr> 
  <tr> 
   <td><code>SMEMBERS key</code></td> 
   <td>返回集合中所有的成员</td> 
  </tr> 
  <tr> 
   <td><code>SISMEMBER key member</code></td> 
   <td>查询member元素是否是集合的成员,结果是无序的</td> 
  </tr> 
  <tr> 
   <td><code>SRANDMEMBER key [count]</code></td> 
   <td>随机返回集合中count个成员，count缺省值为1</td> 
  </tr> 
  <tr> 
   <td><code>SPOP key [count]</code></td> 
   <td>随机移除并返回集合中count个成员，count缺省值为1</td> 
  </tr> 
  <tr> 
   <td><code>SMOVE source destination member</code></td> 
   <td>将source集合的成员member移动到destination集合</td> 
  </tr> 
  <tr> 
   <td><code>SREM key member1[member2..]</code></td> 
   <td>移除集合中一个/多个成员</td> 
  </tr> 
  <tr> 
   <td><code>SDIFF key1[key2..]</code></td> 
   <td>返回所有集合的差集 key1- key2 - …</td> 
  </tr> 
  <tr> 
   <td><code>SDIFFSTORE destination key1[key2..]</code></td> 
   <td>在SDIFF的基础上，将结果保存到集合中==(覆盖)==。不能保存到其他类型key噢！</td> 
  </tr> 
  <tr> 
   <td><code>SINTER key1 [key2..]</code></td> 
   <td>返回所有集合的交集</td> 
  </tr> 
  <tr> 
   <td><code>SINTERSTORE destination key1[key2..]</code></td> 
   <td>在SINTER的基础上，存储结果到集合中。覆盖</td> 
  </tr> 
  <tr> 
   <td><code>SUNION key1 [key2..]</code></td> 
   <td>返回所有集合的并集</td> 
  </tr> 
  <tr> 
   <td><code>SUNIONSTORE destination key1 [key2..]</code></td> 
   <td>在SUNION的基础上，存储结果到及和张。覆盖</td> 
  </tr> 
  <tr> 
   <td><code>SSCAN KEY [MATCH pattern] [COUNT count]</code></td> 
   <td>在大量数据环境下，使用此命令遍历集合中元素，每次遍历部分</td> 
  </tr> 
 </tbody> 
</table>

---------------SADD--SCARD--SMEMBERS--SISMEMBER--------------------
    
    127.0.0.1:6379> SADD myset m1 m2 m3 m4 # 向myset中增加成员 m1~m4
    (integer) 4
    127.0.0.1:6379> SCARD myset # 获取集合的成员数目
    (integer) 4
    127.0.0.1:6379> smembers myset # 获取集合中所有成员
    1) "m4"
    2) "m3"
    3) "m2"
    4) "m1"
    127.0.0.1:6379> SISMEMBER myset m5 # 查询m5是否是myset的成员
    (integer) 0 # 不是，返回0
    127.0.0.1:6379> SISMEMBER myset m2
    (integer) 1 # 是，返回1
    127.0.0.1:6379> SISMEMBER myset m3
    (integer) 1
    
    ---------------------SRANDMEMBER--SPOP----------------------------------
    
    127.0.0.1:6379> SRANDMEMBER myset 3 # 随机返回3个成员
    1) "m2"
    2) "m3"
    3) "m4"
    127.0.0.1:6379> SRANDMEMBER myset # 随机返回1个成员
    "m3"
    127.0.0.1:6379> SPOP myset 2 # 随机移除并返回2个成员
    1) "m1"
    2) "m4"
    # 将set还原到{m1,m2,m3,m4}
    
    ---------------------SMOVE--SREM----------------------------------------
    
    127.0.0.1:6379> SMOVE myset newset m3 # 将myset中m3成员移动到newset集合
    (integer) 1
    127.0.0.1:6379> SMEMBERS myset
    1) "m4"
    2) "m2"
    3) "m1"
    127.0.0.1:6379> SMEMBERS newset
    1) "m3"
    127.0.0.1:6379> SREM newset m3 # 从newset中移除m3元素
    (integer) 1
    127.0.0.1:6379> SMEMBERS newset
    (empty list or set)
    
    # 下面开始是多集合操作,多集合操作中若只有一个参数默认和自身进行运算
    # setx=>{m1,m2,m4,m6}, sety=>{m2,m5,m6}, setz=>{m1,m3,m6}
    
    -----------------------------SDIFF------------------------------------
    
    127.0.0.1:6379> SDIFF setx sety setz # 等价于setx-sety-setz
    1) "m4"
    127.0.0.1:6379> SDIFF setx sety # setx - sety
    1) "m4"
    2) "m1"
    127.0.0.1:6379> SDIFF sety setx # sety - setx
    1) "m5"
    
    
    -------------------------SINTER---------------------------------------
    # 共同关注（交集）
    
    127.0.0.1:6379> SINTER setx sety setz # 求 setx、sety、setx的交集
    1) "m6"
    127.0.0.1:6379> SINTER setx sety # 求setx sety的交集
    1) "m2"
    2) "m6"
    
    -------------------------SUNION---------------------------------------
    
    127.0.0.1:6379> SUNION setx sety setz # setx sety setz的并集
    1) "m4"
    2) "m6"
    3) "m3"
    4) "m2"
    5) "m1"
    6) "m5"
    127.0.0.1:6379> SUNION setx sety # setx sety 并集
    1) "m4"
    2) "m6"
    3) "m2"
    4) "m1"
    5) "m5"

## 3.4 Hash（哈希） ##

> Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
> 
> Set就是一种简化的Hash,只变动key,而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息。
> 
> **Hash更适合于对象的存储，Sring更加适合字符串存储！（本质没有太大区别）**

<table> 
 <thead> 
  <tr> 
   <th>命令（<code>key是hash的名字</code>）</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>HSET key field value</code></td> 
   <td>将哈希表 key 中的字段 field 的值设为 value 。重复设置同一个field会覆盖,返回0</td> 
  </tr> 
  <tr> 
   <td><code>HMSET key field1 value1 [field2 value2..]</code></td> 
   <td>同时将多个 field-value (域-值)对设置到哈希表 key 中。</td> 
  </tr> 
  <tr> 
   <td><code>HSETNX key field value</code></td> 
   <td>只有在字段 field 不存在时，设置哈希表字段的值。</td> 
  </tr> 
  <tr> 
   <td><code>HEXISTS key field</code></td> 
   <td>查看哈希表 key 中，指定的字段是否存在。</td> 
  </tr> 
  <tr> 
   <td><code>HGET key field value</code></td> 
   <td>获取存储在哈希表中指定字段的值</td> 
  </tr> 
  <tr> 
   <td><code>HMGET key field1 [field2..]</code></td> 
   <td>获取所有给定字段的值</td> 
  </tr> 
  <tr> 
   <td><code>HGETALL key</code></td> 
   <td>获取在哈希表key 的所有字段和值</td> 
  </tr> 
  <tr> 
   <td><code>HKEYS key</code></td> 
   <td>获取哈希表key中所有的字段</td> 
  </tr> 
  <tr> 
   <td><code>HLEN key</code></td> 
   <td>获取哈希表中字段的数量</td> 
  </tr> 
  <tr> 
   <td><code>HVALS key</code></td> 
   <td>获取哈希表中所有值</td> 
  </tr> 
  <tr> 
   <td><code>HDEL key field1 [field2..]</code></td> 
   <td>删除哈希表key中一个/多个field字段</td> 
  </tr> 
  <tr> 
   <td><code>HINCRBY key field n</code></td> 
   <td>为哈希表 key 中的指定字段的整数值加上增量n，并返回增量后结果 一样只适用于整数型字段</td> 
  </tr> 
  <tr> 
   <td><code>HINCRBYFLOAT key field n</code></td> 
   <td>为哈希表 key 中的指定字段的浮点数值加上增量 n。</td> 
  </tr> 
  <tr> 
   <td><code>HSCAN key cursor [MATCH pattern] [COUNT count]</code></td> 
   <td>迭代哈希表中的键值对。</td> 
  </tr> 
 </tbody> 
</table>

------------------------HSET--HMSET--HSETNX----------------
    127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象，设置name为sakura
    (integer) 1
    127.0.0.1:6379> HSET studentx name gyc # 重复设置field进行覆盖，并返回0
    (integer) 0
    127.0.0.1:6379> HSET studentx age 20 # 设置studentx的age为20
    (integer) 1
    127.0.0.1:6379> HMSET studentx sex 1 tel 15623667886 # 设置sex为1，tel为15623667886
    OK
    127.0.0.1:6379> HSETNX studentx name gyc # HSETNX 设置已存在的field
    (integer) 0 # 失败
    127.0.0.1:6379> HSETNX studentx email 12345@qq.com
    (integer) 1 # 成功
    
    ----------------------HEXISTS--------------------------------
    127.0.0.1:6379> HEXISTS studentx name # name字段在studentx中是否存在
    (integer) 1 # 存在
    127.0.0.1:6379> HEXISTS studentx addr
    (integer) 0 # 不存在
    
    -------------------HGET--HMGET--HGETALL-----------
    127.0.0.1:6379> HGET studentx name # 获取studentx中name字段的value
    "gyc"
    127.0.0.1:6379> HMGET studentx name age tel # 获取studentx中name、age、tel字段的value
    1) "gyc"
    2) "20"
    3) "15623667886"
    127.0.0.1:6379> HGETALL studentx # 获取studentx中所有的field及其value
     1) "name"
     2) "gyc"
     3) "age"
     4) "20"
     5) "sex"
     6) "1"
     7) "tel"
     8) "15623667886"
     9) "email"
    10) "12345@qq.com"
    
    
    --------------------HKEYS--HLEN--HVALS--------------
    127.0.0.1:6379> HKEYS studentx # 查看studentx中所有的field
    1) "name"
    2) "age"
    3) "sex"
    4) "tel"
    5) "email"
    127.0.0.1:6379> HLEN studentx # 查看studentx中的字段数量
    (integer) 5
    127.0.0.1:6379> HVALS studentx # 查看studentx中所有的value
    1) "gyc"
    2) "20"
    3) "1"
    4) "15623667886"
    5) "12345@qq.com"
    
    -------------------------HDEL--------------------------
    127.0.0.1:6379> HDEL studentx sex tel # 删除studentx 中的sex、tel字段
    (integer) 2
    127.0.0.1:6379> HKEYS studentx
    1) "name"
    2) "age"
    3) "email"
    
    -------------HINCRBY--HINCRBYFLOAT------------------------
    127.0.0.1:6379> HINCRBY studentx age 1 # studentx的age字段数值+1
    (integer) 21
    127.0.0.1:6379> HINCRBY studentx name 1 # 非整数字型字段不可用
    (error) ERR hash value is not an integer
    127.0.0.1:6379> HINCRBYFLOAT studentx weight 0.6 # weight字段增加0.6
    "90.8"

## 3.5 Zset（有序集合） ##

> 不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序。
> 
> score相同：按字典顺序排序
> 
> 有序集合的成员是唯一的,但分数(score)却可以重复。

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>ZADD key score member1 [score2 member2]</code></td> 
   <td>向有序集合添加一个或多个成员，或者更新已存在成员的分数</td> 
  </tr> 
  <tr> 
   <td><code>ZCARD key</code></td> 
   <td>获取有序集合的成员数</td> 
  </tr> 
  <tr> 
   <td><code>ZCOUNT key min max</code></td> 
   <td>计算在有序集合中指定区间score的成员数</td> 
  </tr> 
  <tr> 
   <td><code>ZINCRBY key n member</code></td> 
   <td>有序集合中对指定成员的分数加上增量 n</td> 
  </tr> 
  <tr> 
   <td><code>ZSCORE key member</code></td> 
   <td>返回有序集中，成员的分数值</td> 
  </tr> 
  <tr> 
   <td><code>ZRANK key member</code></td> 
   <td>返回有序集合中指定成员的索引</td> 
  </tr> 
  <tr> 
   <td><code>ZRANGE key start end</code></td> 
   <td>通过索引区间返回有序集合成指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td><code>ZRANGEBYLEX key min max</code></td> 
   <td>通过字典区间返回有序集合的成员</td> 
  </tr> 
  <tr> 
   <td><code>ZRANGEBYSCORE key min max</code></td> 
   <td>通过分数返回有序集合指定区间内的成员==-inf 和 +inf分别表示最小最大值，只支持开区间()==</td> 
  </tr> 
  <tr> 
   <td><code>ZLEXCOUNT key min max</code></td> 
   <td>在有序集合中计算指定字典区间内成员数量</td> 
  </tr> 
  <tr> 
   <td><code>ZREM key member1 [member2..]</code></td> 
   <td>移除有序集合中一个/多个成员</td> 
  </tr> 
  <tr> 
   <td><code>ZREMRANGEBYLEX key min max</code></td> 
   <td>移除有序集合中给定的字典区间的所有成员</td> 
  </tr> 
  <tr> 
   <td><code>ZREMRANGEBYRANK key start stop</code></td> 
   <td>移除有序集合中给定的排名区间的所有成员</td> 
  </tr> 
  <tr> 
   <td><code>ZREMRANGEBYSCORE key min max</code></td> 
   <td>移除有序集合中给定的分数区间的所有成员</td> 
  </tr> 
  <tr> 
   <td><code>ZREVRANGE key start end</code></td> 
   <td>返回有序集中指定区间内的成员，通过索引，分数从高到底</td> 
  </tr> 
  <tr> 
   <td><code>ZREVRANGEBYSCORRE key max min</code></td> 
   <td>返回有序集中指定分数区间内的成员，分数从高到低排序</td> 
  </tr> 
  <tr> 
   <td><code>ZREVRANGEBYLEX key max min</code></td> 
   <td>返回有序集中指定字典区间内的成员，按字典顺序倒序</td> 
  </tr> 
  <tr> 
   <td><code>ZREVRANK key member</code></td> 
   <td>返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序</td> 
  </tr> 
  <tr> 
   <td><code>ZINTERSTORE destination numkeys key1 [key2 ..]</code></td> 
   <td>计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中，numkeys：表示参与运算的集合数，将score相加作为结果的score</td> 
  </tr> 
  <tr> 
   <td><code>ZUNIONSTORE destination numkeys key1 [key2..]</code></td> 
   <td>计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中</td> 
  </tr> 
  <tr> 
   <td><code>ZSCAN key cursor [MATCH pattern\] [COUNT count]</code></td> 
   <td>迭代有序集合中的元素（包括元素成员和元素分值）</td> 
  </tr> 
 </tbody> 
</table>

-------------------ZADD--ZCARD--ZCOUNT--------------
    127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2..
    (integer) 2
    127.0.0.1:6379> ZCARD myzset # 获取有序集合的成员数
    (integer) 2
    127.0.0.1:6379> ZCOUNT myzset 0 1 # 获取score在 [0,1]区间的成员数量
    (integer) 1
    127.0.0.1:6379> ZCOUNT myzset 0 2
    (integer) 2
    
    ----------------ZINCRBY--ZSCORE--------------------------
    127.0.0.1:6379> ZINCRBY myzset 5 m2 # 将成员m2的score +5
    "7"
    127.0.0.1:6379> ZSCORE myzset m1 # 获取成员m1的score
    "1"
    127.0.0.1:6379> ZSCORE myzset m2
    "7"
    
    --------------ZRANK--ZRANGE-----------------------------------
    127.0.0.1:6379> ZRANK myzset m1 # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
    (integer) 0
    127.0.0.1:6379> ZRANK myzset m2
    (integer) 2
    127.0.0.1:6379> ZRANGE myzset 0 1 # 获取索引在 0~1的成员
    1) "m1"
    2) "m3"
    127.0.0.1:6379> ZRANGE myzset 0 -1 # 获取全部成员
    1) "m1"
    2) "m3"
    3) "m2"
    
    #testset=>{abc,add,amaze,apple,back,java,redis} score均为0
    ------------------ZRANGEBYLEX---------------------------------
    127.0.0.1:6379> ZRANGEBYLEX testset - + # 返回所有成员
    1) "abc"
    2) "add"
    3) "amaze"
    4) "apple"
    5) "back"
    6) "java"
    7) "redis"
    127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 # 分页 按索引显示查询结果的 0,1,2条记录
    1) "abc"
    2) "add"
    3) "amaze"
    127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 # 显示 3,4,5条记录
    1) "apple"
    2) "back"
    3) "java"
    127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
    1) "abc"
    2) "add"
    3) "amaze"
    4) "apple"
    127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
    1) "apple"
    2) "back"
    3) "java"
    
    -----------------------ZRANGEBYSCORE---------------------
    127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 # 返回score在 [1,10]之间的的成员
    1) "m1"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
    1) "m1"
    2) "m3"
    
    --------------------ZLEXCOUNT-----------------------------
    127.0.0.1:6379> ZLEXCOUNT testset - +
    (integer) 7
    127.0.0.1:6379> ZLEXCOUNT testset [apple [java
    (integer) 3
    
    ------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
    127.0.0.1:6379> ZREM testset abc # 移除成员abc
    (integer) 1
    127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java # 移除字典区间[apple,java]中的所有成员
    (integer) 3
    127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1 # 移除排名0~1的所有成员
    (integer) 2
    127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 # 移除score在 [0,3]的成员
    (integer) 2
    
    
    # testset=> {abc,add,apple,amaze,back,java,redis} score均为0
    # myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
    ----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
    127.0.0.1:6379> ZREVRANGE myzset 0 3 # 按score递减排序，然后按索引，返回结果的 0~3
    1) "m9"
    2) "m7"
    3) "m4"
    4) "m3"
    127.0.0.1:6379> ZREVRANGE myzset 2 4 # 返回排序结果的 索引的2~4
    1) "m4"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
    1) "m4"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add # 按字典倒序 返回集合中(add,java]字典区间的成员
    1) "java"
    2) "back"
    3) "apple"
    4) "amaze"
    
    -------------------------ZREVRANK------------------------------
    127.0.0.1:6379> ZREVRANK myzset m7 # 按score递减顺序，返回成员m7索引
    (integer) 1
    127.0.0.1:6379> ZREVRANK myzset m2
    (integer) 4
    
    
    # mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
    # enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
    -------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
    127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore # 将mathscore enscore进行合并 结果存放到sumscore
    (integer) 3
    127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores # 合并后的score是之前集合中所有score的和
    1) "xm"
    2) "160"
    3) "xg"
    4) "177"
    5) "xh"
    6) "188"
    
    127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
    (integer) 3
    127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
    1) "xm"
    2) "70"
    3) "xg"
    4) "87"
    5) "xh"
    6) "93"

应用案例：

*  set排序 存储班级成绩表 工资表排序！
 *  普通消息，1.重要消息 2.带权重进行判断
 *  排行榜应用实现，取Top N测试

[Link 1]: https://www.redis.net.cn/tutorial/3508.html
[Link 2]: https://www.redis.net.cn/tutorial/3509.html
[Link 3]: https://www.redis.net.cn/tutorial/3510.html
[Link 4]: https://www.redis.net.cn/tutorial/3511.html
[Link 5]: https://www.redis.net.cn/tutorial/3512.html
[hyperloglogs]: https://www.redis.net.cn/tutorial/3513.html
[Lua]: https://www.redis.net.cn/tutorial/3516.html
[Link 6]: https://www.redis.net.cn/tutorial/3515.html
[Link 7]: https://www.redis.net.cn/tutorial/3524.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70]: /images/20221119/4ed111dd122441f2924997557c4c200f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 1]: /images/20221119/008898ad45784d588e012433af26d5aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 2]: /images/20221119/4bf4c738a6504d068bfafe224c158028.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 3]: /images/20221119/a4387f14d30e437dbd73ca3e35369b2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 4]: /images/20221119/d320c2e69d8e4ffdaecf0f9fb92748c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 5]: /images/20221119/49ac0b5643824485ae1dd71e09a27bc4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 6]: /images/20221119/d2b078880e1340d6bc849ad87e70f266.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 7]: /images/20221119/8c68787a5baf4ed981a449f5d31175bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 8]: /images/20221119/83823bc297e34843aae06c292de9676b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 9]: /images/20221119/6702225c361c43489f8bbcf8a7e0940b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 10]: /images/20221119/ccf2b5cd43444d4c97dc01e012bc3c87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 11]: /images/20221119/40f7b7681433432e8fd9f6ae067a4a75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 12]: /images/20221119/499e75028fe44a3bbf9f590feaabae4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 13]: /images/20221119/c0225405a30447cbaf37a1d3f7014fd8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 14]: /images/20221119/93b890cf10d64ac2a8b37c12d7daef73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N1eWViaXViaXU_size_16_color_FFFFFF_t_70 15]: /images/20221119/1804585f79ad408c934c5a54560e2ca5.png