Redis命令详解

た入场券 2024-02-18 11:20 53阅读 0赞

#### 文章目录 ####

*  Key（键）
 *   *  · DEL
     *  · EXISTS
     *  · EXPIRE
     *  · EXPIREAT
     *  · PEXPIRE
     *  · PEXPIREAT
     *  · PERSIST
     *  · KEYS
     *  · TTL
     *  · PTTL
     *  · RENAME
     *  · RENAMENX
     *  · TYPE
     *  · SCAN
     *  · HSCAN
     *  · SSCAN
     *  · ZSCAN
     *  · DUMP
 *  String（字符串）
 *   *  · SET
     *  · GET
     *  · INCR
     *  · DECR
     *  · MSET
     *  · MGET
     *  · APPEND
     *  · SETNX
     *  · STRLEN
     *  · INCRBY
     *  · DECRBY
     *  · INCRBYFLOAT
     *  · GETSET
     *  · MSETNX
     *  · SETEX
     *  · PSETEX
 *  Hash（哈希）
 *   *  · HSET
     *  · HGET
     *  · HGETALL
     *  · HDEL
     *  · HSETNX
     *  · HMSET
     *  · HINCRBY
     *  · HKEYS
     *  · HLEN
     *  · HVALS
 *  List（列表）
 *   *  · LPUSH
     *  · RPUSH
     *  · LPUSHX
     *  · RPUSHX
     *  · LPOP
     *  · RPOP
     *  · BLPOP
     *  · BRPOP
     *  · LTRIM
     *  · RPOPLPUSH
     *  · BRPOPLPUSH
     *  · LRANGE
     *  · LLEN
     *  · LINDEX
     *  · LINSERT
     *  · LSET
     *  · LREM
 *  Set（集合）
 *   *  · SADD
     *  · SMOVE
     *  · SCARD
     *  · SMEMBERS
     *  · SISMEMBER
     *  · SRANDMEMBER
     *  · SDIFF
     *  · SDIFFSTORE
     *  · SINTER
     *  · SINTERSTORE
     *  · SUNION
     *  · SUNIONSTORE
     *  · SREM
     *  · SPOP
 *  Zset（有序集合）
 *   *  · ZADD
     *  · ZINCRBY
     *  · ZREM
     *  · ZREMRANGEBYRANK
     *  · ZREMRANGEBYSCORE
     *  · ZCARD
     *  · ZCOUNT
     *  · ZRANGE
     *  · ZRANGEBYSCORE
     *  · ZRANK
     *  · ZREVRANGE
     *  · ZREVRANGEBYSCORE
     *  · ZREVRANK
     *  · ZSCORE
     *  · ZLEXCOUNT
     *  · ZRANGEBYLEX
     *  · ZREMRANGEBYLEX
     *  · ZINTERSTORE
     *  · ZUNIONSTORE
 *  Stream（流）
 *   *  · XADD
     *  · XTRIM
     *  · XDEL
     *  · XLEN
     *  · XRANGE
     *  · XREVRANGE
     *  · XREAD
     *  · XGROUP CREATE
     *  · XREADGROUP GROUP
     *  · XACK
     *  · XGROUP SETID
     *  · XGROUP DELCONSUMER
     *  · XGROUP DESTROY
     *  · XPENDING
     *  · XINFO GROUPS
     *  · XINFO STREAM
 *  Pub/Sub（发布/订阅）
 *   *  · PUBLISH
     *  · SUBSCRIBE
     *  · PSUBSCRIBE
     *  · UNSUBSCRIBE
     *  · PUNSUBSCRIBE
     *  · PUBSUB
 *  Bitmap（位图）
 *   *  · SETBIT
     *  · GETBIT
     *  · BITCOUNT
     *  · BITOP
     *  · BITPOS
     *  · BITFIELD
 *  Bloom Filter（布隆过滤器）
 *   *  · BF.ADD
     *  · BF.MADD
     *  · BF.EXISTS
     *  · BF.MEXISTS
     *  · BF.INFO
     *  · BF.INSERT
     *  · BF.RESRVE
     *  · BF.SCANDUMP
     *  · BF.LOADCHUNK
 *  HyperLogLog（基数估计）
 *   *  · PFADD
     *  · PFCOUNT
     *  · PFMERGE
 *  Geospatial（地理空间）
 *   *  · GEOADD
     *  · GEOPOS
     *  · GEOHASH
     *  · GEODIST
     *  · GEORADIUS
     *  · GEORADIUSBYMEMBER
 *  Transaction（事务）
 *  Scripting（LUA脚本）

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

## Key（键） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">DEL</td> 
   <td align="left">删除存储在数据库中的一个或多个键</td> 
   <td align="left">DEL key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">EXISTS</td> 
   <td align="left">检查给定键是否存在</td> 
   <td align="left">EXISTS key</td> 
  </tr> 
  <tr> 
   <td align="left">EXPIRE</td> 
   <td align="left">设置键的过期时间</td> 
   <td align="left">EXPIRE key seconds</td> 
  </tr> 
  <tr> 
   <td align="left">EXPIREAT</td> 
   <td align="left">设置键的过期时间，该过期时间是一个秒级时间戳</td> 
   <td align="left">EXPIREAT key timestamp</td> 
  </tr> 
  <tr> 
   <td align="left">PEXPIRE</td> 
   <td align="left">设置键的过期时间，以毫秒为单位。</td> 
   <td align="left">PEXPIRE key milliseconds</td> 
  </tr> 
  <tr> 
   <td align="left">PEXPIREAT</td> 
   <td align="left">设置键的过期时间，该过期时间是一个毫秒级时间戳</td> 
   <td align="left">PEXPIREAT key milliseconds-timestamp</td> 
  </tr> 
  <tr> 
   <td align="left">PERSIST</td> 
   <td align="left">移除键的过期时间</td> 
   <td align="left">PERSIST key</td> 
  </tr> 
  <tr> 
   <td align="left">KEYS</td> 
   <td align="left">获取匹配指定模式的所有键名</td> 
   <td align="left">KEYS pattern</td> 
  </tr> 
  <tr> 
   <td align="left">TTL</td> 
   <td align="left">获取键的剩余过期时间，以秒为单位</td> 
   <td align="left">TTL key</td> 
  </tr> 
  <tr> 
   <td align="left">PTTL</td> 
   <td align="left">获取键的剩余过期时间，以毫秒为单位</td> 
   <td align="left">PTTL key</td> 
  </tr> 
  <tr> 
   <td align="left">RENAME</td> 
   <td align="left">修改键的名称</td> 
   <td align="left">RENAME key newkey</td> 
  </tr> 
  <tr> 
   <td align="left">RENAMENX</td> 
   <td align="left">修改键的名称，在不覆盖现有键的前提下</td> 
   <td align="left">RENAMENX key newkey</td> 
  </tr> 
  <tr> 
   <td align="left">TYPE</td> 
   <td align="left">获取键存储的值的数据类型</td> 
   <td align="left">TYPE key</td> 
  </tr> 
  <tr> 
   <td align="left">SCAN</td> 
   <td align="left">迭代遍历 Redis 数据库中的键集合</td> 
   <td align="left">SCAN cursor [MATCH pattern] [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">HSCAN</td> 
   <td align="left">迭代遍历 Redis Hash类型中的字段和对应的值</td> 
   <td align="left">HSCAN key cursor [MATCH pattern] [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">SSCAN</td> 
   <td align="left">迭代遍历 Redis Set集合中的元素</td> 
   <td align="left">SSCAN key cursor [MATCH pattern] [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">ZSCAN</td> 
   <td align="left">迭代遍历 Redis Zset集合中的成员和对应的分值</td> 
   <td align="left">ZSCAN key cursor [MATCH pattern] [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">DUMP</td> 
   <td align="left">序列化给定键的值，并以字符串的形式返回序列化后的值</td> 
   <td align="left">DUMP key</td> 
  </tr> 
 </tbody> 
</table>

### · DEL ###

删除存储在数据库中的一个或多个键。

**语法：**  
DEL key \[key …\]

**参数：**

*  key: 要删除的键的名称。

**返回：**  
DEL 命令返回一个整数值，表示被成功删除的键的数量。

**示例：**

DEL mykey1

删除名为 “mykey1” 的键，并返回值为 1，表示成功删除了一个键。

DEL mykey2 mykey3

删除名为 “mykey2” 和 “mykey3” 的两个键，并返回值为 2，表示成功删除了两个键。

### · EXISTS ###

用于检查给定键是否存在于 Redis 数据库中。该命令的作用类似于在编程语言中使用的检查特定变量是否已定义。

**语法：**  
EXISTS key

**参数：**

*  key: 要检查的键名。

**返回：**  
如果键存在，则 EXISTS 命令返回 1，否则返回 0。

**示例：**

EXISTS mykey

### · EXPIRE ###

用于为一个键设置过期时间。一旦设置了过期时间，键将在一定时间内自动过期，Redis 将删除这个键及其关联的值。

**语法：**  
EXPIRE key seconds

**参数：**

*  key: 要设置过期时间的键名。
 *  seconds: 时间戳，指定键的过期时间（以秒为单位）。

**返回：**  
执行 EXPIRE 命令后，如果过期时间设置成功，则返回 1，否则返回 0（因为此时键不存在或不能设置过期时间）。

**示例：**

EXPIRE mykey 60

设置mykey”键的过期时间为 60 秒。

### · EXPIREAT ###

用于设置一个键的过期时间，该过期时间是一个秒级时间戳，表示在指定的时间点该键将过期。

**语法：**  
EXPIREAT key timestamp

**参数：**

*  key：要设置过期时间的键名。
 *  timestamp：过期时间戳，以秒为单位。

**返回：**  
如果成功设置过期时间，则返回 1；如果键不存在或无法设置过期时间，则返回 0。

**示例：**

EXPIREAT mykey 1700294260

需要注意的是，如果键已经存在并具有过期时间，则 EXPIREAT 命令将覆盖原有的过期时间。另外，需要确保 timestamp 参数的值大于当前 Redis 服务器的时间，否则命令执行时将无法设置过期时间。

### · PEXPIRE ###

设置一个键的过期时间，以毫秒为单位。

**语法：**  
PEXPIRE key milliseconds

**参数：**

*  key：要设置过期时间的键名。
 *  milliseconds：毫秒数，表示键在指定的时间段后过期。

**返回：**  
如果成功设置过期时间，则返回 1；如果键不存在或无法设置过期时间，则返回 0。

**示例：**

PEXPIRE mykey 500

将键名为 “mykey” 的键设置为 500 毫秒后过期。

需要注意的是，如果键已经存在并具有过期时间，则 PEXPIRE 命令将更新原有的过期时间。另外，需要确保 milliseconds 参数的值大于 0，否则键将立即过期。如果键在设置过期时间之前就被删除或修改了，那么 PEXPIRE 命令将返回 0，表示无法设置过期时间。

### · PEXPIREAT ###

设置一个键的过期时间，该过期时间是一个毫秒级时间戳，表示在指定的时间点该键将过期。与 EXPIREAT 命令相比，PEXPIREAT 命令使用毫秒级的时间戳。

**语法：**  
PEXPIREAT key milliseconds-timestamp

**参数：**

*  key：要设置过期时间的键名。
 *  milliseconds-timestamp：毫秒级的过期时间戳。

**返回：**

如果成功设置过期时间，则返回 1；如果键不存在或无法设置过期时间，则返回 0。

**示例：**

PEXPIREAT mykey 1700294260000

需要注意的是，如果键已经存在并具有过期时间，则 PEXPIREAT 命令将覆盖原有的过期时间。另外，需要确保 milliseconds-timestamp 参数的值大于当前 Redis 服务器的时间，否则命令执行时将无法设置过期时间。

### · PERSIST ###

移除键的过期时间，使键持久化，即永远不会过期。

**语法：**  
PERSIST key

**参数：**

*  key：要移除过期时间的键名。

**返回：**  
如果成功移除过期时间，则返回 1；如果键不存在过期时间或无法移除过期时间，则返回 0。

**示例：**

PERSIST mykey

需要注意的是，如果键不存在过期时间，即键本身就是持久化的，或者键不存在，PERSIST 命令将返回 0。另外，一旦过期时间被移除，该键将永远不会过期，除非显式地设置新的过期时间。

### · KEYS ###

用于获取匹配指定模式的所有键名。这个命令是非常强大的，但在生产环境中使用时需要小心，因为它会遍历整个键空间并返回所有匹配的键名。在大型数据库中使用 KEYS 命令可能会导致性能问题。

**语法：**  
KEYS pattern

**参数：**

*  pattern: 要匹配的模式：支持通配符 \*（表示零个或多个字符）和 ?（表示一个字符）。

**返回：**  
返回一个数组，包含所有匹配模式的键名。

**示例：**

KEYS key*

获取所有以 “key” 开头的键名。

需要注意：KEYS 命令会遍历整个 Redis 数据库，如果数据库非常大，执行这个命令可能会导致性能问题。因此，在生产环境中使用 KEYS 命令时，应该谨慎评估其使用场景，并考虑使用其他更高的命令来实现更，如 SCAN 命令。 SCAN 命令可以分批地迭代集合中的键，避免一次性处理大。

### · TTL ###

获取键的剩余过期时间，以秒为单位。

**语法：**  
TTL key

**参数：**

*  key：要获取剩余过期时间的键名。

**返回：**

*  当键存在且具有过期时间时，返回剩余过期时间的秒数。
 *  当键不存在或键不存在过期时间时，返回 -1。
 *  当键存在但没有设置过期时间时，返回 -1。

**示例：**

TTL mykey

需要注意的是，TTL 命令的返回值是以秒为单位的。如果需要以毫秒为单位获取剩余过期时间，可以使用 PTTL 命令。同时，当键过期时，TTL 命令将返回 -2，表示键已经被删除。

### · PTTL ###

获取键的剩余过期时间，以毫秒为单位。

**语法：**  
PTTL key

**参数：**

*  key：要获取剩余过期时间的键名。

**返回：**

*  当键存在且具有过期时间时，返回剩余过期时间的毫秒数。
 *  当键不存在或键不存在过期时间时，返回 -1。
 *  当键存在但没有设置过期时间时，返回 -1。

**示例：**

PTTL mykey

与 TTL 命令不同，PTTL 命令返回的是以毫秒为单位的剩余过期时间。当键过期时，PTTL 命令将返回 -2，表示键已经被删除。

### · RENAME ###

修改键的名称。

**语法：**  
RENAME key newkey

**参数：**

*  key：要修改名称的键名。
 *  newkey：键的新名称。

**返回：**

*  当键被成功重命名时，返回 OK。
 *  如果键名不存在，或无法重命名键名，返回错误。
 *  如果新的键名已经存在，那么它将被覆盖。

**示例：**

RENAME mykey newkey

需要注意的是，如果新的键名已经存在，那么它将被覆盖。如果键名不存在，则命令将返回错误。此外，RENAME 命令还可以用来移动键，即将键从当前数据库移动到另一个数据库。要实现这个操作，可以将 newkey 指定为目标数据库中的键名。

### · RENAMENX ###

在不覆盖现有键的情况下，修改键的名称。  
**语法：**  
RENAMENX key newkey

**参数：**

*  key：要修改名称的键名。
 *  newkey：键的新名称。

**返回：**

*  当键成功重命名时，返回 1。
 *  如果新的键名已经存在，那么不执行重命名操作，并返回 0。

**示例：**

RENAMENX mykey newkey

如果 “newkey” 已经存在，则不执行重命名操作并返回 0；如果键名成功修改，则返回 1。

需要注意的是，与 RENAME 命令不同，RENAMENX 命令会检查新键名是否已经存在。如果新键名已经被使用，那么不会执行重命名操作，以避免覆盖已有的键。

### · TYPE ###

获取键存储的值的数据类型。

**语法：**  
TYPE key

**参数：**

*  key：要获取数据类型的键名。

**返回：**

*  当键不存在时，返回 none。
 *  当键存储的值是字符串类型时，返回 string。
 *  当键存储的值是列表类型时，返回 list。
 *  当键存储的值是哈希类型时，返回 hash。
 *  当键存储的值是集合类型时，返回 set。
 *  当键存储的值是有序集合类型时，返回 zset。

**示例：**

TYPE mykey

### · SCAN ###

迭代遍历 Redis 数据库中的键集合。SCAN 命令及其相关的 SSCAN, HSCAN 和 ZSCAN 命令都用于增量迭代key。

*  SCAN：迭代当前数据库中的key集合。
 *  HSCAN：迭代Hash类型中的键值对。
 *  SSCAN：迭代SET集合中的元素。
 *  ZSCAN：迭代SortSet集合中的元素和元素对应的分值

**语法：**  
SCAN cursor \[MATCH pattern\] \[COUNT count\]

**参数：**

*  cursor：遍历的起始位置，如果你想要完整的遍历执行 SCAN 0，然后使用返回结果中的非零游标来进行下一次迭代。如果返回结果为 0，表示遍历结束。
 *  MATCH pattern：可选参数，用于指定匹配的模式，只返回与给定模式相匹配的键。
 *  COUNT count：可选参数，用于指定每次遍历返回的元素个数，它并不是完全准确的，只是用于优化返回元素的个数，并不保证返回数量一定是 COUNT 设定的值。

**返回：**  
返回一个包含两个元素的数组：

*  游标，下一次迭代时使用；
 *  列表，包含了所有符合条件的键。

**示例：**

游标为 0 的位置开始，匹配以 “user” 开头的键，每次返回 3 个键。

SCAN 0 MATCH user* COUNT 3

![在这里插入图片描述][91a4222fb9d842f896dcc7a440cd117b.png]  
游标值变为 5，下一次迭代从游标为 5 的位置开始，匹配以 “user” 开头的键，每次返回 3 个键。

SCAN 5 MATCH user* COUNT 3

![在这里插入图片描述][fa014466f79a4f81a7a3f11e5ce62922.png]

游标值变为 0，这表示遍历已经完成。

**KEYS与SCAN使用选择：**

当需要获取 Redis 数据库中所有与特定模式匹配的键时，通常可以使用 SCAN 命令和 KEYS 命令。下面是这两个命令之间的一些区别和使用建议：

*  KEYS 命令是一个阻塞式的命令，多用于开发测试和调试环境，以及小数据量的场景。
    
    它会暂停 Redis 服务去扫描整个数据库，通过给定的模式匹配去返回符合条件的键列表。但是，当匹配规则过于广泛时，会导致 KEYS 命令执行缓慢，阻塞 Redis 服务甚至触发 Redis 自我保护机制，从而影响 Redis 的性能。
 *  SCAN 命令是一个游标迭代式命令，可以在不加重服务器负担的情况下，遍历数据库中指定模式的键值对。
    
    SCAN 命令可以保证不会消耗大量的内存和网络带宽，同时也可以保证遍历过程不会被干扰，且可以多次重复操作，避免较大的MongoDB并发请求。

因此，对于获取大量 Redis 中的键，而且需要保证稳定的性能和响应时间的情况，建议使用 SCAN 命令，因为它可以更加高效地获取键列表。但是，在小规模的 Redis 实例和非关键业务场景下，可以考虑使用 KEYS 命令，是否符合业务实际情况，作出灵活决策。

### · HSCAN ###

迭代遍历 Redis 哈希类型中的字段和对应的值。

**语法：**  
HSCAN key cursor \[MATCH pattern\] \[COUNT count\]

**参数：**

*  key：要遍历的哈希键名。
 *  cursor：遍历的起始位置，如果你想要完整的遍历执行 HSCAN key 0，然后使用返回结果中的非零游标来进行下一次迭代。如果返回结果为 0，表示遍历结束。
 *  MATCH pattern：可选参数，用于指定匹配的模式，只返回字段名与给定模式相匹配的键值对。
 *  COUNT count：可选参数，用于指定每次遍历返回的键值对个数，它并不是完全准确的，只是用于优化返回键值对的个数，并不保证返回数量一定是 COUNT 设定的值。

**返回：**  
返回一个包含两个元素的数组：

*  返回的游标，用于下一次迭代时使用。
 *  一个列表，包含了在游标位置上迭代得到的键值对。

**示例：**

HSCAN myhash 0

遍历 Redis 哈希中的字段和对应的值。

使用 HSCAN 命令可以逐步遍历哈希中的字段和对应的值，这对于处理大型哈希非常有用，因为它避免了一次性获取整个哈希的开销，并且能够提供更好的性能和效率。

### · SSCAN ###

迭代遍历 Redis 无序集合中的元素。

**语法：**  
SSCAN key cursor \[MATCH pattern\] \[COUNT count\]

**参数：**

*  key：要遍历的无序集合键名。
 *  cursor：遍历的起始位置，如果你想要完整的遍历执行 SSCAN key 0，然后使用返回结果中的非零游标来进行下一次迭代。如果返回结果为 0，表示遍历结束。
 *  MATCH pattern：可选参数，用于指定匹配的模式，只返回与给定模式相匹配的元素。
 *  COUNT count：可选参数，用于指定每次遍历返回的元素个数，它并不是完全准确的，只是用于优化返回元素的个数，并不保证返回数量一定是 COUNT 设定的值。

**返回：**  
返回一个包含两个元素的数组：

*  返回的游标，用于下一次迭代时使用。
 *  一个列表，包含了在游标位置上迭代得到的元素。

**示例：**

SSCAN myset 0

返回一个数组，第一个元素是下一次迭代时要使用的游标，第二个元素是在游标位置上迭代得到的元素的列表。

使用 SSCAN 命令可以逐步遍历无序集合中的元素，这对于处理大型无序集合非常有用，因为它避免了一次性获取整个无序集合的开销，并且能够提供更好的性能和效率。

### · ZSCAN ###

迭代遍历 Redis 有序集合中的成员和对应的分值。

**语法：**  
ZSCAN key cursor \[MATCH pattern\] \[COUNT count\]

**参数：**

*  key：要遍历的有序集合键名。
 *  cursor：遍历的起始位置，如果你想要完整的遍历执行 ZSCAN key 0，然后使用返回结果中的非零游标来进行下一次迭代。如果返回结果为 0，表示遍历结束。
 *  MATCH pattern：可选参数，用于指定匹配的模式，只返回成员名与给定模式相匹配的成员和分值。
 *  COUNT count：可选参数，用于指定每次遍历返回的成员和对应分值对的个数，它并不是完全准确的，只是用于优化返回成员和对应分值对的个数，并不保证返回数量一定是 COUNT 设定的值。

**返回：**  
返回一个包含两个元素的数组：

*  返回的游标，用于下一次迭代时使用。
 *  一个列表，包含了在游标位置上迭代得到的成员和对应的分值对。

**示例：**

ZSCAN myzset 0

返回一个数组，第一个元素是下一次迭代时要使用的游标，第二个元素是在游标位置上迭代得到的成员和对应的分值对的列表。

通过使用 ZSCAN 命令，你可以逐步遍历有序集合中的成员和对应的分值，从而避免一次性获取整个有序集合的开销，并且能够提供更

### · DUMP ###

用于序列化给定键的值，并以字符串的形式返回序列化后的值。该命令通常用于创建 Redis 中键的备份，以及将键的值转移到其他 Redis 实例。

**语法：**  
DUMP key

**参数：**

*  key：要进行序列化的键的名称。

**返回：**  
如果键存在，则 DUMP 命令返回值序列化后的字符串，否则返回 NULL。

**示例：**

SET mykey "Hello World"
    
    DUMP mykey

返回一个被序列化后的字符串值，例如：\\x00\\x06Hello World\\x06\\x00\\x00\\x00\\x00\\x00

这个字符串包含了键 “mykey” 的值的所有信息，你可以使用这个字符串恢复键的值，这可以通过使用 Redis RESTORE 命令实现。

需要注意的是，DUMP 命令可能会对 Redis 服务器的性能产生影响，因为它会序列化键的整个值。如果值很大，序列化和传输可能会花费相当长的时间。建议在生产环境中仅在必要时使用。

## String（字符串） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">SET</td> 
   <td align="left">设置指定 key 的值</td> 
   <td align="left">SET key value</td> 
  </tr> 
  <tr> 
   <td align="left">GET</td> 
   <td align="left">获取指定 key 的值</td> 
   <td align="left">GET key</td> 
  </tr> 
  <tr> 
   <td align="left">INCR</td> 
   <td align="left">将指定 key 的值增加 1</td> 
   <td align="left">INCR key</td> 
  </tr> 
  <tr> 
   <td align="left">DECR</td> 
   <td align="left">将指定 key 的值减少 1</td> 
   <td align="left">DECR key</td> 
  </tr> 
  <tr> 
   <td align="left">MSET</td> 
   <td align="left">同时设置多个 key-value 对</td> 
   <td align="left">MSET key1 value1 key2 value2 …</td> 
  </tr> 
  <tr> 
   <td align="left">MGET</td> 
   <td align="left">同时获取多个 key 的值</td> 
   <td align="left">MGET key1 key2 …</td> 
  </tr> 
  <tr> 
   <td align="left">APPEND</td> 
   <td align="left">追加值到指定 key 的值末尾</td> 
   <td align="left">APPEND key value</td> 
  </tr> 
  <tr> 
   <td align="left">SETNX</td> 
   <td align="left">在指定 key 不存在的情况下设置值</td> 
   <td align="left">SETNX key value</td> 
  </tr> 
  <tr> 
   <td align="left">STRLEN</td> 
   <td align="left">获取指定 key 的值的长度</td> 
   <td align="left">STRLEN key</td> 
  </tr> 
  <tr> 
   <td align="left">INCRBY</td> 
   <td align="left">将指定 key 的值增加指定的增量</td> 
   <td align="left">INCRBY key increment</td> 
  </tr> 
  <tr> 
   <td align="left">DECRBY</td> 
   <td align="left">将指定 key 的值减少指定的减量</td> 
   <td align="left">DECRBY key decrement</td> 
  </tr> 
  <tr> 
   <td align="left">INCRBYFLOAT</td> 
   <td align="left">将指定 key 的值以浮点数的方式增加</td> 
   <td align="left">INCRBYFLOAT key increment</td> 
  </tr> 
  <tr> 
   <td align="left">GETSET</td> 
   <td align="left">设置指定 key 的值，并返回原始值</td> 
   <td align="left">GETSET key value</td> 
  </tr> 
  <tr> 
   <td align="left">MSETNX</td> 
   <td align="left">同时设置多个 key-value 对</td> 
   <td align="left">MSETNX key1 value1 key2 value2 …</td> 
  </tr> 
  <tr> 
   <td align="left">SETEX</td> 
   <td align="left">设置指定 key 的值，并指定过期时间</td> 
   <td align="left">SETEX key seconds value</td> 
  </tr> 
  <tr> 
   <td align="left">PSETEX</td> 
   <td align="left">设置指定 key 的值，并指定过期时间</td> 
   <td align="left">PSETEX key milliseconds value</td> 
  </tr> 
 </tbody> 
</table>

### · SET ###

使用 Redis 中的 SET 命令时，可以用于设置指定 key 的值。

**语法：**  
SET key value \[EX seconds\] \[PX milliseconds\] \[NX|XX\]

**参数：**

*  key：键名
 *  value：要设置的值
 *  EX seconds：可选参数，指定键的过期时间（以秒为单位）
 *  PX milliseconds：可选参数，指定键的过期时间（以毫秒为单位）
 *  NX|XX：可选参数，设置键的条件选项，其中 NX 表示仅在键不存在时设置值，XX 表示仅在键已经存在时设置值

**返回：**

*  当 SET 命令成功设置值时，返回 OK

**示例：**

*  设置值
    
        SET mykey "Hello Redis"
 *  设置值及过期时间
    
        SET mykey "Hello Redis" EX 60
 *  仅在键不存在时才设置值
    
        SET mykey "Hello Redis" NX
 *  仅在键已经存在时设置值
    
        SET mykey "Hello Redis" XX

SET 命令用于设置指定键的值，并且可以配合过期时间和条件选项来实现更灵活的设置。成功设置值后，SET 命令将返回 OK。

### · GET ###

使用 Redis 中的 GET 命令时，可以获取指定 key 的值。  
**语法：**  
GET key

**参数：**

*  key：要获取值的键名

**返回：**  
如果键存在，则返回键的值；如果键不存在，则返回特殊值 nil。

**示例：**

GET mykey

### · INCR ###

对指定的 key 的值进行递增操作。

**语法：**  
INCR key

**参数：**

*  key：要递增的键名

**返回：**

*  执行 INCR 命令后，返回递增后的新值。

**示例：**  
对键值进行递增1

INCR mykey

在执行 INCR 命令之前，键对应的值必须能够被解析为一个 64 位有符号整数。如果键不存在，INCR 命令将会先将键的值设置为 0，然后执行递增操作。

### · DECR ###

对指定的 key 的值进行递减操作。

**语法：**

DECR key

**参数：**

*  key：要递减的键名

**返回：**

*  执行 DECR 命令后，返回递减后的新值。

**示例：**

对键值进行递减1

DECR mykey

注意：在执行 DECR 命令之前，键对应的值必须能够被解析为一个 64 位有符号整数。如果键不存在，DECR 命令将会先将键的值设置为 0，然后执行递减操作。

### · MSET ###

设置多个 key 的值。

**语法：**

MSET key1 value1 \[key2 value2 … keyn valuen\]

**参数：**

*  key1 value1 \[key2 value2 … keyn valuen\]：要设置的键值对，可以一次传入多个键值对

**返回：**  
在 Redis 2.0.1 以后的版本中，MSET 命令会返回 OK，表示所有键值设定成功。在之前的版本中，MSET 不会返回任何值。

**示例：**

MSET key1 "Hello" key2 "Redis" key3 "MSET"

需要注意的是，如果其中某个键已经存在，对应的值会被覆盖。

### · MGET ###

一次性获取多个指定 key 的值。

**语法：**  
MGET key1 \[key2 … keyn\]

**参数：**

*  key1 \[key2 … keyn\]：要获取值的键名列表，可以传入多个键名

**返回：**

返回一个列表，包含了所有指定 key 的值。

**示例：**

获取了键名为 key1、key2 和 key3 的值

MGET key1 key2 key3

需要注意的是，如果某个键不存在，返回的结果列表中对应的值为 nil。

### · APPEND ###

在指定 key 的字符串值后追加一个或多个值。

**语法：**

APPEND key value

**参数：**

*  key：要进行追加操作的键名
 *  value：要追加的值

**返回：**

*  追加后字符串的长度（即追加后的值的长度）

**示例：**

SET mykey "Hello"
    APPEND mykey " Redis"

在 mykey 的值的末尾追加了一个空格和 “Redis”。

需要注意的是，如果键名不存在，APPEND 命令会视为操作一个空字符串，等同于直接设置一个新值。

### · SETNX ###

在指定的 key 不存在时，设置 key 的值。

**语法：**  
SETNX key value

**参数：**

*  key：要设置值的键名
 *  value：要设置的值

**返回：**

如果 key 不存在，设置成功返回 1；如果 key 已经存在，设置失败返回 0。

**示例：**

SETNX mykey "Hello"

当键名为 mykey 不存在时，SETNX 命令会将值 “Hello” 设置给键名为 mykey

如果键名为 mykey 已经存在，则 SETNX 命令不会进行任何操作，并返回 0 表示设置失败。

### · STRLEN ###

获取指定 key 的字符串值的长度。

**语法：**  
STRLEN key

**参数：**

*  key：要获取长度的键名

**返回：**  
指定 key 的字符串值的长度，如果 key 不存在则返回 0。

**示例：**

SET mykey "Hello"
    STRLEN mykey

获取 mykey 的字符串值的长度。

### · INCRBY ###

对指定 key 的整数值进行增量操作。

**语法：**  
INCRBY key increment

**参数：**

*  key：要增加值的键名
 *  increment：要增加的值（必须为整数）

**返回：**  
增加后的值

**示例：**

SET mykey 10
    INCRBY mykey 5

将 mykey 的值增加了 5。

需要注意的是：

*  如果指定的 key 不存在，INCRBY 命令会将 key 的值视为 0 进行增加操作。
 *  如果 increment 参数不是整数，INCRBY 命令将返回一个错误。

### · DECRBY ###

对指定 key 的整数值进行递减操作。

**语法：**  
DECRBY key decrement

**参数：**

*  key：要递减值的键名
 *  decrement：要递减的值（必须为整数）

**返回：**  
递减后的值`在这里插入代码片`

**示例：**

SET mykey 10
    DECRBY mykey 5

mykey 的值递减了 5。

需要注意的是：

*  如果指定的 key 不存在，DECRBY 命令会将 key 的值视为 0 进行递减操作。
 *  如果 decrement 参数不是整数，DECRBY 命令将返回一个错误。

### · INCRBYFLOAT ###

对指定 key 的浮点数值进行增量操作。

**语法：**  
INCRBYFLOAT key increment

**参数：**

*  key：要增加值的键名
 *  increment：要增加的浮点数值（可以为正数或负数）

**返回：**  
增加后的值

**示例：**

SET mykey 10.5
    INCRBYFLOAT mykey 2.1

mykey 的值增加了2.1

如果指定的 key 不存在，INCRBYFLOAT 命令会将 key 的值视为 0 进行增加操作。

当使用 INCRBYFLOAT 命令进行浮点数增加操作时，需要注意可能存在的精度丢失问题，并在需要的情况下进行额外的精度控制和处理。

### · GETSET ###

设置指定 key 的值并返回原来的值。

**语法：**  
GETSET key value

**参数：**

*  key：要设置值的键名
 *  value：要设置的值

**返回：**  
原来的值

**示例：**

SET mykey "Hello"
    GETSET mykey "World"

将 mykey 的值设置为 “World” 并返回原来的值"Hello"。

如果指定的 key 不存在，GETSET 命令会将 key 的值视为 nil，并返回 nil。

### · MSETNX ###

MSETNX 命令可以设置多个键值对，但只有在所有键都不存在的情况下才执行设置操作。

**语法：**  
MSETNX key1 value1 key2 value2 …

**参数：**

*  key1, value1, key2, value2：要设置的键值对

**返回：**  
如果所有键都设置成功，返回 1；如果至少有一个键已经存在，设置失败返回 0。

**示例：**

MSETNX key1 "Hello" key2 "World"

在上述示例中：

*  如果 key1 和 key2 都不存在，则 MSETNX 命令将 “Hello” 设置给 key1，“World” 设置给 key2，并返回 1 表示设置成功。
 *  如果 key1 或 key2 中至少有一个已经存在，MSETNX 命令不会进行任何操作，并返回 0 表示设置失败。

### · SETEX ###

设置指定 key 的值，并指定该值的过期时间（以秒为单位）。

**语法：**  
SETEX key seconds value

**参数：**

*  key：要设置值的键名
 *  seconds：过期时间（以秒为单位）
 *  value：要设置的值

**返回：**  
无

**示例：**

SETEX mykey 3600 "Hello"

将 “Hello” 设置给键名为 mykey 的值，并指定该值的过期时间为 3600 秒（即 1 小时）。

需要注意的是，当键名为 mykey 的值被设置后，经过 1 小时后该值将自动被删除。即在 1 小时后，再执行 GET mykey 将返回 nil。

### · PSETEX ###

设置指定 key 的值，并指定该值的过期时间（以毫秒为单位）

**语法：**  
PSETEX key milliseconds value

**参数：**

*  key：要设置值的键名
 *  milliseconds：过期时间（以毫秒为单位）
 *  value：要设置的值

**返回：**  
无

**示例：**

PSETEX mykey 1000 "Hello"

将 “Hello” 设置给键名为 mykey 的值，并指定该值的过期时间为 1000 毫秒（即 1 秒）。

需要注意的是，当键名为 mykey 的值被设置后，过了 1 秒后该值将自动被删除。即在 1 秒后，再执行 GET mykey 将返回 nil。

## Hash（哈希） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">HSET</td> 
   <td align="left">将哈希表中指定字段的值设置为指定的值</td> 
   <td align="left">HSET key field value</td> 
  </tr> 
  <tr> 
   <td align="left">HGET</td> 
   <td align="left">获取哈希表中指定字段的值</td> 
   <td align="left">HGET key field</td> 
  </tr> 
  <tr> 
   <td align="left">HGETALL</td> 
   <td align="left">获取哈希表中所有字段和对应的值</td> 
   <td align="left">HGETALL key</td> 
  </tr> 
  <tr> 
   <td align="left">HDEL</td> 
   <td align="left">从哈希表中删除指定的字段和对应的值</td> 
   <td align="left">HDEL key field [field …]</td> 
  </tr> 
  <tr> 
   <td align="left">HSETNX</td> 
   <td align="left">将哈希表中指定字段的值设为指定的字符串值，当且仅当该字段不存在</td> 
   <td align="left">HSETNX key field value</td> 
  </tr> 
  <tr> 
   <td align="left">HMSET</td> 
   <td align="left">设置哈希表中多个字段的值</td> 
   <td align="left">HMSET key field1 value1 [field2 value2 …]</td> 
  </tr> 
  <tr> 
   <td align="left">HINCRBY</td> 
   <td align="left">将哈希表中指定字段的值增加指定的整数增量</td> 
   <td align="left">HINCRBY key field increment</td> 
  </tr> 
  <tr> 
   <td align="left">HKEYS</td> 
   <td align="left">获取哈希表中所有字段的键名</td> 
   <td align="left">HKEYS key</td> 
  </tr> 
  <tr> 
   <td align="left">HLEN</td> 
   <td align="left">获取哈希表中字段的数量</td> 
   <td align="left">HLEN key</td> 
  </tr> 
  <tr> 
   <td align="left">HVALS</td> 
   <td align="left">获取哈希表中所有字段的值</td> 
   <td align="left">HVALS key</td> 
  </tr> 
 </tbody> 
</table>

### · HSET ###

用于将哈希表中指定字段的值设置为指定的值。如果该字段存在，则会更新其值；如果该字段不存在，则会创建并设置值。

**语法：**  
HSET key field value

**参数：**

*  key：哈希表的键名。
 *  field：要设置值的字段名。
 *  value：要设置的值。

**返回：**  
返回一个整数，表示设置成功的字段数量（如果字段已存在，则更新值时返回 0）。

**示例：**

HSET user:001 username "哈哈"

*  如果字段 “username” 不存在，则会在哈希表中创建该字段，并将其值设置为 “哈哈”，返回值为 1。
 *  如果字段 “username” 已经存在，则会更新其值为"哈哈"，返回值为 0。

### · HGET ###

获取哈希表中指定字段的值。

**语法：**  
HGET key field

**参数：**

*  key：哈希表的键名。
 *  field：要获取值的字段名。

**返回：**  
返回指定字段的值，如果字段不存在，则返回 nil。

**示例：**

HGET user:001 name

获取key为user:001的哈希表中 “name” 字段的值。

需要注意的是，如果指定的字段名不存在，HGET 命令将返回 nil。

### · HGETALL ###

获取哈希表中所有字段和对应的值。

该命令用于操作 Redis 中的哈希数据结构，它将返回哈希表中所有的字段和值，其中字段和值之间以键值对的形式组织返回。

**语法：**  
HGETALL key

**参数：**

*  key：要获取字段和值的哈希表的键名。

**返回：**  
返回一个数组，包含指定键中的所有字段和值。数组的奇数下标为字段名，偶数下标为对应的值。

**示例：**

HGETALL user:001

获取key为user:001的哈希表中所有的字段和值。

需要注意的是，如果哈希表中的字段和值非常多，HGETALL 命令返回的数组也会非常大，因此在使用该命令时需要注意返回数据的大小。

### · HDEL ###

用于从哈希表中删除指定的字段和对应的值。

**语法：**  
HDEL key field \[field …\]

**参数：**

*  key：哈希表的键名。
 *  field：要删除的字段名，可以指定多个字段。

**返回：**  
返回一个整数，表示成功删除的字段数量

**示例：**

HDEL user:001 age email

将字段 “age” 和 “email” 从哈希表中删除。

需要注意：如果指定的字段在哈希表中不存在，则会被忽略，不会报错。可以一次性指定多个字段进行删除。

### · HSETNX ###

将哈希表中指定字段的值设为指定的字符串值，当且仅当该字段不存在。如果该字段已经存在，该命令不会执行任何操作。

**语法：**  
HSETNX key field value

**参数：**

*  key：哈希表的键名。
 *  field：要设置值的字段名。
 *  value：要设置的字符串值。

**返回：**  
如果字段不存在，则设置成功并返回 1；如果字段已经存在，则不执行任何操作并返回 0。

**示例：**

HSETNX user:info:001 username 哈哈

### · HMSET ###

同时设置哈希表中多个字段的值。

**语法：**  
HMSET key field1 value1 \[field2 value2 …\]

**参数：**

*  key：哈希表的键名。
 *  field：要设置值的字段名。
 *  value：要设置的值。

**返回：**  
该命令没有固定的返回值。

**示例：**

HMSET user:info:001 name John age 30

### · HINCRBY ###

用于将哈希表中指定字段的值增加指定的整数增量。如果该字段不存在，则会将其值初始化为 0。

**语法：**  
HINCRBY key field increment

**参数：**

*  key：哈希表的键名。
 *  field：要增加值的字段名。
 *  increment：要增加的整数增量。

**返回：**  
返回字段增加后的值。

**示例：**

HINCRBY user:points:001 points 50

将字段 “points” 的值增加 50。

需要注意的是，键对应的数据确实是一个哈希表，并且字段的值可以解释为整数类型。如果字段的值无法解释为整数，则会返回错误。

### · HKEYS ###

获取哈希表中所有字段的键名。

**语法：**  
HKEYS key

**参数：**

*  key：哈希表的键名。

**返回：**  
返回一个包含哈希表中所有字段键名的数组。

**示例：**

HKEYS user:info:001

需要注意：返回的键名数组中的键名的顺序是无序的，即不保证与字段的存放顺序一致。

### · HLEN ###

获取哈希表中字段的数量。

**语法：**  
HLEN key

**参数：**

*  key：哈希表的键名。

**返回：**  
返回一个整数，表示哈希表中字段的数量。如果哈希表不存在，则返回 0。

**示例：**

HLEN user:info:001

获取哈希表中的字段数量。

### · HVALS ###

获取哈希表中所有字段的值。

**语法：**  
HVALS key

**参数：**

*  key：哈希表的键名。

**返回：**  
返回一个包含哈希表中所有字段值的数组。

**示例：**

HVALS user:info:001

需要注意：返回的值数组中的值的顺序是无序的，即不保证与字段的存放顺序一致。

## List（列表） ##

在 Redis 中，列表类型的键被用作栈（stack）或队列（queue）数据结构的实现。

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">LPUSH</td> 
   <td align="left">将一个或多个元素插入列表的头部</td> 
   <td align="left">LPUSH key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">RPUSH</td> 
   <td align="left">将一个或多个元素插入列表的尾部</td> 
   <td align="left">RPUSH key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">LPUSHX</td> 
   <td align="left">将一个或多个元素添加到已存在的列表的头部</td> 
   <td align="left">LPUSHX key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">RPUSHX</td> 
   <td align="left">将一个或多个元素添加到已存在的列表的尾部</td> 
   <td align="left">RPUSHX key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">LPOP</td> 
   <td align="left">移除并返回列表的第一个元素（首部）</td> 
   <td align="left">LPOP key</td> 
  </tr> 
  <tr> 
   <td align="left">RPOP</td> 
   <td align="left">移除并返回列表的最后一个元素（尾部）</td> 
   <td align="left">RPOP key</td> 
  </tr> 
  <tr> 
   <td align="left">BLPOP</td> 
   <td align="left">阻塞式弹出列表第一个元素的命令<br>它是基于 LPOP 的阻塞式版本，适用于队列场景</td> 
   <td align="left">BLPOP key [key …] timeout</td> 
  </tr> 
  <tr> 
   <td align="left">BRPOP</td> 
   <td align="left">阻塞式弹出列表最后一个元素的命令<br>它是基于 RPOP 的阻塞式版本，适用于队列场景</td> 
   <td align="left">BRPOP key [key …] timeout</td> 
  </tr> 
  <tr> 
   <td align="left">LTRIM</td> 
   <td align="left">移除列表中除指定范围以外的所有元素（对列表进行修剪）</td> 
   <td align="left">LTRIM key start stop</td> 
  </tr> 
  <tr> 
   <td align="left">RPOPLPUSH</td> 
   <td align="left">原子性地将列表尾部的元素弹出并推入另一个列表头部的命令</td> 
   <td align="left">RPOPLPUSH source destination</td> 
  </tr> 
  <tr> 
   <td align="left">BRPOPLPUSH</td> 
   <td align="left">在列表之间移动元素，并且它具有阻塞特性</td> 
   <td align="left">BRPOPLPUSH source destination timeout</td> 
  </tr> 
  <tr> 
   <td align="left">LRANGE</td> 
   <td align="left">获取列表中指定范围内的元素</td> 
   <td align="left">LRANGE key start stop</td> 
  </tr> 
  <tr> 
   <td align="left">LLEN</td> 
   <td align="left">获取列表的长度（即列表中的元素数量）</td> 
   <td align="left">LLEN key</td> 
  </tr> 
  <tr> 
   <td align="left">LINDEX</td> 
   <td align="left">获取列表中指定索引位置的元素</td> 
   <td align="left">LINDEX key index</td> 
  </tr> 
  <tr> 
   <td align="left">LINSERT</td> 
   <td align="left">将指定值插入到列表中另一个元素之前或之后</td> 
   <td align="left">LINSERT key BEFORE|AFTER pivot value</td> 
  </tr> 
  <tr> 
   <td align="left">LSET</td> 
   <td align="left">设置列表中指定索引位置的元素</td> 
   <td align="left">LSET key index value</td> 
  </tr> 
  <tr> 
   <td align="left">LREM</td> 
   <td align="left">从列表中移除指定数量的元素</td> 
   <td align="left">LREM key count value</td> 
  </tr> 
 </tbody> 
</table>

### · LPUSH ###

用于将一个或多个元素插入列表的头部。

**语法：**  
LPUSH key element \[element …\]

**参数：**

*  key：目标列表的键名。
 *  element ：要插入到列表头部的一个或多个数值。

**返回：**  
执行操作后列表的长度。

**示例：**

LPUSH mylist "Hello"
    LPUSH mylist "World"

要注意的是，如果指定的键不存在，LPUSH 命令将创建一个新的列表，并将元素追加到该列表中。如果键存在，但不是列表类型，那么该命令将返回一个错误。

### · RPUSH ###

将一个或多个元素插入列表的尾部

**语法：**  
RPUSH key element \[element …\]

**参数：**

*  key：列表键的名称。
 *  element：要添加到列表尾部的一个或多个元素。

**返回：**  
执行 RPUSH 命令后，列表中的元素数量。

**示例：**

RPUSH mylist "apple" "banana" "cherry"

要注意的是，如果指定的键不存在，RPUSH 命令将创建一个新的列表，并将元素追加到该列表中。如果键存在，但不是列表类型，那么该命令将返回一个错误。

### · LPUSHX ###

用于将一个或多个元素添加到已存在的列表的头部。

**语法：**  
LPUSHX key element \[element …\]

**参数：**

*  key：列表键的名称。
 *  element：要添加到列表头部的一个或多个元素。

**返回：**  
执行 LPUSHX 命令后，列表中的元素数量。

**示例：**

LPUSHX mylist "apple" "banana" "cherry"

要注意的是，如果指定的键不存在，LPUSHX 命令不会进行任何操作，也不会创建新的列表。LPUSHX 只对已存在的列表进行头部添加操作。

LPUSHX 命令是 LPUSH 命令的扩展，它们的作用类似。LPUSH 命令用于将元素添加到列表的头部，并且如果键不存在，它会自动创建一个列表。

### · RPUSHX ###

用于将一个或多个元素添加到已存在的列表的尾部。

**语法：**  
RPUSHX key element \[element …\]

**参数：**

*  key：列表键的名称。
 *  element：要添加到列表尾部的一个或多个元素。

**返回：**  
执行 RPUSHX 命令后，列表中的元素数量。

**示例：**

RPUSHX mylist "apple" "banana" "cherry"

要注意的是，如果指定的键不存在，RPUSHX 命令不会进行任何操作，也不会创建新的列表。RPUSHX 只对已存在的列表进行尾部添加操作。

RPUSHX 命令是 RPUSH 命令的扩展，它们的作用类似。RPUSH 命令用于将元素添加到列表的尾部，并且如果键不存在，它会自动创建一个列表。

### · LPOP ###

用于移除并返回列表的第一个元素（头部）。

**语法：**  
LPOP key

**参数：**

*  key：列表键的名称。

**返回：**  
执行 LPOP 命令后，返回被移除的元素。

**示例：**

LPOP mylist

要注意的是，如果列表不存在或者是空列表，LPOP 将返回 nil 值。

LPOP 命令用于移除并获取列表的第一个元素，因此在使用 LPOP 命令后，列表的长度会减少1。

### · RPOP ###

用于移除并返回列表的最后一个元素（尾部）。

**语法：**  
LPOP key

**参数：**

*  key：列表键的名称。

**返回：**  
执行 RPOP 命令后，返回被移除的元素。

**示例：**

RPOP mylist

要注意的是，如果列表不存在或者是空列表，LPOP 将返回 nil 值。

RPOP 命令用于移除并获取列表的最后一个元素，因此在使用 RPOP 命令后，列表的长度会减少1。

### · BLPOP ###

用于阻塞式弹出列表第一个元素的命令，它是基于 LPOP 的阻塞式版本，适用于队列场景。

**语法：**  
BLPOP key \[key …\] timeout

**参数：**

*  key：一个或多个列表键的名称，按优先级顺序依次检查弹出操作（从左至右）。
 *  timeout：阻塞的最大时间（以秒为单位），在超时之前，BLPOP 将阻塞并等待一个或多个非空列表可被弹出。

**返回：**

*  如果列表中有可弹出的元素，则返回一个包含被弹出元素所在列表和元素值的数组，形如 \[list\_name, element\]。
 *  如果超时时间到达，返回 nil。

**示例：**

BLPOP list1 list2 10

BLPOP 命令是基于 LPOP 命令的阻塞式版本，**从给的列表参数中按顺序检查第一个不空的列表，然后从该列表的尾部移除元素**。它会在指定的列表键中等待可弹出的元素出现，或者等待超时。在阻塞期间，客户端连接将被阻塞，直到有元素可被弹出或者超时。

使用 BLPOP 命令可以实现生产者-消费者模式，其中生产者将元素推入列表（LPUSH 或 RPUSH），而消费者通过 BLPOP 命令阻塞式地等待并弹出元素，实现线程安全地消费列表中的数据。

### · BRPOP ###

用于阻塞式弹出列表最后一个元素的命令，它是基于 RPOP 的阻塞式版本，适用于队列场景。

**语法：**  
BRPOP key \[key …\] timeout

**参数：**

*  key：一个或多个列表键的名称，按优先级顺序依次检查弹出操作（从左至右）。
 *  timeout：阻塞的最大时间（以秒为单位），在超时之前，BRPOP 将阻塞并等待一个或多个非空列表可被弹出。

**返回：**

*  如果列表中有可弹出的元素，则返回一个包含被弹出元素所在列表和元素值的数组，形如 \[list\_name, element\]。
 *  如果超时时间到达，返回 nil。

**示例：**

BRPOP list1 10

BRPOP 命令是基于 RPOP 命令的阻塞式版本，**从给的列表参数中按顺序检查第一个不空的列表，然后从该列表的尾部移除元素**。它会在指定的列表键中等待可弹出的元素出现，或者等待超时。在阻塞期间，客户端连接将被阻塞，直到有元素可被弹出或者超时。

使用 BRPOP 命令可以实现生产者-消费者模式，其中生产者将元素推入列表（LPUSH 或 RPUSH），而消费者通过 BRPOP 命令阻塞式地等待并弹出元素，实现线程安全地消费列表中的数据。

### · LTRIM ###

用于对列表进行修剪，即移除列表中除指定范围以外的所有元素。

**语法：**  
LTRIM key start stop

**参数：**

*  key：列表键的名称。
 *  start：保留的起始索引位置（包含该位置的元素）。
 *  stop：保留的结束索引位置（包含该位置的元素）。

**返回：**  
修剪成功时返回 OK。

**示例：**

LTRIM mylist 0 2

LTRIM 命令用于修剪指定列表的元素范围，即保留指定索引范围内的元素，而移除其他元素。该命令对列表进行就地修改，不会返回修剪后的列表，而是返回修剪操作的结果。

要注意的是，索引是从 0 开始的，且可以是负数。负数索引表示与列表末尾的相对位置，例如 -1 表示列表的最后一个元素，-2 表示倒数第二个元素，依此类推。

通过 LTRIM 命令可以实现对列表的修剪操作，这在一些场景下非常有用，比如保留某个范围内的最新数据，或者控制列表的长度，以避免列表过长导致内存占用过大。

### · RPOPLPUSH ###

用于原子性地将列表尾部的元素弹出并推入另一个列表头部的命令。

**语法：**  
RPOPLPUSH source destination

**参数：**

*  source：源列表的名称，即要从其尾部弹出元素的列表。
 *  destination：目标列表的名称，即要将元素推入其头部的列表。

**返回：**  
被弹出并推入的元素值。

**示例：**

RPOPLPUSH list1 list2

RPOPLPUSH 命令实现了一个原子性操作，确保在执行整个过程中，不会有其他客户端对这两个列表进行修改。这使得 RPOPLPUSH 命令在处理队列和任务分发等场景中非常有用。

在队列场景中，RPOPLPUSH 命令可以确保元素的移动是原子性的，即将元素从一个列表弹出并推入另一个列表的操作是不可分割的，防止其他客户端在此过程中获取相同的元素。这是因为 Redis 是单线程的，一次只能执行一个命令，从而保证了原子性。

要注意的是，RPOPLPUSH 命令在推入元素到目标列表时，会返回被推入的元素值，因此可以根据返回值来进行相应的处理。

### · BRPOPLPUSH ###

BRPOPLPUSH 是 Redis 中的一种原子性命令，用于在列表之间移动元素，并且它具有阻塞特性。

**语法：**  
BRPOPLPUSH source destination timeout

**参数：**

*  source：源列表的名称，即要从其尾部弹出元素的列表。
 *  destination：目标列表的名称，即要将元素推入其头部的列表。
 *  timeout：阻塞超时时间，如果列表 source 中没有任何元素，命令将会阻塞并等待元素出现的最长时间（以秒为单位），超时时间为0表示一直阻塞。

**返回：**  
如果在指定的时间内成功地将元素从源列表弹出并推入目标列表，将返回被移动的元素。  
如果阻塞超时，返回 nil。

**示例：**

BRPOPLPUSH list1 list2 10

BRPOPLPUSH 命令是 BRPOP 和 RPOPLPUSH 两个命令的组合，它原子性地将源列表中的尾部元素弹出并推入目标列表的头部。同时，它具有阻塞特性，即在源列表中没有可弹出的元素时，会阻塞等待元素的出现，直到超时时间设定或有元素可弹出。

BRPOPLPUSH 命令常被用于实现任务队列或消息队列，确保任务移动的原子性并阻塞等待新任务的到来。由于其原子性，这个命令非常适合多个客户端同时操作同一个队列的场景。

### · LRANGE ###

用于获取列表中指定范围内的元素的命令。

**语法：**  
LRANGE key start stop

**参数：**

*  key：列表键的名称。
 *  start：起始索引位置。
 *  stop：结束索引位置。

**返回：**  
表示指定范围内的元素的列表。

**示例：**

LRANGE mylist 0 2

LRANGE 命令用于获取列表中指定范围内的元素，起始索引位置和结束索引位置都是基于 0 的索引。第一个元素的索引是 0，第二个是 1，依此类推。

要注意的是，LRANGE 命令返回的元素包括起始和结束索引位置上的元素。如果索引为负数，则表示从列表末尾开始计算的位置。例如，-1 表示列表的最后一个元素，-2 表示倒数第二个元素。

LRANGE 命令允许我们根据需要从列表中获取指定范围内的元素，这在需要获取部分列表数据进行展示或处理时非常有用。通过指定不同的起始和结束索引，可以灵活地获取列表中的子集。

### · LLEN ###

用于获取列表的长度（即列表中的元素数量）的命令。

**语法：**  
LLEN key

**参数：**

*  key：列表键的名称。

**返回：**  
列表的长度，即列表中的元素数量。

**示例：**

LLEN mylist

LLEN 命令用于获取列表的长度，即列表中的元素数量。它对于检查列表的大小是否满足要求，或者获取列表的元素数量用于计算和统计非常有用。

在 Redis 中，列表是一个有序的字符串类型数据结构，每个列表可以包含多个元素。通过 LLEN 命令，可以直接获取列表的长度，而无需遍历整个列表。

LLEN 命令的时间复杂度为 O(1)，即获取列表长度的操作的时间与列表的大小无关，所以可以在常数时间内完成。

### · LINDEX ###

用于获取列表中指定索引位置的元素的命令。

**语法：**  
LINDEX key index

**参数：**

*  key：列表键的名称。
 *  index：要获取的元素的索引位置。

**返回：**  
表示指定索引位置上的元素的字符串。

**示例：**

LINDEX mylist 0

LINDEX 命令用于获取列表中指定索引位置的元素。索引位置是基于 0 的，第一个元素的索引为 0，第二个为 1，以此类推。如果索引为负数，则表示从列表末尾开始计算的位置，-1 表示列表的最后一个元素，-2 表示倒数第二个元素。

需要注意的是，如果索引超出列表的范围，即大于等于列表的长度或小于等于负数的列表长度，则 LINDEX 命令返回 nil。

通过 LINDEX 命令，我们可以根据需要获取列表中指定索引位置的元素。这在需要获取特定的列表元素进行展示或处理时非常有用。

### · LINSERT ###

用于将指定值插入到列表中另一个元素之前或之后。

**语法：**  
LINSERT key BEFORE|AFTER pivot value

**参数：**

*  key: 目标列表元素之前还是之后进行插入。
 *  pivot: 目标元素，即用于确定插入位置的参考元素。
 *  value: 要插入的值。

**返回：**  
返回插入操作完成后的目标列表的长度。

**示例：**

LINSERT mylist BEFORE "b" "a"

LINSERT 命令用于在列表中的指定元素之前或之后插入新的元素。该命令需要指定插入位置（BEFORE 或 AFTER）、目标元素（pivot）和要插入的值。如果目标元素不存在，则不会执行插入操作。

通过 LINSERT 命令，可以在列表中灵活地插入新的元素，这对于管理和维护列表中的数据非常有用。

需要注意的是，LINSERT 命令的时间复杂度为 O(N)，其中 N 为列表的长度，因此执行该命令可能对性能产生影响，特别是对于长度较大的列表。

### · LSET ###

用于设置列表中指定索引位置的元素的命令。

**语法：**  
LSET key index value

**参数：**

*  key：列表键的名称。
 *  index：要设置的元素的索引位置。
 *  value：要设置的新值。

**返回：**  
无，即不返回任何信息。

**示例：**

LSET mylist 0 "new value"

LSET 命令用于设置列表中指定索引位置的元素的值。索引位置是基于 0 的，第一个元素的索引为 0，第二个为 1，以此类推。如果索引为负数，则表示从列表末尾开始计算的位置，-1 表示列表的最后一个元素，-2 表示倒数第二个元素。

需要注意的是，如果索引超出列表的范围，即大于等于列表的长度或小于等于负数的列表长度，则 LSET 命令会抛出一个错误。

通过 LSET 命令，我们可以根据需要，将列表中指定索引位置的元素的值进行修改。

### · LREM ###

用于从列表中移除指定数量的元素的命令。

**语法：**  
LREM key count value

**参数：**

*  key：列表键的名称。
 *  count：要移除的元素的数量。
 *  value：要被移除的元素的值。

**返回：**  
返回被移除的元素的数量。

**示例：**

LREM mylist 2 "value"

LREM 命令用于从列表中移除指定数量的元素。移除的数量可以是正数、零或负数。根据 count 参数的不同取值，LREM 命令有以下几种情况：

count > 0：从表头开始向表尾搜索，移除值为 value 的元素，直到移除 count 个元素为止。  
count < 0：从表尾开始向表头搜索，移除值为 value 的元素，直到移除 count 个元素为止。  
count = 0：移除所有值为 value 的元素，即没有数量限制。  
需要注意的是，如果 count 参数的绝对值大于列表中值为 value 的元素的数量，那么所有匹配的元素都会被移除。

通过 LREM 命令，我们可以根据需要从列表中移除指定数量的元素。

## Set（集合） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">SADD</td> 
   <td align="left">向集合中添加一个或多个元素</td> 
   <td align="left">SADD key member [member …]</td> 
  </tr> 
  <tr> 
   <td align="left">SMOVE</td> 
   <td align="left">将集合中的一个元素移动到另一个集合中</td> 
   <td align="left">SMOVE source destination member</td> 
  </tr> 
  <tr> 
   <td align="left">SCARD</td> 
   <td align="left">获取集合中的成员数量</td> 
   <td align="left">SCARD key</td> 
  </tr> 
  <tr> 
   <td align="left">SMEMBERS</td> 
   <td align="left">获取指定集合的所有成员</td> 
   <td align="left">SMEMBERS key</td> 
  </tr> 
  <tr> 
   <td align="left">SISMEMBER</td> 
   <td align="left">判断一个元素是否是指定集合的成员</td> 
   <td align="left">SISMEMBER key member</td> 
  </tr> 
  <tr> 
   <td align="left">SRANDMEMBER</td> 
   <td align="left">从指定集合中随机获取一个或多个元素</td> 
   <td align="left">SRANDMEMBER key [count]</td> 
  </tr> 
  <tr> 
   <td align="left">SDIFF</td> 
   <td align="left">获取多个集合之间的差集</td> 
   <td align="left">SDIFF key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SDIFFSTORE</td> 
   <td align="left">将多个集合之间的差集存储到一个新的集合中</td> 
   <td align="left">SDIFFSTORE destination key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SINTER</td> 
   <td align="left">获取多个集合之间的交集</td> 
   <td align="left">SINTER key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SINTERSTORE</td> 
   <td align="left">将多个集合之间的交集存储到一个新的集合中</td> 
   <td align="left">SINTERSTORE destination key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SUNION</td> 
   <td align="left">获取多个集合的并集</td> 
   <td align="left">SUNION key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SUNIONSTORE</td> 
   <td align="left">将多个集合的并集存储到一个新的集合中</td> 
   <td align="left">SUNIONSTORE destination key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">SREM</td> 
   <td align="left">从集合中移除一个或多个指定的成员</td> 
   <td align="left">SREM key member [member …]</td> 
  </tr> 
  <tr> 
   <td align="left">SPOP</td> 
   <td align="left">从集合中随机地移除并返回一个或多个成员</td> 
   <td align="left">SPOP key [count]</td> 
  </tr> 
 </tbody> 
</table>

### · SADD ###

向集合中添加一个或多个元素。

**语法：**  
SADD key member \[member …\]

**参数：**

*  key：集合的键名。
 *  member：要添加到集合中的一个或多个元素。

**返回：**  
添加到集合的元素数量。

**示例：**

SADD fruits orange banana

注意事项：

*  如果集合已存在，但里面不存在要添加的元素，那么新的元素将被添加到集合中。
 *  如果集合不存在，则会先创建集合，然后再添加元素。

SADD 命令在存储唯一值、进行快速成员查找和去重等场景下非常有用。通过将元素添加到集合中，可以将添加的元素与已存在于集合中的元素进行去重，并快速进行成员查询和操作。

### · SMOVE ###

将集合中的一个元素移动到另一个集合中。

**语法：**  
SMOVE source destination member

**参数：**

*  source：源集合的键名。
 *  destination：目标集合的键名。
 *  member：要移动的元素。

**返回：**  
如果成功移动元素，则返回 1；如果源集合中不存在该元素或移动失败，则返回 0。

**示例：**

SMOVE set1 set2 apple

注意事项：

*  被移动的元素必须存在于源集合中，否则移动操作将失败。
 *  如果源集合和目标集合都不存在，那么移动操作将会被忽略。
 *  如果目标集合已经存在要移动的元素，那么移动操作将会成功，但源集合中的该元素将不会被移除。

### · SCARD ###

获取集合中的成员数量，即集合的基数（cardinality）。

**语法：**  
SCARD key

**参数：**

*  key：要获取成员数量的集合的键名。

**返回：**  
集合中的成员数量。

**示例：**

SCARD set1

注意事项：

*  如果指定的集合不存在，那么返回的成员数量为 0。
 *  SCARD 命令对于快速获取集合中元素的数量非常有用，尤其在需要实时统计集合大小的场景中。

### · SMEMBERS ###

获取指定集合的所有成员。

**语法：**  
SMEMBERS key

**参数：**

*  key：需要返回成员列表的集合的键名。

**返回：**  
集合中的所有成员列表。

**示例：**

SMEMBERS set1

注意事项：

*  如果集合不存在或集合为空，那么返回一个空列表。
 *  SMEMBERS 命令通常用于获取 Redis 集合中的所有成员，以便对集合中的成员进行遍历和操作。

### · SISMEMBER ###

判断一个元素是否是指定集合的成员。

**语法：**  
SISMEMBER key member

**参数：**

*  key：要检查成员归属的集合的键名。
 *  member：要检查的元素。

**返回：**

*  如果指定的元素是集合的成员，返回 1；
 *  如果指定的元素不是集合的成员，或者集合不存在，返回 0。

**示例：**

SISMEMBER set1 apple

注意事项：

*  如果指定的集合不存在，或者集合为空，则被视为不包含任何成员，此时 SISMEMBER 命令返回 0。
 *  如果要检查的元素不是集合的成员，则 SISMEMBER 命令返回 0。
 *  如果集合中存在多个相同的元素，SISMEMBER 命令只需要检查一个匹配元素，即可返回 1。

### · SRANDMEMBER ###

从指定集合中随机获取一个或多个元素。

**语法：**  
SRANDMEMBER key \[count\]

**参数：**

*  key：要获取元素的集合的键名。
 *  count（可选）：要获取的元素数量。如果未指定该参数，将返回一个随机元素。

**返回：**

*  如果未指定 count 参数，则返回一个随机元素。
 *  如果指定了 count 参数，且集合存在且非空，返回的元素数量等于 count 参数，可能包含重复。

**示例：**

SRANDMEMBER set1 2

注意事项：

*  如果集合不存在，或者集合为空，SRANDMEMBER 命令将返回空值 nil。
 *  如果指定的 count 参数大于集合中的元素数量，将返回集合中的所有元素。
 *  SRANDMEMBER 命令可以用于从集合中获取随机样本，无需修改集合本身。如果需要随机删除集合中的元素，请使用 SPOP 命令。

### · SDIFF ###

获取多个集合之间的差集，即获取存在于第一个集合中但不存在于其他集合中的元素。

**语法：**  
SDIFF key \[key …\]

**参数：**

*  key：要取差集的集合的键名，可以指定多个键名。

**返回：**  
返回一个包含差集元素的结果集（即存在于第一个集合但不存在于其他集合中的元素）。

**示例：**

SDIFF set1 set2

注意事项：

*  如果指定的集合不存在，将被视为空集合。
 *  如果只指定一个键名作为参数，则返回该集合的所有元素。
 *  差集操作是针对第一个集合进行的，即 SDIFF 命令的结果将是存在于第一个集合中但不存在于其他集合中的元素。

### · SDIFFSTORE ###

将多个集合之间的差集存储到一个新的集合中。

**语法：**  
SDIFFSTORE destination key \[key …\]

**参数：**

*  destination：要存储差集的新集合的键名。
 *  key：要取差集的集合的键名，可以指定多个键名。

**返回：**  
返回存储到新集合中的差集元素数量。

**示例：**

SDIFFSTORE diff_set set1 set2

注意事项：

*  如果指定的原始集合不存在，将被视为空集合。
 *  如果 destination 键已存在，它将被覆盖。
 *  差集操作是针对第一个集合进行的，即 SDIFFSTORE 命令将对第一个集合和其他集合之间的差集进行计算，并将结果存储到 destination 集合中。

### · SINTER ###

获取多个集合之间的交集，即获取存在于所有集合中的元素。

**语法：**  
SINTER key \[key …\]

**参数：**

*  key：要取交集的集合的键名，可以指定多个键名。

**返回：**  
返回一个包含交集元素的结果集（即存在于所有集合中的元素）。

**示例：**

SINTER set1 set2

注意事项：

*  如果指定的集合不存在，将被视为空集合。
 *  如果只指定一个键名作为参数，则返回该集合的所有元素。
 *  交集操作会计算所有指定集合中存在的元素，并返回存在于所有集合中的元素。

### · SINTERSTORE ###

将多个集合之间的交集存储到一个新的集合中。

**语法：**  
SINTERSTORE destination key \[key …\]

**参数：**

*  destination：要存储交集的新集合的键名。
 *  key：要取交集的集合的键名，可以指定多个键名。

**返回：**  
返回存储到新集合中的交集元素数量。

**示例：**

SINTERSTORE inter_set set1 set2

注意事项：

*  如果指定的原始集合不存在，将被视为空集合。
 *  如果 destination 键已存在，它将被覆盖。
 *  交集操作会计算所有指定集合中存在的元素

### · SUNION ###

获取多个集合的并集，即返回包含所有指定集合中元素的集合，每个元素在结果集中只会出现一次。

**语法：**  
SUNION key \[key …\]

**参数：**

*  key：要取并集的集合的键名，可以指定多个键名。

**返回：**  
返回一个包含并集元素的结果集，其中包含所有指定集合中的不重复元素。

**示例：**

SUNION set1 set2

注意事项：

*  如果指定的集合不存在，将被视为空集合。
 *  如果只指定一个键名作为参数，则返回该集合的所有元素。
 *  并集操作会合并所有指定集合中的元素，并将所有不重复的元素存储到结果集中。

### · SUNIONSTORE ###

将多个集合的并集存储到一个新的集合中。

**语法：**  
SUNIONSTORE destination key \[key …\]

**参数：**

*  destination：要存储并集的新集合的键名。
 *  key：要取并集的集合的键名，可以指定多个键名。

**返回：**  
返回存储到新集合中的并集元素数量。

**示例：**

SUNIONSTORE union_set set1 set2

注意事项：

*  如果指定的原始集合不存在，将被视为空集合。
 *  如果 destination 键已存在，它将被覆盖。
 *  并集操作会将所有指定集合中的元素合并，并将所有不重复的元素存储到 destination 集合中。

### · SREM ###

从集合中移除一个或多个指定的成员。

**语法：**  
SREM key member \[member …\]

**参数：**

*  key：要操作的集合的键名。
 *  member：要从集合中移除的成员，可以指定多个成员。

**返回：**  
返回被成功移除的成员数量，不包括那些不存在的成员。

**示例：**

SREM set1 orange

注意事项：

*  如果集合不存在或为空集，那么 SREM 命令将不会进行任何操作，并返回 0。
 *  如果指定的成员不在集合中，也会被忽略，并返回被成功移除的成员数量。
 *  如果成功移除了集合中的成员，那么它们将不再在集合中存在。

### · SPOP ###

从集合中随机地移除并返回一个或多个成员。

**语法：**  
SPOP key \[count\]

**参数：**

*  key：要操作的集合的键名。
 *  count：可选参数，指定要移除的成员数量，默认为 1。

**返回：**

*  当未指定 count 参数时，返回被移除的随机成员。
 *  当指定了 count 参数时，返回被移除的成员组成的数组。

**示例：**

SPOP set1 2

注意事项：

*  在集合为空时，SPOP 命令会返回 nil 值。
 *  当指定了 count 参数时，如果集合中的成员数量小于等于 count，那么返回整个集合中的所有成员。

## Zset（有序集合） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">ZADD</td> 
   <td align="left">向有序集合中添加一个或多个成员，或者更新已存在成员的分数</td> 
   <td align="left">ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score member …]</td> 
  </tr> 
  <tr> 
   <td align="left">ZSCORE</td> 
   <td align="left">获取有序集合中指定成员的分数</td> 
   <td align="left">ZSCORE key member</td> 
  </tr> 
  <tr> 
   <td align="left">ZINCRBY</td> 
   <td align="left">为有序集合中的成员增加指定的分数</td> 
   <td align="left">ZINCRBY key increment member</td> 
  </tr> 
  <tr> 
   <td align="left">ZREM</td> 
   <td align="left">从有序集合中移除一个或多个成员</td> 
   <td align="left">ZREM key member [member …]</td> 
  </tr> 
  <tr> 
   <td align="left">ZREMRANGEBYRANK</td> 
   <td align="left">移除有序集合中排名在指定区间内的成员</td> 
   <td align="left">ZREMRANGEBYRANK key start stop</td> 
  </tr> 
  <tr> 
   <td align="left">ZREMRANGEBYSCORE</td> 
   <td align="left">移除有序集合中分数在指定范围内的成员</td> 
   <td align="left">ZREMRANGEBYSCORE key min max</td> 
  </tr> 
  <tr> 
   <td align="left">ZREMRANGEBYLEX</td> 
   <td align="left">移除有序集合中指定字典区间内的成员</td> 
   <td align="left">ZREMRANGEBYLEX key min max</td> 
  </tr> 
  <tr> 
   <td align="left">ZCARD</td> 
   <td align="left">获取有序集合中的成员数量</td> 
   <td align="left">ZCARD key</td> 
  </tr> 
  <tr> 
   <td align="left">ZCOUNT</td> 
   <td align="left">计算有序集合中分数在指定范围内的成员数量</td> 
   <td align="left">ZCOUNT key min max</td> 
  </tr> 
  <tr> 
   <td align="left">ZLEXCOUNT</td> 
   <td align="left">获取有序集合中指定字典区间内的成员数量</td> 
   <td align="left">ZLEXCOUNT key min max</td> 
  </tr> 
  <tr> 
   <td align="left">ZRANGEBYLEX</td> 
   <td align="left">按照字典排序，获取有序集合中指定字典区间内的成员</td> 
   <td align="left">ZRANGEBYLEX key min max [LIMIT offset count]</td> 
  </tr> 
  <tr> 
   <td align="left">ZRANK</td> 
   <td align="left">获取有序集合中成员的排名<br>即成员在有序集合中按分数从小到大排序后的索引位置</td> 
   <td align="left">ZRANK key member</td> 
  </tr> 
  <tr> 
   <td align="left">ZRANGE</td> 
   <td align="left">按照分数从小到大的顺序，获取有序集合中的指定范围内的成员</td> 
   <td align="left">ZRANGE key start stop [WITHSCORES]</td> 
  </tr> 
  <tr> 
   <td align="left">ZRANGEBYSCORE</td> 
   <td align="left">按照分数范围获取有序集合中的成员</td> 
   <td align="left">ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]</td> 
  </tr> 
  <tr> 
   <td align="left">ZREVRANGE</td> 
   <td align="left">按照分数从大到小的顺序，获取有序集合中的指定范围内的成员</td> 
   <td align="left">ZREVRANGE key start stop [WITHSCORES]</td> 
  </tr> 
  <tr> 
   <td align="left">ZREVRANGEBYSCORE</td> 
   <td align="left">按照分数从大到小的顺序，获取有序集合中分数范围内的成员</td> 
   <td align="left">ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]</td> 
  </tr> 
  <tr> 
   <td align="left">ZREVRANK</td> 
   <td align="left">获取有序集合中成员的排名<br>即成员在有序集合中按分数从大到小排序后的索引位置</td> 
   <td align="left">ZREVRANK key member</td> 
  </tr> 
  <tr> 
   <td align="left">ZINTERSTORE</td> 
   <td align="left">计算并存储一个或多个有序集合的交集，并将结果存储在新的有序集合中</td> 
   <td align="left">ZINTERSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]</td> 
  </tr> 
  <tr> 
   <td align="left">ZUNIONSTORE</td> 
   <td align="left">计算并存储一个或多个有序集合的并集，并将结果存储在新的有序集合中</td> 
   <td align="left">ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]</td> 
  </tr> 
 </tbody> 
</table>

### · ZADD ###

向有序集合中添加一个或多个成员，或者更新已存在成员的分数。

**语法：**  
ZADD key \[NX|XX\] \[GT|LT\] \[CH\] \[INCR\] score member \[score member …\]

**参数：**

*  key：要操作的有序集合的键名。
 *  NX：可选参数，表示只在成员不存在时进行添加，不覆盖已存在成员的分数。
 *  XX：可选参数，表示只在成员已存在时进行更新。
 *  LT: 可选参数，更新新的分值比当前分值小的成员，不存在则新增。
 *  GT: 可选参数，更新新的分值比当前分值大的成员，不存在则新增。
 *  CH：可选参数，表示将命令返回的结果由成功添加的成员数量改为成功添加或已更新的成员数量。
 *  INCR：可选参数，表示执行命令后返回成员的当前分数，并将分数自动递增。

**返回：**  
返回成功添加或已更新的成员数量。

**示例：**

ZADD set1 NX CH 80 "Charlie" 95 "David"

向 set1 有序集合中添加了成员 “David” 及其分数，并且采用了 NX 和 CH 参数，成功添加了一个成员。

注意事项：

*  如果有序集合不存在，将会自动创建一个新的有序集合。
 *  成员的分数用于为有序集合中的成员进行排序。
 *  成员的分数可以重复，如果多个成员具有相同的分数，则按照成员的字典顺序进行排序。
 *  使用 NX 参数可以保证只有在成员不存在时进行添加。
 *  使用 XX 参数可以保证只有在成员已存在时进行更新。
 *  使用 CH 参数将命令返回的结果改为成功添加或已更新的成员数量。
 *  使用 INCR 参数可以在添加或更新成员后，自动对成员的分数进行递增。

### · ZINCRBY ###

为有序集合中的成员增加指定的分数。

**语法：**  
ZINCRBY key increment member

**参数：**

*  key：要操作的有序集合的键名。
 *  increment：要增加的分数值，可以是正数或负数。
 *  member：要增加分数的成员。

**返回：**  
返回增加后的成员的新分数。

**示例：**

ZINCRBY set1 5 "Alice"

注意事项：

*  如果成员不存在，则会将其自动添加到有序集合中，并给它设置分数。
 *  使用正数作为 increment 参数可以增加分数，使用负数则可以减少分数。
 *  当有序集合中的成员被成功更新后，其在有序集合中的排序会发生变化。
 *  如果使用的 Redis 版本较旧（< 2.6.0），则 ZINCRBY 命令不支持使用 float 类型的分数，分数只能是整数。从 2.6.0 版本开始，支持 float 类型的分数。

### · ZREM ###

从有序集合中移除一个或多个成员。

**语法：**  
ZREM key member \[member …\]

**参数：**

*  key：要操作的有序集合的键名。
 *  member：要移除的成员。

**返回：**  
返回被成功移除的成员的数量。

**示例：**

ZREM set1 "Bob" "Charlie"

注意事项：

*  如果有序集合不存在或者成员在有序集合中不存在，则命令不会执行任何操作。
 *  成员被移除后，其在有序集合中的排名会相应改变。
 *  ZREM 命令可以一次性移除多个成员，只需要在命令后面添加要移除的成员即可。
 *  ZREM 命令的时间复杂度为 O(log(N))，N 表示有序集合中的成员数量。

### · ZREMRANGEBYRANK ###

移除有序集合中排名在指定区间内的成员。

**语法：**  
ZREMRANGEBYRANK key start stop

**参数：**

*  key：要操作的有序集合的键名。
 *  start：要移除的起始排名（0 表示第一个成员，1 表示第二个成员，以此类推）。
 *  stop：要移除的结束排名。

**返回：**  
返回被成功移除的成员的数量。

**示例：**

ZREMRANGEBYRANK set1 1 3

注意事项：

*  start 和 stop 参数表示的是排名范围，而不是分数的范围。
 *  如果 start 大于有序集合中最大的排名，则不会有任何数据被移除。
 *  如果 stop 大于有序集合中最大的排名，那么 Redis 将移除从 start 开始到有序集合的最后一个成员的所有成员。（可以理解为 stop 被设置为有序集合的最大排名）
 *  ZREMRANGEBYRANK 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示被移除的成员数量。

### · ZREMRANGEBYSCORE ###

移除有序集合中分数在指定范围内的成员。

**语法：**  
ZREMRANGEBYSCORE key min max

**参数：**

*  key：要操作的有序集合的键名。
 *  min：要移除的最小分数。
 *  max：要移除的最大分数。

**返回：**  
返回被成功移除的成员的数量。

**示例：**

ZREMRANGEBYSCORE set1 5 8

注意事项：

*  min 和 max 参数表示的是分数的范围。
 *  如果有序集合中存在多个成员拥有相同的分数，且这些成员的分数都在指定范围内，那么它们都将被移除。
 *  ZREMRANGEBYSCORE 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示被移除的成员数量。

### · ZCARD ###

获取有序集合中的成员数量，也就是获取有序集合的基数。

**语法：**  
ZCARD key

**参数：**

*  key：要操作的有序集合的键名。

**返回：**  
返回有序集合的成员数量。

**示例：**

ZCARD set1

注意事项：

*  如果有序集合不存在，则返回 0。
 *  ZCARD 命令的时间复杂度为 O(1)。

### · ZCOUNT ###

计算有序集合中分数在指定范围内的成员数量。

**语法：**  
ZCOUNT key min max

**参数：**

*  key：要操作的有序集合的键名。
 *  min：要计算的最小分数。
 *  max：要计算的最大分数。

**返回：**  
返回分数在指定范围内的成员数量。

**示例：**

ZCOUNT set1 5 8

注意事项：

*  min 和 max 参数表示的是分数的范围。
 *  如果有序集合中存在多个成员拥有相同的分数，且这些成员的分数都在指定范围内，那么它们都会被计算在内。
 *  ZCOUNT 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示指定范围内的成员数量。

### · ZRANGE ###

按照分数从小到大的顺序，获取有序集合中的指定范围内的成员。

**语法：**  
ZRANGE key start stop \[WITHSCORES\]

**参数：**

*  key：要操作的有序集合的键名。
 *  start：指定范围的起始位置，0 表示第一个成员。
 *  stop：指定范围的结束位置，-1 表示最后一个成员。
 *  WITHSCORES（可选）：当传递了 WITHSCORES 参数时，命令会同时返回成员和其对应的分数。

**返回：**  
返回指定范围内的成员列表。

**示例：**

ZRANGE set1 1 3

注意事项：

*  start 和 stop 参数表示的是成员在有序集合中的索引位置。
 *  索引位置从 0 开始，-1 表示最后一个成员。
 *  可以使用负数作为 start 和 stop 参数的值，表示从末尾开始计数。例如，-2 表示倒数第二个成员。
 *  如果指定范围超出了有序集合的索引范围，命令会自动进行截断。
 *  使用 WITHSCORES 参数可以返回成员及其对应的分数。
 *  ZRANGE 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示返回的成员数量。

### · ZRANGEBYSCORE ###

按照分数范围获取有序集合中的成员。

**语法：**  
ZRANGEBYSCORE key min max \[WITHSCORES\] \[LIMIT offset count\]

**参数：**

*  key：要操作的有序集合的键名。
 *  min：指定范围的最小分数。
 *  max：指定范围的最大分数。
 *  WITHSCORES（可选）：当传递了 WITHSCORES 参数时，命令会同时返回成员和其对应的分数。
 *  LIMIT offset count（可选）：限制返回结果的偏移量和数量。其中，offset 表示偏移量（即从匹配的结果中的第几个开始），count 表示要返回的成员数量。

**返回：**  
返回分数在指定范围内的成员列表。

**示例：**

ZRANGEBYSCORE set1 5 8

注意事项：

*  min 和 max 参数表示的是分数的范围。
 *  使用 WITHSCORES 参数可以返回成员及其对应的分数。
 *  使用 LIMIT 参数可以限制返回结果的偏移量和数量。
 *  ZRANGEBYSCORE 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示返回的成员数量。

### · ZRANK ###

获取有序集合中成员的排名（即成员在有序集合中按分数从小到大排序后的索引位置）。

**语法：**  
ZRANK key member

**参数：**

*  key：要操作的有序集合的键名。
 *  member：要获取排名的成员。

**返回：**  
返回成员在有序集合中的排名（从 0 开始）。如果成员不存在于有序集合中，返回 nil。

**示例：**

ZRANK set1 "Bob"

注意事项：

*  成员在有序集合中的排名从 0 开始，即第一个成员的排名是 0，第二个成员的排名是 1，以此类推。
 *  如果指定的成员不存在于有序集合中，命令会返回 nil。
 *  ZRANK 命令的时间复杂度为 O(log(N))，N 表示有序集合中的成员数量。

### · ZREVRANGE ###

按照分数从大到小的顺序，获取有序集合中的指定范围内的成员。

**语法：**  
ZREVRANGE key start stop \[WITHSCORES\]

**参数：**

**返回：**  
返回指定范围内的成员列表。

**示例：**

ZREVRANGE set1 0 2

注意事项：

*  start 和 stop 参数表示的是成员在有序集合中的索引位置。
 *  索引位置从 0 开始，-1 表示最后一个成员。
 *  可以使用负数作为 start 和 stop 参数的值，表示从末尾开始计数。例如，-2 表示倒数第二个成员。
 *  如果指定范围超出了有序集合的索引范围，命令会自动进行截断。
 *  使用 WITHSCORES 参数可以返回成员及其对应的分数。
 *  ZREVRANGE 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示返回的成员数量。

### · ZREVRANGEBYSCORE ###

按照分数从大到小的顺序，获取有序集合中分数范围内的成员。

**语法：**  
ZREVRANGEBYSCORE key max min \[WITHSCORES\] \[LIMIT offset count\]

**参数：**

*  key：要操作的有序集合的键名。
 *  max：指定范围的最大分数。
 *  min：指定范围的最小分数。
 *  WITHSCORES（可选）：当传递了 WITHSCORES 参数时，命令会同时返回成员和其对应的分数。
 *  LIMIT offset count（可选）：限制返回结果的偏移量和数量。其中，offset 表示偏移量（即从匹配的结果中的第几个开始），count 表示要返回的成员数量。

**返回：**  
返回分数范围内的成员列表。

**示例：**

ZREVRANGEBYSCORE set1 8 5

注意事项：

*  max 和 min 参数表示的是分数的范围。
 *  使用 WITHSCORES 参数可以返回成员及其对应的分数。
 *  使用 LIMIT 参数可以限制返回结果的偏移量和数量。
 *  ZREVRANGEBYSCORE 命令的时间复杂度为 O(log(N)+M)，N 表示有序集合中的成员数量，M 表示返回的成员数量。

### · ZREVRANK ###

获取有序集合中成员的排名（即成员在有序集合中按分数从大到小排序后的索引位置）。

**语法：**  
ZREVRANK key member

**参数：**

*  key：要操作的有序集合的键名。
 *  member：要获取排名的成员。

**返回：**  
返回成员在有序集合中的排名（从 0 开始）。如果成员不存在于有序集合中，返回 nil。

**示例：**

ZREVRANK set1 "Bob"

注意事项：

*  成员在有序集合中的排名从 0 开始，即第一个成员的排名是 0，第二个成员的排名是 1，以此类推。
 *  如果指定的成员不存在于有序集合中，命令会返回 nil。
 *  ZREVRANK 命令的时间复杂度为 O(log(N))，N 表示有序集合中的成员数量。

### · ZSCORE ###

获取有序集合中指定成员的分数。

**语法：**  
ZSCORE key member

**参数：**

*  key：要操作的有序集合的键名。
 *  member：要获取分数的成员。

**返回：**  
返回成员在有序集合中的分数。如果成员不存在于有序集合中，返回 nil。

**示例：**

ZSCORE set1 "Bob"

注意事项：

*  如果指定的成员不存在于有序集合中，命令会返回 nil。
 *  ZSCORE 命令的时间复杂度为 O(1)。

### · ZLEXCOUNT ###

获取有序集合中指定字典区间内的成员数量。

**语法：**  
ZLEXCOUNT key min max

**参数：**

*  key：要操作的有序集合的键名。
 *  min：字典区间的下界（inclusive）。
 *  max：字典区间的上界（inclusive）。

**返回：**  
返回指定字典区间内的成员数量。

**示例：**

ZADD set1 0 "a" 0 "b" 0 "c" 0 "d" 0 "e"
    ZLEXCOUNT set1 [b [d

*  使用 ZADD 命令向 set1 有序集合中添加了五个成员 “a”、“b”、“c”、“d”、“e”，它们的排序是按照字典顺序排列的。
 *  然后使用 ZLEXCOUNT 命令获取了有序集合 set1 中字典区间 \[b 到 \[d 内的成员数量，返回结果为 3，因为在这个范围内有 “b”、“c” 和 “d” 三个成员。

注意事项：

*  字典区间查询是针对有序集合中的成员进行字典顺序的查询。这与普通的由分数进行排序的情况不同。
 *  min 和 max 参数可以使用 - 表示负无穷和 + 表示正无穷。
 *  ZLEXCOUNT 命令的时间复杂度为 O(log(N)+M)，其中 N 为有序集合的基数，M 为结果集的基数。

### · ZRANGEBYLEX ###

按照字典排序获取有序集合中指定字典区间内的成员。

**语法：**  
ZRANGEBYLEX key min max \[LIMIT offset count\]

**参数：**

*  key：要操作的有序集合的键名。
 *  min：字典区间的下界（inclusive）。
 *  max：字典区间的上界（inclusive）。
 *  LIMIT offset count（可选）：指定返回结果的偏移量和数量，用于分页查询。

**返回：**  
返回指定字典区间内的成员列表。

**示例：**

ZADD set1 0 "a" 0 "b" 0 "c" 0 "d" 0 "e"
    ZRANGEBYLEX set1 [b [d

*  首先使用 ZADD 命令向 set1 有序集合中添加了五个成员 “a”、“b”、“c”、“d”、“e”，它们的排序是按照字典顺序排列的。
 *  然后使用 ZRANGEBYLEX 命令获取了有序集合 set1 中字典区间 \[b 到 \[d 内的成员列表，返回结果为 \[“b”, “c”, “d”\]，即符合条件的成员列表。

注意事项：

*  字典区间查询是针对有序集合中的成员进行字典顺序的查询。这与按分数进行排序的情况不同。
 *  min 和 max 参数可以使用 - 表示负无穷和 + 表示正无穷。
 *  可以使用 LIMIT offset count 参数来指定返回结果的偏移量和数量，实现分页查询。
 *  ZRANGEBYLEX 命令的时间复杂度为 O(log(N)+M)，其中 N 为有序集合的基数，M 为结果集的基数。

### · ZREMRANGEBYLEX ###

移除有序集合中指定字典区间内的成员。

**语法：**  
ZREMRANGEBYLEX key min max

**参数：**

*  key：要操作的有序集合的键名。
 *  min：字典区间的下界（inclusive）。
 *  max：字典区间的上界（inclusive）。

**返回：**  
返回被移除的成员数量。

**示例：**

ZADD set1 0 "a" 0 "b" 0 "c" 0 "d" 0 "e"
    ZREMRANGEBYLEX set1 [b [d

*  首先使用 ZADD 命令向 set1 有序集合中添加了五个成员 “a”、“b”、“c”、“d”、“e”，它们的排序是按照字典顺序排列的。
 *  然后使用 ZREMRANGEBYLEX 命令移除了有序集合 set1 中字典区间 \[b 到 \[d 内的成员，返回结果为 3，即移除了三个成员。

注意事项：

*  字典区间查询是针对有序集合中的成员进行字典顺序的查询。这与按分数进行排序的情况不同。
 *  min 和 max 参数可以使用 - 表示负无穷和 + 表示正无穷。
 *  ZREMRANGEBYLEX 命令会同时将属于指定字典区间的成员从有序集合中移除。
 *  ZREMRANGEBYLEX 命令的时间复杂度为 O(log(N)+M)，其中 N 为有序集合的基数，M 为结果集的

### · ZINTERSTORE ###

计算并存储一个或多个有序集合的交集。它将多个有序集合的成员交集（根据给定的权重进行计算），并将结果存储在新的有序集合中。

**语法：**  
ZINTERSTORE destination numkeys key \[key …\] \[WEIGHTS weight \[weight …\]\] \[AGGREGATE SUM|MIN|MAX\]

**参数：**

*  destination：存储计算结果的有序集合键名。
 *  numkeys：参与交集计算的有序集合的数量。
 *  key：参与计算的有序集合的键名。
 *  WEIGHTS weight \[weight …\]（可选）：指定每个有序集合的权重参数，用于计算交集时的权重累加。
 *  AGGREGATE SUM|MIN|MAX（可选）：指定计算交集时使用的聚合函数，可选值为 SUM、MIN 或 MAX，默认为 SUM。

**返回：**  
返回存储在目标有序集合中的交集成员数量。

**示例：**

ZADD set1 1 "a" 2 "b" 3 "c"
    ZADD set2 2 "b" 3 "c" 4 "d"
    ZINTERSTORE set3 2 set1 set2 WEIGHTS 0.5 0.5

*  首先使用 ZADD 命令向 set1 有序集合中添加了三个成员 “a”、“b”、“c”，分别带有权重 1、2 和 3。
 *  然后使用 ZADD 命令向 set2 有序集合中添加了三个成员 “b”、“c”、“d”，分别带有权重 2、3 和 4。
 *  接下来使用 ZINTERSTORE 命令计算 set1 和 set2 的交集，并将结果存储在 set3 中。
 *  权重参数指定了权重累加的方式为均等分配(0.5 0.5)，交集计算结果为有序集合 set3 中的成员为 “b” 和 “c”，并且它们的权重值为 2.5。

注意事项：

*  ZINTERSTORE 命令会覆盖目标有序集合中已有的成员。
 *  如果计算结果为空集，目标有序集合将会被删除。
 *  WEIGHTS 参数可以用于指定每个有序集合的权重，权重值必须是非负数。
 *  AGGREGATE 参数可以用于指定交集计算时使用的聚合函数，默认为 SUM，可选值为 SUM、MIN 或 MAX。
 *  ZINTERSTORE 命令的时间复杂度为 O(NMlog(M))，其中 N 表示参与计算的有序集合的基数，M 表示最小的有序集合的基数。

### · ZUNIONSTORE ###

计算并存储一个或多个有序集合的并集。它将多个有序集合的成员并集（根据给定的权重进行计算），并将结果存储在新的有序集合中。

**语法：**  
ZUNIONSTORE destination numkeys key \[key …\] \[WEIGHTS weight \[weight …\]\] \[AGGREGATE SUM|MIN|MAX\]

**参数：**

*  destination：存储计算结果的有序集合键名。
 *  numkeys：参与并集计算的有序集合的数量。
 *  key：参与计算的有序集合的键名。
 *  WEIGHTS weight \[weight …\]（可选）：指定每个有序集合的权重参数，用于计算并集时的权重累加。
 *  AGGREGATE SUM|MIN|MAX（可选）：指定计算并集时使用的聚合函数，可选值为 SUM、MIN 或 MAX，默认为 SUM。

**返回：**  
返回存储在目标有序集合中的并集成员数量。

**示例：**

ZADD set1 1 "a" 2 "b" 3 "c"
    ZADD set2 2 "b" 3 "c" 4 "d"
    ZUNIONSTORE set3 2 set1 set2 WEIGHTS 0.5 0.5

*  使用 ZADD 命令向 set1 有序集合中添加了三个成员 “a”、“b”、“c”，分别带有权重 1、2 和 3。
 *  然后使用 ZADD 命令向 set2 有序集合中添加了三个成员 “b”、“c”、“d”，分别带有权重 2、3 和 4。
 *  接下来使用 ZUNIONSTORE 命令计算 set1 和 set2 的并集，并将结果存储在 set3 中。
 *  权重参数指定了权重累加的方式为均等分配(0.5 0.5)，并集计算结果为有序集合 set3 中的成员为 “a”、“b”、“c”、“d”，并且它们的权重值为 1.5。

注意事项：

*  ZUNIONSTORE 命令会覆盖目标有序集合中已有的成员。
 *  如果计算结果为空集，目标有序集合将会被删除。
 *  WEIGHTS 参数可以用于指定每个有序集合的权重，权重值必须是非负数。
 *  AGGREGATE 参数可以用于指定并集计算时使用的聚合函数，默认为 SUM，可选值为 SUM、MIN 或 MAX。
 *  ZUNIONSTORE 命令的时间复杂度为 O(NMlog(M))，其中 N 表示参与计算的有序集合的基数，M 表示最小的有序集合的基数。

## Stream（流） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">XADD</td> 
   <td align="left">向指定的 Stream 中添加一条消息</td> 
   <td align="left">XADD key [MAXLEN [~</td> 
  </tr> 
  <tr> 
   <td align="left">XTRIM</td> 
   <td align="left">在指定的 Stream 中修剪（Trim）消息的长度，以控制消息数量并释放空间</td> 
   <td align="left">XTRIM key MAXLEN [~</td> 
  </tr> 
  <tr> 
   <td align="left">XDEL</td> 
   <td align="left">从指定的 Stream 中删除一个或多个消息</td> 
   <td align="left">XDEL key ID [ID …]</td> 
  </tr> 
  <tr> 
   <td align="left">XLEN</td> 
   <td align="left">获取指定 Stream 的长度（即消息的数量）</td> 
   <td align="left">XLEN key</td> 
  </tr> 
  <tr> 
   <td align="left">XRANGE</td> 
   <td align="left">获取指定范围内的消息（或事件）列表</td> 
   <td align="left">XRANGE key start end [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">XREVRANGE</td> 
   <td align="left">按照逆序获取指定范围内的消息（或事件）列表</td> 
   <td align="left">XREVRANGE key end start [COUNT count]</td> 
  </tr> 
  <tr> 
   <td align="left">XREAD</td> 
   <td align="left">从一个或多个流（Stream）中读取（订阅）消息，它可以持续等待新的消息到达</td> 
   <td align="left">XREAD [COUNT count] [BLOCK milliseconds] STREAMS key [ID id]</td> 
  </tr> 
  <tr> 
   <td align="left">XGROUP CREATE</td> 
   <td align="left">创建一个消费者组</td> 
   <td align="left">XGROUP CREATE key groupname id_or_mkconsumer [mkstream]</td> 
  </tr> 
  <tr> 
   <td align="left">XREADGROUP GROUP</td> 
   <td align="left">从流（Stream）中读取消息并将其分配给指定的消费者组</td> 
   <td align="left">XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] STREAMS key [ID gt]</td> 
  </tr> 
  <tr> 
   <td align="left">XACK</td> 
   <td align="left">将消息从消费者组中移除</td> 
   <td align="left">XACK key group ID [ID …]</td> 
  </tr> 
  <tr> 
   <td align="left">XGROUP SETID</td> 
   <td align="left">设置消费者组（Consumer Group）的消费进度</td> 
   <td align="left">XGROUP SETID key group id</td> 
  </tr> 
  <tr> 
   <td align="left">XGROUP DELCONSUMER</td> 
   <td align="left">从消费者组（Consumer Group）中删除指定的消费者</td> 
   <td align="left">XGROUP DELCONSUMER key group consumer</td> 
  </tr> 
  <tr> 
   <td align="left">XGROUP DESTROY</td> 
   <td align="left">销毁消费者组（Consumer Group），同时会将消费者组中的所有未处理消息和待处理消息转移到流的未分组区（未消费消息的默认位置）</td> 
   <td align="left">XGROUP DESTROY key group</td> 
  </tr> 
  <tr> 
   <td align="left">XPENDING</td> 
   <td align="left">获取有关消费者组中待处理消息的信息</td> 
   <td align="left">XPENDING key group [start end count] [consumer]</td> 
  </tr> 
  <tr> 
   <td align="left">XINFO GROUPS</td> 
   <td align="left">获取有关流的消费者组的信息</td> 
   <td align="left">XINFO GROUPS key</td> 
  </tr> 
  <tr> 
   <td align="left">XINFO STREAM</td> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

### · XADD ###

向指定的 Stream 中添加一条消息。

**语法：**  
XADD key \[MAXLEN \[~|=\] count\] \[MAXLEN mode count\] \[ID ID\] field value \[field value …\]

**参数：**

*  key: Stream 的键名。
 *  MAXLEN: 可选参数，用于指定 Stream 的长度限制。
    
     *  ~ 表示采用最大长度限制，即当 Stream 长度超过指定值时，会自动删除最旧的消息。
     *  = 表示精确设置长度限制，如果 Stream 的长度超过指定值，则再次执行 XADD 命令时将无法添加新的消息。
 *  count: Stream 的长度限制值（消息的最大数量）。
 *  mode: 仅在 MAXLEN mode count 语法下使用，指定长度限制的行为。可以是以下两个值之一：
    
     *  NOMORE：超过长度限制时丢弃新消息。
     *  APPROX：超过长度限制时删除最旧的消息。
 *  ID: 可选参数，用于指定消息的 ID。如果未指定，则 Redis 会为新的消息自动生成一个唯一的 ID。
 *  field value: 消息的键值对，可以有多个。

**返回：**  
成功添加消息后，返回新消息的 ID。

**示例：**

添加一条消息到名为 mystream 的 Stream 中：

XADD mystream * field1 value1 field2 value2

添加一条消息到名为 mystream 的 Stream 中，限制 Stream 的长度为 1000 条消息，超过长度时自动删除最旧的消息：

XADD mystream MAXLEN ~ 1000 field1 value1 field2 value2

注意事项

*  XADD 命令用于向指定的 Stream 中添加一条消息。
 *  Stream 的消息可以包含一个或多个键值对。
 *  如果没有明确指定消息的 ID，则 Redis 会自动生成一个唯一的 ID。
 *  可以通过限制 Stream 的长度来控制消息数量，当 Stream 长度超过指定值时，可以选择丢弃新消息或删除最旧的消息。
 *  在添加新消息后，可以获取返回的 ID 来标识新消息。

### · XTRIM ###

在指定的 Stream 中修剪（Trim）消息的长度，以控制消息数量并释放空间。

**语法：**  
XTRIM key MAXLEN \[~|=\] count

**参数：**

*  key: Stream 的键名。
 *  MAXLEN: 用于指定修剪（Trim）消息的长度限制。
    
     *  ~ 表示保留最大长度限制之前的消息。
     *  = 表示精确设置长度限制，如果 Stream 的长度超过指定值，则会删除超出部分的消息。
 *  count: Stream 的长度限制值（消息的最大数量）。

**返回：**  
成功修剪消息后，返回修剪后的 Stream 的长度。

**示例：**

修剪名为 mystream 的 Stream，保留最近的 1000 条消息：

XTRIM mystream MAXLEN ~ 1000

修剪名为 mystream 的 Stream，保留精确的 5000 条消息，如果超过则删除超出部分的消息：

XTRIM mystream MAXLEN = 5000

注意事项

*  XTRIM 命令用于在指定的 Stream 中修剪（Trim）消息的长度。
 *  通过指定最大长度限制，可以控制消息数量并释放空间。
 *  使用 ~ 符号表示保留最大长度限制之前的消息。
 *  使用 = 符号可以精确设置长度限制，并根据需要删除超出部分的消息。
 *  在修剪消息后，可以获取返回的修剪后 Stream 的长度。

### · XDEL ###

从指定的 Stream 中删除一个或多个消息。

**语法：**  
XDEL key ID \[ID …\]

**参数：**

*  key: Stream 的键名。
 *  ID: 要删除的消息的 ID，可以一次性指定一个或多个 ID。

**返回：**  
返回被删除的消息的数量。

**示例：**

从名为 mystream 的 Stream 中删除 ID 为 1605728802574-0 的消息：

XDEL mystream 1605728802574-0

从名为 mystream 的 Stream 中删除多个消息的 ID：

XDEL mystream 1605728802574-0 1605728802574-1 1605728802574-2

注意事项

*  XDEL 命令用于从指定的 Stream 中删除一个或多个消息。
 *  通过指定消息的 ID，可以删除对应的消息。
 *  可以一次性指定一个或多个消息的 ID 进行删除。
 *  返回被删除的消息的数量。

### · XLEN ###

获取指定 Stream 的长度（即消息的数量）。

**语法：**  
XLEN key

**参数：**

*  key: Stream 的键名。

**返回：**  
返回指定 Stream 的长度（即消息的数量）。

**示例：**

获取名为 mystream 的 Stream 的长度：

XLEN mystream

注意事项

*  XLEN 命令用于获取指定 Stream 的长度（即消息的数量）。
 *  通过指定 Stream 的键名，可以获取对应 Stream 的长度。
 *  返回指定 Stream 的长度。

### · XRANGE ###

获取指定范围内的消息（或事件）列表，这些消息是存储在一个给定流（Stream）中的。

**语法：**  
XRANGE key start end \[COUNT count\]

**参数：**

*  key: Stream 的键名。
 *  start: 起始消息的ID，可以使用 - 表示最小的消息ID，例如 - 表示最旧的消息。
 *  end: 结束消息的ID，可以使用 + 表示最大的消息ID，例如 + 表示最新的消息。
 *  COUNT count: （可选参数）指定返回消息的数量。

**返回：**  
返回指定范围内的消息列表，每条消息包括ID和消息内容。

**示例：**

获取名为 mystream 的 Stream 中所有消息:

XRANGE mystream - +

获取名为 mystream 的 Stream 中最新的 10 条消息:

XRANGE mystream 1605728802574-0 + COUNT 10

注意事项

*  XRANGE 命令用于获取指定范围内的消息列表。
 *  通过指定起始消息的ID和结束消息的ID，可以获取在指定范围内的消息。
 *  可以使用 COUNT 参数来指定返回消息的数量。
 *  返回指定范围内的消息列表，每条消息包括ID和消息内容。

### · XREVRANGE ###

按照逆序获取指定范围内的消息（或事件）列表，这些消息是存储在一个给定流（Stream）中的。

**语法：**  
XREVRANGE key end start \[COUNT count\]

**参数：**

*  key: Stream 的键名。
 *  end: 结束消息的ID，可以使用 + 表示最大的消息ID，例如 + 表示最新的消息。
 *  start: 起始消息的ID，可以使用 - 表示最小的消息ID，例如 - 表示最旧的消息。
 *  COUNT count: （可选参数）指定返回消息的数量。

**返回：**  
返回按逆序排列的指定范围内的消息列表，每条消息包括ID和消息内容。

**示例：**

获取名为 mystream 的 Stream 中所有消息的逆序列表：

XREVRANGE mystream + -

获取名为 mystream 的 Stream 中最新的 10 条消息的逆序列表：

XREVRANGE mystream + 1605728802574-0 COUNT 10

注意事项

*  XREVRANGE 命令用于按照逆序获取指定范围内的消息列表。
 *  通过指定结束消息的ID和起始消息的ID，可以获取在指定范围内的消息列表，按逆序排列。
 *  可以使用 COUNT 参数来指定返回消息的数量。
 *  返回按逆序排列的指定范围内的消息列表，每条消息包括ID和消息内容。

### · XREAD ###

从一个或多个流（Stream）中读取（订阅）消息，它可以持续等待新的消息到达。

**语法：**  
XREAD \[COUNT count\] \[BLOCK milliseconds\] STREAMS key \[ID id\]

**参数：**

*  COUNT count: （可选参数）指定每个流应该返回多少个消息。
 *  BLOCK milliseconds: （可选参数）指定阻塞等待新消息的时间（以毫秒为单位），如果没有新消息到达，则超时返回。
 *  key: 一个或多个流的键名。
 *  ID id: （可选参数）与 STREAMS 关键字一起使用，指定从给定消息 ID 之后的消息开始读取。

**返回：**  
返回一个包含流名称和消息的数组。每个消息包含ID和内容。

**示例：**

从名为 mystream 的 Stream 中读取消息并等待新消息到达:

XREAD STREAMS mystream 0

从名为 stream1 和 stream2 的 Stream 中读取最新的 5 条消息:

XREAD COUNT 5 STREAMS stream1 stream2 0

注意事项

*  XREAD 命令用于从一个或多个流中读取消息。
 *  可以通过指定 COUNT 参数来限制每个流中返回的消息数量。
 *  可以通过指定 BLOCK 参数来阻塞等待新消息到达，并设置超时时间。
 *  可以通过指定 ID 参数来指定从特定消息 ID 之后的消息开始读取。
 *  返回一个包含流名称和消息的数组，每个消息包含ID和内容。

### · XGROUP CREATE ###

创建一个消费者组（Consumer Group）。消费者组是用于对流（Stream）进行消费的一种机制，它允许多个消费者协同地处理流中的消息。

**语法：**  
XGROUP CREATE key groupname id\_or\_mkconsumer \[mkstream\]

**参数：**

*  key: 流的键名。
 *  groupname: 消费者组的名称。
 *  id\_or\_mkconsumer: 消费组的消费者ID或者 “$” 符号用于表示消费者组的第一个消费者。
 *  mkstream: （可选参数）在创建消费者组的同时创建流，如果流不存在的话。

**返回：**  
返回创建消费者组的结果。

**示例：**

创建名为 mystream 的流，并创建一个名为 mygroup 的消费者组，并指定消费者为 consumer1:

XGROUP CREATE mystream mygroup consumer1 $

注意事项

*  如果指定的流（Stream）不存在，可以通过 XGROUP CREATE 命令的 mkstream 参数来创建新的流。
 *  如果 id\_or\_mkconsumer 参数为 “$” 符号，表示创建消费者组的第一个消费者。
 *  消费者组是用于分组处理流中消息的消费者集合，可以确保每条消息只有一个消费者处理。
 *  消费者组允许多个消费者并发处理消息，每个消息只会被消费者组中的一个消费者处理。

### · XREADGROUP GROUP ###

从流（Stream）中读取消息并将其分配给指定的消费者组（Consumer Group）。这可以用于实现多个消费者协同处理流中的消息。

**语法：**  
XREADGROUP GROUP group consumer \[COUNT count\] \[BLOCK milliseconds\] STREAMS key \[ID gt\]

**参数：**

*  GROUP group: 指定要读取消息的消费者组的名称。
 *  consumer: 指定用于读取消息的消费者名称。
 *  COUNT count: （可选参数）指定每个流应该返回多少个消息。
 *  BLOCK milliseconds: （可选参数）指定阻塞等待新消息的时间（以毫秒为单位），如果没有新消息到达，则超时返回。
 *  key: 一个或多个流的键名。
 *  ID gt: （可选参数）指定大于给定消息 ID 的消息将被读取，用于继续之前的消费。

**返回：**  
返回一个包含流名称和消息的数组。每个消息包含ID和内容。

**示例：**

从名为 mystream 的 Stream 中读取消息并分配给名为 mygroup 的消费者组中的名为 consumer1 的消费者:

XREADGROUP GROUP mygroup consumer1 STREAMS mystream >

从名为 stream1 和 stream2 的 Stream 中读取最新的 5 条消息并分配给消费者组:

XREADGROUP GROUP mygroup consumer1 COUNT 5 BLOCK 1000 STREAMS stream1 stream2 >

注意事项

*  XREADGROUP GROUP 命令用于从一个或多个 Stream 中读取消息并将其分配给指定的消费者组中的指定消费者。
 *  可以通过指定 COUNT 参数来限制每个流中返回的消息数量。
 *  可以通过指定 BLOCK 参数来阻塞等待新消息到达，并设置超时时间。
 *  可以通过指定 ID 参数来指定大于特定消息 ID 的消息将被读取，用于继续之前的消费。
 *  返回一个包含流名称和消息的数组，每个消息包含ID和内容。

### · XACK ###

将消息从消费者组（Consumer Group）中移除。当一个消费者成功处理了一条消息后，可以使用 XACK 命令将该消息标记为已处理，避免其他消费者重复处理。

**语法：**  
XACK key group ID \[ID …\]

**参数：**

*  key: 流的键名。
 *  group: 消费者组的名称。
 *  ID: 要从消费者组中移除的消息的 ID。

**返回：**  
返回移除消息的结果，即成功移除的消息数量。

**示例：**

移除名为 mystream 的流中消费者组 mygroup 中的消息:

XACK mystream mygroup 1537696289909-0

注意事项

*  XACK 命令用于将消息从消费者组中移除。
 *  需要指定流的键名、消费者组的名称以及要移除的消息的ID。
 *  当一个消费者成功处理了一条消息后，可以使用 XACK 命令将该消息从消费者组中移除，避免其他消费者重复处理。
 *  返回移除成功的消息数量。

### · XGROUP SETID ###

设置消费者组（Consumer Group）的消费进度。可以使用 XGROUP SETID 命令来重置或调整消费者组消费的起始位置。

**语法：**  
XGROUP SETID key group id

**参数：**

*  key: 流的键名。
 *  group: 消费者组的名称。
 *  id: 要设置的起始位置的消息 ID。

**返回：**  
返回设置消费进度的结果。

**示例：**

设置名为 mystream 的流中消费者组 mygroup 的消费进度为 1605965850628-0:

XGROUP SETID mystream mygroup 1605965850628-0

注意事项

*  XGROUP SETID 命令用于设置消费者组的消费进度。
 *  需要指定流的键名、消费者组的名称以及要设置的起始位置的消息ID。
 *  通过设置消费进度可以控制消费者组从哪条消息开始消费流中的消息。
 *  它可以用于重置消费者组的消费进度，或者调整消费进度以重新消费某些消息。
 *  返回设置消费进度的结果。

### · XGROUP DELCONSUMER ###

从消费者组（Consumer Group）中删除指定的消费者。这可以用于停止消费者从流中接收消息。

**语法：**  
XGROUP DELCONSUMER key group consumer

**参数：**

*  key: 流的键名。
 *  group: 消费者组的名称。
 *  consumer: 要删除的消费者的名称。

**返回：**  
返回删除消费者的结果。

**示例：**

从名为 mystream 的流中的消费者组 mygroup 中删除名为 consumer1 的消费者:

XGROUP DELCONSUMER mystream mygroup consumer1

注意事项

*  XGROUP DELCONSUMER 命令用于从消费者组中删除指定的消费者。
 *  需要指定流的键名、消费者组的名称以及要删除的消费者的名称。
 *  当一个消费者不再需要接收流中的消息时，可以使用 XGROUP DELCONSUMER 命令将其从消费者组中删除。
 *  删除消费者后，该消费者将不再接收该消费者组下的消息。
 *  返回删除消费者的结果。

### · XGROUP DESTROY ###

销毁消费者组（Consumer Group），同时会将消费者组中的所有未处理消息和待处理消息转移到流的未分组区（未消费消息的默认位置）。

**语法：**  
XGROUP DESTROY key group

**参数：**

*  key: 流的键名。
 *  group: 要销毁的消费者组名称。

**返回：**  
如果成功销毁消费者组，则返回1；如果消费者组不存在，则返回0。

**示例：**

XGROUP DESTROY mystream mygroup

注意事项

*  XGROUP DESTROY命令用于销毁指定的消费者组。
 *  在销毁消费者组时，所有该消费者组中的未处理消息和待处理消息都会被转移到流的未分组区，等待下一次消费。
 *  销毁消费者组后，消费者组将不再存在，需要重新创建才能继续使用。
 *  如果消费者组不存在，XGROUP DESTROY命令将返回0；如果成功销毁消费者组，则返回1。

### · XPENDING ###

获取有关消费者组中待处理消息的信息。它可以提供有关待处理消息的数量、最早/最新消息的 ID、不同消费者的挂起消息数量等相关信息。

**语法：**  
XPENDING key group \[start end count\] \[consumer\]

**参数：**

*  key: 流的键名。
 *  group: 消费者组的名称。
 *  start、end: 可选参数，用于指定要获取的消息 ID 的范围。
 *  count: 可选参数，用于指定要返回的消息数目的上限。
 *  consumer: 可选参数，用于指定要返回特定消费者的信息。

**返回：**  
返回一个列表，包含有关待处理消息的各种信息。

**示例：**  
获取名为 mystream 的流中消费者组 mygroup 中的待处理消息信息:

XPENDING mystream mygroup

获取名为 mystream 的流中消费者组 mygroup 中的 10 条待处理消息信息:

XPENDING mystream mygroup - + 10

获取名为 mystream 的流中消费者组 mygroup 中消费者 consumer1 的待处理消息信息:

XPENDING mystream mygroup - + 10 consumer1

注意事项

*  XPENDING 命令用于获取消费者组中待处理消息的信息。
 *  需要指定流的键名和消费者组的名称。
 *  可选参数 start 和 end 可用于限制返回的消息 ID 的范围。
 *  可选参数 count 可用于限制返回的消息数量。
 *  可选参数 consumer 可用于获取特定消费者的信息。
 *  返回一个包含有关待处理消息的列表，包括消息的 ID、生产者的 ID、消息的到达时间、消息的未处理时间等信息。

### · XINFO GROUPS ###

获取有关流的消费者组的信息。它提供了有关每个消费者组的名称、正在处理的消息数量、最后一个已经被消费的消息 ID 等相关信息。

**语法：**  
XINFO GROUPS key

**参数：**

*  key: 流的键名。

**返回：**  
返回一个包含有关消费者组的信息的列表。

**示例：**

获取名为 mystream 的流的所有消费者组的信息：

XINFO GROUPS mystream

注意事项

*  XINFO GROUPS 命令用于获取流的消费者组的信息。
 *  需要指定流的键名。
 *  返回一个包含有关消费者组的信息的列表，包括消费者组的名称、已经完成的消费者数量、挂起的消费者数量、已处理的消息数量、最后一个已经被消费的消息 ID 等。

### · XINFO STREAM ###

获取有关流的信息。它提供了有关流的长度、第一个和最后一个消息的 ID、消费者组的数量等相关信息。

**语法：**  
XINFO STREAM key

**参数：**

*  key: 流的键名。

**返回：**  
返回一个包含有关流的信息的列表。

**示例：**

获取名为 mystream 的流的信息：

XINFO STREAM mystream

注意事项

*  XINFO STREAM 命令用于获取流的信息。
 *  需要指定流的键名。
 *  返回一个包含有关流的信息的列表，包括流的长度、第一个和最后一个消息的 ID、最后一个被消费的消息的 ID、消费者组的数量等。

## Pub/Sub（发布/订阅） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">PUBLISH</td> 
   <td align="left">向指定频道发布消息</td> 
   <td align="left">PUBLISH channel message</td> 
  </tr> 
  <tr> 
   <td align="left">SUBSCRIBE</td> 
   <td align="left">订阅一个或多个频道</td> 
   <td align="left">SUBSCRIBE channel [channel …]</td> 
  </tr> 
  <tr> 
   <td align="left">PSUBSCRIBE</td> 
   <td align="left">订阅与给定模式匹配的一个或多个频道</td> 
   <td align="left">PSUBSCRIBE pattern [pattern …]</td> 
  </tr> 
  <tr> 
   <td align="left">UNSUBSCRIBE</td> 
   <td align="left">取消订阅一个或多个频道</td> 
   <td align="left">UNSUBSCRIBE [channel [channel …]]</td> 
  </tr> 
  <tr> 
   <td align="left">PUNSUBSCRIBE</td> 
   <td align="left">取消订阅与给定模式匹配的一个或多个频道</td> 
   <td align="left">PUNSUBSCRIBE [pattern [pattern …]]</td> 
  </tr> 
  <tr> 
   <td align="left">PUBSUB</td> 
   <td align="left">获取关于发布/订阅消息的信息，如查看订阅者数量、查看频道和模式信息等</td> 
   <td align="left">PUBSUB subcommand [argument [argument …]]</td> 
  </tr> 
 </tbody> 
</table>

### · PUBLISH ###

将指定的消息发布到指定的频道。

当有订阅者订阅了相应的频道，它们将收到从该频道发布的消息。

**语法：**  
PUBLISH channel1 “Hello, subscribers!”

**参数：**

*  channel：要发布消息的频道名。
 *  message：要发布的消息内容。

**返回：**  
返回值表示接收到消息的订阅者数量（不包括那些无法接收到消息的订阅者）。

**示例：**

PUBLISH channel1 "Hello, subscribers!"

注意事项

*  PUBLISH 命令用于将消息发布到指定的频道中，以供订阅者接收。
 *  在发布消息前，请确认至少有一个订阅者订阅了该频道，否则消息将无法被接收到。
 *  PUBLISH 命令会向所有订阅了相应频道的客户端广播消息，但不保证消息的顺序。

### · SUBSCRIBE ###

订阅一个或多个频道，以接收这些频道中发布的消息。

**语法：**  
SUBSCRIBE channel \[channel …\]

**参数：**

*  channel：要订阅的频道名。

**返回：**  
在成功执行订阅操作后，SUBSCRIBE 命令将进入订阅模式，不再返回任何结果。当有消息发布到已订阅的频道时，服务器会向客户端发送相应的消息。

**示例：**

SUBSCRIBE channel1 channel2

注意事项

*  SUBSCRIBE 命令用于订阅一个或多个频道，以接收这些频道中发布的消息。
 *  客户端在执行 SUBSCRIBE 命令后将进入订阅模式，此时命令行将显示 “subscribed to channel1, channel2”。
 *  当有消息发布到已订阅的频道时，服务器会向客户端发送相应的消息。在接收消息时，客户端需要使用 PUB/SUB 模式下的特定命令，如 PSUBSCRIBE 等。
 *  当需要取消订阅频道时，可以使用 UNSUBSCRIBE 命令。

### · PSUBSCRIBE ###

**语法：**

**参数：**

**返回：**

**示例：**

### · UNSUBSCRIBE ###

取消订阅一个或多个频道。在客户端不再需要接收指定频道的消息时，可以使用该命令取消订阅。

**语法：**  
UNSUBSCRIBE \[channel \[channel …\]\]

**参数：**

*  channel：要取消订阅的频道名。如果不指定任何频道，表示取消订阅所有频道。

**返回：**  
在成功执行取消订阅操作后，服务器将向客户端返回一个相关的 UNSUBSCRIBE 消息，用于通知客户端已成功取消订阅。

**示例：**

UNSUBSCRIBE channel1 channel2

注意事项

*  UNSUBSCRIBE 命令用于取消订阅一个或多个频道，使客户端不再接收对应频道的消息。
 *  如果不指定任何频道，表示取消订阅所有频道。
 *  在取消订阅后，服务器将向客户端返回一个相关的 UNSUBSCRIBE 消息，用于通知客户端已成功取消订阅。

### · PUNSUBSCRIBE ###

取消订阅模式，即取消与指定模式相关的所有订阅。

**语法：**  
PUNSUBSCRIBE \[pattern \[pattern …\]\]

**参数：**

*  pattern：要取消订阅的模式，可以指定多个模式。

**返回：**  
在成功执行取消订阅操作后，服务器将向客户端返回一个相关的PUNSUBSCRIBE 消息，以通知客户端已成功取消订阅。

**示例：**

PUNSUBSCRIBE news.*

注意事项

*  PUNSUBSCRIBE 命令用于取消与指定模式相关的所有订阅。
 *  如果不指定任何模式，表示取消订阅所有模式。
 *  在取消订阅后，服务器将向客户端返回一个相关的PUNSUBSCRIBE 消息，用于通知客户端已成功取消订阅。

### · PUBSUB ###

获取关于发布/订阅消息的信息，如查看订阅者数量、查看频道和模式信息等。

**语法：**  
PUBSUB subcommand \[argument \[argument …\]\]

**参数：**

*  subcommand: 可以是以下几种子命令之一：
    
     *  CHANNELS \[pattern\]：列出当前至少有一个订阅者的频道。
     *  NUMSUB \[channel-1 … channel-N\]：获取给定频道的订阅者数量。
     *  NUMPAT：获取满足给定模式的订阅数。
 *  pattern: 可选参数，用于匹配频道的模式。

**返回：**  
根据不同的子命令，返回值也会有所不同：

*  对于 CHANNELS 命令，返回一个数组，包含当前至少有一个订阅者的频道名。
 *  对于 NUMSUB 命令，返回一个数组，包含给定频道及其对应的订阅者数量。
 *  对于 NUMPAT 命令，返回满足给定模式的订阅数。

**示例：**

PUBSUB CHANNELS			// 获取当前至少有一个订阅者的频道
    PUBSUB NUMSUB channel1	// 获取指定频道的订阅者数量
    PUBSUB NUMPAT			// 获取满足指定模式的订阅数

注意事项

*  PUBSUB 命令是用于获取发布/订阅消息的信息，包括订阅者数量、频道和模式信息等。
 *  在使用不同的子命令时，需要按照相应的语法传入参数。
 *  了解不同子命令的返回值，以便正确处理获取到的信息。

## Bitmap（位图） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">SETBIT</td> 
   <td align="left">设置位图指定位置的值</td> 
   <td align="left">SETBIT key offset value</td> 
  </tr> 
  <tr> 
   <td align="left">GETBIT</td> 
   <td align="left">获取位图指定位置的值</td> 
   <td align="left">GETBIT key offset</td> 
  </tr> 
  <tr> 
   <td align="left">BITCOUNT</td> 
   <td align="left">统计位图中值为 1 的位的数量</td> 
   <td align="left">BITCOUNT key [start end]</td> 
  </tr> 
  <tr> 
   <td align="left">BITOP</td> 
   <td align="left">对一个或多个位图进行位运算</td> 
   <td align="left">BITOP operation destkey key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">BITPOS</td> 
   <td align="left">在指定范围内查找指定 key 中的第一个位值为 1 或 0 的位置</td> 
   <td align="left">BITPOS key bit [start] [end]</td> 
  </tr> 
  <tr> 
   <td align="left">BITFIELD</td> 
   <td align="left">对位图执行多个位操作</td> 
   <td align="left">BITFIELD key [GET</td> 
  </tr> 
 </tbody> 
</table>

### · SETBIT ###

设置指定位图（Bitmap）中指定偏移量（offset）的位的值。

**语法：**  
SETBIT key offset value

**参数：**

*  key：位图的键名。
 *  offset：偏移量，表示位图中要设置的位的位置。
 *  value：要设置的位的值，可以是 0 或 1。

**返回：**  
设置前位图中偏移量对应的位的值。

**示例：**

SETBIT mybitmap 5 1

注意事项：

*  SETBIT 将指定偏移量的位设置为指定的值。
 *  如果键不存在，Redis 会自动创建一个新的位图。
 *  如果指定偏移量超出位图的长度，Redis 会自动扩展位图的长度。
 *  SETBIT 的偏移量是以位（bit）为单位的，从左到右排序，最左侧的位的偏移量为 0。
 *  SETBIT 返回设置前位图中偏移量对应的位的值。

### · GETBIT ###

获取指定位图（Bitmap）中指定偏移量（offset）的位的值。

**语法：**  
GETBIT key offset

**参数：**

*  key：位图的键名。
 *  offset：偏移量，表示位图中要获取的位的位置。

**返回：**  
指定位图中偏移量对应的位的值，0 或 1。

**示例：**

GETBIT mybitmap 5

注意事项：

*  GETBIT 获取指定偏移量的位的值。
 *  如果键不存在，或者指定偏移量超出位图的长度，GETBIT 返回 0。
 *  GETBIT 的偏移量是以位（bit）为单位的，从左到右排序，最左侧的位的偏移量为 0。
 *  返回的值可以是 0 或 1，分别表示位图中偏移量对应的位的值是 0 或 1。

### · BITCOUNT ###

计算指定 key 中位值为 1 的个数。这个命令通常用于处理位数组、进行特定数据集的统计分析或者计算位图的相关信息。

**语法：**  
BITCOUNT key \[start end\]

**参数：**

*  key：要进行计数的键名。
 *  start：可选参数，指定位图的起始偏移量，默认为 0。
 *  end：可选参数，指定位图的结束偏移量，默认为 -1（表示位图的最后一位）。如果指定 end，那么 start 和 end 都是闭区间。

**返回：**

*  命令执行成功时，返回指定 key 中位值为 1 的个数。
 *  如果 key 不存在，返回 0。

**示例：**

BITCOUNT mykey      	// 统计 mykey 的字符串值中被设置为 1 的比特位的数量
    BITCOUNT mykey 0 1 		// 计数从第 0 个到第 1 个位
    BITCOUNT mykey 0 -1		// 计数从第 0 个到最后一个位
    BITCOUNT mykey -3 -1	// 计数从倒数第 3 个到最后一个位

注意事项

*  当处理大型位图时，BITCOUNT 命令的内存消耗可能较高，请谨慎使用。
 *  在处理大数据集时，BITCOUNT 命令可能会产生较高的计算成本，在生产环境中要注意性能。

### · BITOP ###

对多个 key 进行位操作，并将结果保存到指定的目标 key 中。

该命令支持的位操作包括 AND、OR、XOR 和 NOT。

**语法：**  
BITOP operation destkey key \[key …\]

**参数：**

*  operation：位操作类型，可以是 AND、OR、XOR 或 NOT。
 *  destkey：保存操作结果的目标键名。
 *  key：参与位操作的源键名，可以是一个或多个。

**返回：**

*  命令执行成功时，返回保存操作结果的目标 key 的长度（以字节为单位）。
 *  如果所有 key 的长度都为 0，则目标 key 也为长度 0。
 *  如果 destkey 在执行 BITOP 操作前存在，它将被覆盖。

**示例：**

BITOP AND destkey key1 key2  // 对 key1 和 key2 进行按位 AND 操作，结果存储在 destkey 中

注意事项

*  在进行位操作期间，源键的长度应保持一致。如果长度不一致，则长度短的源键将通过补零进行填充。
 *  执行 BITOP 操作可能对目标键和源键造成临时内存消耗，因此请注意控制键的大小和操作频率。

### · BITPOS ###

在指定范围内查找指定 key 中的第一个位值为 1 或 0 的位置。

该命令可以用于位图、索引和位集合的操作。

**语法：**  
BITPOS key bit \[start\] \[end\]

**参数：**

*  key：进行查找的键名。
 *  bit：要查找的位值，可以是 0 或 1。
 *  start：可选参数，指定查找的起始位置，默认为 0。
 *  end：可选参数，指定查找的结束位置，默认为 -1（表示最后一个位置）。如果指定了 end，那么 start 和 end 都是闭区间。

**返回：**  
如果在指定范围内找到指定的位值，返回其索引位置；如果未找到，返回 -1。  
如果 key 不存在，也返回 -1。

**示例：**

BITPOS key 1 2 2           // 在指定范围内未找到位值为 1 的位置

注意事项

*  位位置是以 0 为起始的索引，最左边的位索引为 0。
 *  BITPOS 命令可以用于位图、索引和位集合的操作，可用于查找特定位值的位置。请根据具体需求使用适当的参数。
 *  在处理大型位图时，BITPOS 命令的复杂度为 O(N)，其中 N 是范围的大小。请注意性能和内存消耗。

### · BITFIELD ###

执行复杂的位级操作，可以对指定偏移量的位进行读取、设置或修改，还可以进行多个位域的组合操作。

**语法：**  
BITFIELD key \[GET type offset\] \[SET type offset value\] \[INCRBY type offset increment\] \[OVERFLOW WRAP|SAT|FAIL\]

**参数：**

*  key：要进行操作的键名。
 *  GET/SET/INCRBY：执行操作的类型，可以是 GET（读取位域）、SET（设置位域）、INCRBY（增加位域的值）之一。
 *  type：位域的类型和长度，例如：u8（8 位无符号整数）、i4（4 位有符号整数）等。
 *  offset：位域的偏移量。
 *  value：要设置的值（仅用于 SET 操作）。
 *  increment：增加的值（仅用于 INCRBY 操作）。
 *  OVERFLOW：指定在执行 INCRBY 操作时发生溢出时的行为，可以是 WRAP（环绕）、SAT（饱和）或 FAIL（失败）。

**返回：**  
根据执行的操作不同，返回不同的结果。执行成功时返回相应的执行结果。

**示例：**

BITFIELD mykey GET u4 0 // 读取 mykey 中索引为 0 的 4 位的无符号整数
    BITFIELD mykey SET u4 0 5 // 将 mykey 中索引为 0 的 4 位设置为无符号整数 5
    BITFIELD mykey INCRBY i4 4 2 // 将 mykey 中索引为 4 的 4 位的有符号整数增加 2
    BITFIELD mykey OVERFLOW WRAP // 设置溢出时的处理方式为环绕

注意事项

*  BITFIELD 命令提供了灵活且复杂的位级操作，可以进行读取、设置和修改位域的值。根据具体需求和业务场景合理选择操作类型和参数。
 *  要特别注意指定的 type 和 offset 参数，确保操作对应正确的位域。
 *  对于 INCRBY 操作，要注意溢出时的处理方式，选择适合业务需求的处理方式。

## Bloom Filter（布隆过滤器） ##

Redis 本身并没有提供布隆过滤器（Bloom Filter）功能。

如果需要使用，需要安装 RedisBloom 模块，这是一个由 Redis 社区开发的开源模块，为 Redis 提供了布隆过滤器的功能。一旦安装了 RedisBloom 模块，你就能够使用相关的命令进行布隆过滤器的管理和操作。

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">BF.ADD</td> 
   <td align="left">将元素添加到布隆过滤器中</td> 
   <td align="left">BF.ADD key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.MADD</td> 
   <td align="left">向布隆过滤器中批量添加多个元素</td> 
   <td align="left">BF.MADD key item [item …]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.EXISTS</td> 
   <td align="left">检查给定元素是否存在于布隆过滤器中</td> 
   <td align="left">BF.EXISTS key item [ITEM …]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.MEXISTS</td> 
   <td align="left">性检查多个元素是否存在于布隆过滤器中</td> 
   <td align="left">BF.MEXISTS key item [item …]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.INFO</td> 
   <td align="left">获取布隆过滤器的信息，包括错误率、容量、哈希函数数量等</td> 
   <td align="left">BF.INFO key</td> 
  </tr> 
  <tr> 
   <td align="left">BF.INSERT</td> 
   <td align="left">在布隆过滤器中插入指定元素</td> 
   <td align="left">BF.INSERT key [ITEMS item [item …]] [CAPACITY capacity] [ERROR error] [EXPANSION expansion] [NO_CREATE] [NONSCALING]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.RESRVE</td> 
   <td align="left">创建一个空的布隆过滤器，设置其预期容量和错误率</td> 
   <td align="left">BF.RESERVE key capacity error [EXPANSION expansion]</td> 
  </tr> 
  <tr> 
   <td align="left">BF.LOADCHUNK</td> 
   <td align="left">在布隆过滤器中生成一个迭代器，可以用于逐步遍历过滤器中的所有元素</td> 
   <td align="left">BF.SCANDUMP key iter</td> 
  </tr> 
  <tr> 
   <td align="left">BF.SCANDUMP</td> 
   <td align="left">将布隆过滤器的一块数据（chunk）加载到 RedisBloom 过滤器中</td> 
   <td align="left">BF.LOADCHUNK key id chunk</td> 
  </tr> 
 </tbody> 
</table>

### · BF.ADD ###

将元素添加到布隆过滤器中。

**语法：**  
BF.ADD key element \[element …\]

**参数：**

*  key 表示布隆过滤器的键名。
 *  element 表示要添加到布隆过滤器中的元素。

**返回：**  
返回一个整数值，表示成功添加到布隆过滤器中的元素数量。

**示例：**

BF.ADD bloomfilter alice

注意事项：

*  布隆过滤器的容量和误判率需要在创建布隆过滤器时指定，因此在使用 BF.ADD 命令前，必须已经创建了对应的布隆过滤器。
 *  元素添加后，可以使用 BF.EXISTS 命令来检查元素是否存在于布隆过滤器中。
 *  在添加元素时，要确保布隆过滤器的容量和误判率适合业务需求，以兼顾准确性和内存消耗。

### · BF.MADD ###

向布隆过滤器中批量添加多个元素。

**语法：**  
BF.MADD key item \[item …\]

**参数：**

*  key：布隆过滤器的键。
 *  item：要添加到布隆过滤器中的元素列表。

**返回：**  
返回一个整数值，表示成功添加到布隆过滤器中的元素数量。

**示例：**

BF.MADD bloomfilter alice bob carol

注意事项：

*  在使用 BF.MADD 命令前，必须已经创建了对应的布隆过滤器。
 *  批量添加元素可以提高效率，尤其是在需要向布隆过滤器中添加大量元素时。
 *  添加元素后，可以使用 BF.EXISTS 命令来检查元素是否存在于布隆过滤器中。

### · BF.EXISTS ###

检查给定元素是否存在于布隆过滤器中。

**语法：**  
BF.EXISTS key item \[ITEM …\]

**参数：**

*  key：布隆过滤器的键。
 *  item：要检查的元素。

**返回：**  
返回一个整数值，表示给定元素是否存在于布隆过滤器中。如果返回值为 1，则表示元素可能存在于布隆过滤器中；如果返回值为 0，则表示元素肯定不存在于布隆过滤器中。

**示例：**

BF.EXISTS bloomfilter alice

注意事项：

*  在使用 BF.EXISTS 命令前，必须已经创建了对应的布隆过滤器。
 *  布隆过滤器具有一定的误判率，因此 BF.EXISTS 命令的返回结果是有一定概率性的。
 *  布隆过滤器的误判率和容量需要在创建布隆过滤器时指定，因此在使用 BF.EXISTS 命令前，要确保布隆过滤器的配置满足业务需求。

### · BF.MEXISTS ###

一次性检查多个元素是否存在于布隆过滤器中。

**语法：**  
BF.MEXISTS key item \[item …\]

**参数：**

*  key: 布隆过滤器的键名
 *  item: 待检查是否存在的元素

**返回：**  
布尔值的数组，每个元素代表对应位置的元素是否存在于布隆过滤器中

**示例：**

BF.MEXISTS myfilter hello world nonexist

注意事项:

*  BF.MEXISTS 命令可以一次性检查多个元素是否存在，但请注意随着元素数量的增加，布隆过滤器的误判率（false positive rate）也会增加。

### · BF.INFO ###

获取布隆过滤器的信息，包括错误率、容量、哈希函数数量等。

**语法：**  
BF.INFO key

**参数：**

*  key：布隆过滤器的键名。

**返回：**  
字符串，包含有关布隆过滤器的信息。

**示例：**

BF.INFO myfilter

注意事项：

*  BF.INFO 命令提供了布隆过滤器的一些重要信息，可以帮助您了解过滤器的性能、容量和误判率等。
 *  布隆过滤器的哈希函数数量和位数组大小都是在创建过滤器时指定的。
 *  误判率表示布隆过滤器在存在性检查中可能出现的误判的概率，通常应该尽量保持低误判率。

### · BF.INSERT ###

在布隆过滤器中插入指定元素。

**语法：**  
BF.INSERT key \[ITEMS item \[item …\]\] \[CAPACITY capacity\] \[ERROR error\] \[EXPANSION expansion\] \[NO\_CREATE\] \[NONSCALING\]

**参数：**

*  key：布隆过滤器的键名。
 *  ITEMS item \[item …\]：要插入的元素。
 *  CAPACITY capacity：可选参数，用于设置布隆过滤器的预期容量。默认值为 100。
 *  ERROR error：可选参数，用于设置布隆过滤器的期望错误率。默认值为 0.01。
 *  EXPANSION expansion：可选参数，用于设置在过滤器容量不足时的扩容速率。默认值为 2.0。
 *  NO\_CREATE：可选参数，如果 key 不存在则不创建新的布隆过滤器。
 *  NONSCALING：可选参数，禁用自动调整容量。

**返回：**  
插入成功的元素的数量。

**示例：**

BF.INSERT myfilter hello world

注意事项：

*  BF.INSERT 命令用于向布隆过滤器中插入元素，可以一次性插入多个元素。
 *  如果指定的布隆过滤器 key 不存在，BF.INSERT 命令会自动创建一个新的布隆过滤器。
 *  如果元素已经存在于布隆过滤器中，则插入操作会被忽略。
 *  布隆过滤器的容量和错误率可以通过参数进行自定义，也可以使用默认值。

### · BF.RESRVE ###

创建一个空的布隆过滤器，设置其预期容量和错误率。

**语法：**  
BF.RESERVE key capacity error \[EXPANSION expansion\]

**参数：**

*  key：布隆过滤器的键名。
 *  capacity：布隆过滤器的预期容量。
 *  error：布隆过滤器的期望错误率。
 *  expansion：可选参数，用于设置在过滤器容量不足时的扩容速率。默认值为 2.0。

**返回：**  
字符串，表示成功创建的布隆过滤器的信息。

**示例：**

BF.RESERVE myfilter 100 0.01

注意事项：

*  BF.RESERVE 命令用于创建一个新的布隆过滤器，并指定其预期容量和错误率。
 *  布隆过滤器的容量决定了可以插入的元素数量，错误率表示在验证元素存在性时可能出现的误判概率。
 *  如果指定的布隆过滤器 key 已经存在，则 BF.RESERVE 命令会抛出错误。
 *  可以使用 EXPANSION 参数设置在布隆过滤器容量不足时的扩容速率。如果不指定 EXPANSION 参数，默认为 2.0。

### · BF.SCANDUMP ###

在布隆过滤器中生成一个迭代器，可以用于逐步遍历过滤器中的所有元素。

**语法：**  
BF.SCANDUMP key iter

**参数：**

*  key：布隆过滤器的键名。
 *  iter：迭代器的标识符。第一次调用时使用 0。

**返回：**  
迭代器（iterator）值，用于后续的 BF.SCANITER 命令。

**示例：**

BF.SCANDUMP myfilter 0

注意事项：

*  BF.SCANDUMP 命令生成一个迭代器，用于逐步获取布隆过滤器中的元素。
 *  迭代器的标识符(iter)会被存储在 Redis 服务器中，因此需要记录并在后续的操作中使用。
 *  如果布隆过滤器的元素数量很大，或者遍历耗时较长，可以使用多个迭代器进行分批处理。
 *  遍历完成后，需要通过 BF.SCANDUMP 命令删除迭代器，以释放相关资源。

### · BF.LOADCHUNK ###

将布隆过滤器的一块数据（chunk）加载到 RedisBloom 过滤器中。

**语法：**  
BF.LOADCHUNK key id chunk

**参数：**

*  key：布隆过滤器的键名。
 *  id：布隆过滤器 chunk 的标识符。
 *  chunk：布隆过滤器的数据块（chunk），以十六进制字符串表示。

**返回：**  
字符串，表示命令执行的状态。

**示例：**

BF.LOADCHUNK myfilter 0 0123456789ABCDEF

注意事项：

*  BF.LOADCHUNK 命令用于将布隆过滤器的数据块加载到 RedisBloom 过滤器中。
 *  数据块（chunk）通常由 BF.SCANDUMP 命令生成，并以十六进制字符串形式保存。
 *  加载数据块可能会增加布隆过滤器的元素数量，并影响错误率。
 *  当数据块加载完成后，建议使用 BF.SCANDUMP 命令删除相关的迭代器。

## HyperLogLog（基数估计） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">PFADD</td> 
   <td align="left">添加一个或多个元素到 HyperLogLog 中</td> 
   <td align="left">PFADD key element [element …]</td> 
  </tr> 
  <tr> 
   <td align="left">PFCOUNT</td> 
   <td align="left">统计 HyperLogLog 中的唯一元素的数量</td> 
   <td align="left">PFCOUNT key [key …]</td> 
  </tr> 
  <tr> 
   <td align="left">PFMERGE</td> 
   <td align="left">合并多个 HyperLogLog</td> 
   <td align="left">PFMERGE destkey sourcekey [sourcekey …]</td> 
  </tr> 
 </tbody> 
</table>

### · PFADD ###

向 HyperLogLog 结构添加一个或多个元素，用于估计集合的基数（不重复元素的数量）。

它的操作速度非常快，并且占用的空间很小。

**语法：**  
PFADD key element \[element …\]

**参数：**

*  key：要添加元素的 HyperLogLog 键名。
 *  element：要添加的元素，可以是一个或多个。

**返回：**

*  返回值为 1 表示至少有一个元素被添加到 HyperLogLog 中。
 *  返回值为 0 表示没有元素被添加到 HyperLogLog 中。

**示例：**

PFADD hllkey "element1" "element2" "element3"

注意事项

*  PFADD 命令用于向 HyperLogLog 结构添加元素，用于估计集合的基数。它不关心元素是否重复，只关心不同元素的数量。
 *  HyperLogLog 结构占用的内存空间相对较小，适合用于大规模数据的基数估计。
 *  尽管 PFADD 命令可以添加多个元素，但请注意一次添加的元素数量不宜过多，以防占用大量内存。

### · PFCOUNT ###

计算 HyperLogLog 结构的基数（不重复元素的数量）。

它可以用于统计、估计集合的大小，具有快速运算和占用较小内存的特点。

**语法：**  
PFCOUNT key \[key …\]

**参数：**

*  key：要计算基数的 HyperLogLog 键名。

**返回：**  
返回值表示计算得到的基数（不重复元素的数量）。

**示例：**

PFCOUNT hllkey

注意事项

*  PFCOUNT 命令用于计算 HyperLogLog 结构的基数，即不重复元素的数量。它可以用于统计、估计集合的大小。
 *  由于 HyperLogLog 结构占用的内存较小，计算基数的速度非常快。
 *  在进行计算前，请确保已经使用 PFADD 命令将元素添加到 HyperLogLog 结构中。

### · PFMERGE ###

合并多个 HyperLogLog 结构，得到一个新的 HyperLogLog 结构，新结构的基数估计值接近于合并前各个结构基数估计值的总和。

**语法：**  
PFMERGE destkey sourcekey \[sourcekey …\]

**参数：**

*  destkey：要存储合并结果的 HyperLogLog 键名。
 *  sourcekey：要合并的多个 HyperLogLog 键名。

**返回：**  
无返回值，在执行成功后，会将合并的结果存储在 destkey 中。

**示例：**

PFMERGE hllkey-merged hllkey1 hllkey2

注意事项

*  PFMERGE 命令用于合并多个 HyperLogLog 结构，得到一个新的 HyperLogLog 结构。合并后的新结构可以用于估计多个 HyperLogLog 结构的整体基数。
 *  注意确保合并的各个 HyperLogLog 结构的键名正确无误，并且确保这些结构中包含了要合并的数据。
 *  在合并时，新的 HyperLogLog 结构的基数估计值接近于合并前各个结构基数估计值的总和。

## Geospatial（地理空间） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">GEOADD</td> 
   <td align="left">向一个地理位置集合中添加一个或多个地理位置对象，并在地理位置集合中建立索引</td> 
   <td align="left">GEOADD key longitude latitude member [longitude latitude member …]</td> 
  </tr> 
  <tr> 
   <td align="left">GEOPOS</td> 
   <td align="left">获取一个或多个地理位置对象在地理位置集合中的经纬度坐标</td> 
   <td align="left">GEOPOS key member [member …]</td> 
  </tr> 
  <tr> 
   <td align="left">GEOHASH</td> 
   <td align="left">获取一个或多个地理位置对象在地理位置集合中的 Geohash 值</td> 
   <td align="left">GEOHASH key member [member …]</td> 
  </tr> 
  <tr> 
   <td align="left">GEODIST</td> 
   <td align="left">计算地理位置集合中两个地理位置对象之间的距离</td> 
   <td align="left">GEODIST key member1 member2 [unit]</td> 
  </tr> 
  <tr> 
   <td align="left">GEORADIUS</td> 
   <td align="left">从地理位置集合中查找指定中心点范围内的地理位置对象</td> 
   <td align="left">GEORADIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key]</td> 
  </tr> 
  <tr> 
   <td align="left">GEORADIUSBYMEMBER</td> 
   <td align="left">从地理位置集合中查找与指定地理位置对象邻近的地理位置对象</td> 
   <td align="left">GEORADIUSBYMEMBER key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STOREDIST key]</td> 
  </tr> 
 </tbody> 
</table>

### · GEOADD ###

向一个地理位置集合（GeoSet）中添加一个或多个地理位置对象，并在地理位置集合中建立索引。

**语法：**  
GEOADD key longitude latitude member \[longitude latitude member …\]

**参数：**

*  key：地理位置集合的键名。
 *  longitude：地理位置的经度，必须是有效的经度值（-180 到 180）。
 *  latitude：地理位置的纬度，必须是有效的纬度值（-90 到 90）。
 *  member：地理位置对象的名称。

**返回：**  
返回添加到地理位置集合中的成员数量。

**示例：**

GEOADD cities 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"

使用 GEOADD 命令向 cities 地理位置集合中添加了两个地理位置对象，分别是 “Palermo” 和 “Catania”。其中 “Palermo” 的经度为 13.361389，纬度为 38.115556；“Catania” 的经度为 15.087269，纬度为 37.502669。

注意事项：

*  GEOADD 命令会自动创建地理位置集合（GeoSet），无需事先创建。
 *  如果地理位置已经存在于地理位置集合中，那么会更新该地理位置的经纬度和成员名称。
 *  GEOADD 命令的时间复杂度为 O(log(N))，其中 N 表示地理位置集合的规模。

### · GEOPOS ###

获取一个或多个地理位置对象在地理位置集合中的经纬度坐标。

**语法：**  
GEOPOS key member \[member …\]

**参数：**

*  key：地理位置集合的键名。
 *  member：地理位置对象的名称。

**返回：**  
返回一个或多个地理位置对象的经纬度坐标。

**示例：**

GEOPOS cities "Palermo" "Catania"

使用 GEOPOS 命令获取了地理位置集合 cities 中 “Palermo” 和 “Catania” 两个地理位置对象的经纬度坐标。

注意事项：

*  GEOPOS 命令返回的经纬度坐标是一个二维数组，表示地理位置的经度和纬度。
 *  如果某个地理位置对象不存在于地理位置集合中，那么返回值中对应该对象的位置将为 nil。
 *  GEOPOS 命令的时间复杂度为 O(log(N))，其中 N 表示查询的地理位置对象数量。

### · GEOHASH ###

获取一个或多个地理位置对象在地理位置集合中的 Geohash 值。

**语法：**  
GEOHASH key member \[member …\]

**参数：**

*  key：地理位置集合的键名。
 *  member：地理位置对象的名称。

**返回：**  
返回一个或多个地理位置对象的 Geohash 值。

**示例：**

GEOHASH cities "Palermo" "Catania"

使用 GEOHASH 命令获取了地理位置集合 cities 中 “Palermo” 和 “Catania” 两个地理位置对象的 Geohash 值。

注意事项：

*  GEOHASH 命令返回的 Geohash 值是一个字符串，表示地理位置的编码。
 *  Geohash 是一种用于地理位置编码的算法，将地理位置信息转换为一串字符串。通过比较 Geohash 值的相似性，我们可以用于计算两个地理位置之间的距离。
 *  GEOHASH 命令的时间复杂度为 O(N)，其中 N 表示查询的地理位置对象数量。

### · GEODIST ###

计算地理位置集合中两个地理位置对象之间的距离。

**语法：**  
GEODIST key member1 member2 \[unit\]

**参数：**

*  key：地理位置集合的键名。
 *  member1：第一个地理位置对象的名称。
 *  member2：第二个地理位置对象的名称。
 *  unit（可选）：距离的单位（默认值为 m），可以是以下值之一：
    
     *  m：米
     *  km：千米
     *  mi：英里
     *  ft：英尺

**返回：**  
返回两个地理位置对象之间的距离。

**示例：**

GEODIST cities "Palermo" "Catania" km

使用 GEODIST 命令计算了地理位置集合 cities 中 “Palermo” 和 “Catania” 两个地理位置对象之间的距离，并指定距离单位为千米。

注意事项：

*  GEODIST 命令返回的距离值是一个双精度浮点数，表示两个地理位置之间的距离。
 *  如果某个地理位置对象不存在于地理位置集合中，或者两个地理位置对象之间没有距离可计算，那么返回值将为 nil。
 *  GEODIST 命令的时间复杂度为 O(log(N))，其中 N 表示地理位置集合的规模。

### · GEORADIUS ###

从地理位置集合中查找指定中心点范围内的地理位置对象。

**语法：**  
GEORADIUS key longitude latitude radius m|km|ft|mi \[WITHCOORD\] \[WITHDIST\] \[WITHHASH\] \[COUNT count\] \[ASC|DESC\] \[STORE key\] \[STOREDIST key\]

**参数：**

*  key：地理位置集合的键名。
 *  longitude：中心点的经度。
 *  latitude：中心点的纬度。
 *  radius：以给定单位度量的半径。
 *  m|km|ft|mi：表示 radius 参数的单位，可以是米、千米、英尺或英里。
 *  WITHCOORD：返回地理位置对象的经度和纬度坐标。
 *  WITHDIST：返回地理位置对象与中心点的距离。
 *  WITHHASH：返回地理位置对象的 Geohash 值。
 *  COUNT count：限制返回结果的数量。
 *  ASC|DESC：对结果进行排序，升序或降序。
 *  STORE key：将结果保存到指定键名的有序集合中。
 *  STOREDIST key：保存结果到指定键名的有序集合，并同时保存地理位置对象与中心点的距离。

**返回：**  
根据命令参数的设置，返回符合条件的地理位置对象的列表或存储结果的键名。

**示例：**

GEORADIUS cities 13.361389 38.115556 200 km WITHDIST WITHCOORD COUNT 10

使用 GEORADIUS 命令查找了地理位置集合 cities 中距离经度 13.361389、纬度 38.115556 点200千米范围内的地理位置对象，并返回了距禿中心点距离、经纬度坐标，并限制了返回结果的数量为 10。

GEORADIUS cities 13.361389 38.115556 200 km COUNT 10  ASC STORE cities1
    
    GEORADIUS cities 13.361389 38.115556 200 km COUNT 10  ASC STOREDIST cities1

注意事项：

*  GEORADIUS 命令可以根据不同的参数设置返回指定范围内符合条件的地理位置对象。
 *  通过 WITHCOORD、WITHDIST、WITHHASH 等参数可以控制返回结果中包含的信息。
 *  结果可以按照距离进行排序（升序或降序），并且可以限制返回结果的数量。
 *  GEORADIUS 命令的时间复杂度为 O(log(N)+M)，其中 N 表示地理位置集合的规模，M 表示返回结果的数量。

### · GEORADIUSBYMEMBER ###

从地理位置集合中查找与指定地理位置对象邻近的地理位置对象。

**语法：**  
GEORADIUSBYMEMBER key member radius m|km|ft|mi \[WITHCOORD\] \[WITHDIST\] \[WITHHASH\] \[COUNT count\] \[ASC|DESC\] \[STORE key\] \[STOREDIST key\]

**参数：**

*  key：地理位置集合的键名。
 *  member：指定的地理位置对象。
 *  radius：以给定单位度量的半径。
 *  m|km|ft|mi：表示 radius 参数的单位，可以是米、千米、英尺或英里。
 *  WITHCOORD：返回地理位置对象的经度和纬度坐标。
 *  WITHDIST：返回地理位置对象与指定对象的距离。
 *  WITHHASH：返回地理位置对象的 Geohash 值。
 *  COUNT count：限制返回结果的数量。
 *  ASC|DESC：对结果进行排序，升序或降序。
 *  STORE key：将结果保存到指定键名的有序集合中。
 *  STOREDIST key：保存结果到指定键名的有序集合，并同时保存地理位置对象与指定对象的距离。

**返回：**  
根据命令参数的设置，返回符合条件的地理位置对象的列表或存储结果的键名。

**示例：**

GEORADIUSBYMEMBER cities "Palermo" 200 km WITHDIST WITHCOORD COUNT 10

使用 GEORADIUSBYMEMBER 命令查找了地理位置集合 cities 中与地理位置对象 “Palermo” 邻近的地理位置对象，并返回了距离和经纬度坐标，并限制了返回结果的数量为 10。

GEORADIUSBYMEMBER cities "Palermo" 200 km COUNT 10 ASC STORE cities1
    
    GEORADIUSBYMEMBER cities "Palermo" 200 km COUNT 10 ASC STOREDIST cities1

注意事项：

*  GEORADIUSBYMEMBER 命令可以根据指定的地理位置对象查找邻近的地理位置对象。
 *  可以通过 WITHCOORD、WITHDIST、WITHHASH 等参数来控制返回结果中包含的信息。
 *  结果可以按照距离进行排序（升序或降序），并且可以限制返回结果的数量。
 *  GEORADIUSBYMEMBER 命令的时间复杂度为 O(log(N)+M)，其中 N 表示地理位置集合的规模，M 表示返回结果的数量。

## Transaction（事务） ##

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
   <th align="left">示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">MULTI</td> 
   <td align="left">标记一个事务块的开始。</td> 
   <td align="left">MULTI</td> 
   <td align="left">MULTI</td> 
  </tr> 
  <tr> 
   <td align="left">EXEC</td> 
   <td align="left">执行事务块中的所有命令。</td> 
   <td align="left">EXEC</td> 
   <td align="left">EXEC</td> 
  </tr> 
  <tr> 
   <td align="left">WATCH</td> 
   <td align="left">监视一个或多个键，用于在事务执行期间检测到键发生变化时取消事务。</td> 
   <td align="left">WATCH key1 [key2 …]</td> 
   <td align="left">WATCH key1 key2</td> 
  </tr> 
  <tr> 
   <td align="left">UNWATCH</td> 
   <td align="left">取消对所有键的监视。</td> 
   <td align="left">UNWATCH</td> 
   <td align="left">UNWATCH</td> 
  </tr> 
  <tr> 
   <td align="left">DISCARD</td> 
   <td align="left">取消当前事务。</td> 
   <td align="left">DISCARD</td> 
   <td align="left">DISCARD</td> 
  </tr> 
 </tbody> 
</table>

使用示例：

MULTI                 # 标记一个事务的开始
    GET mykey             # 读取当前mykey的值
    SET mykey "NewValue"  # 修改mykey的值
    EXEC                  # 执行事务

*  使用MULTI命令开始一个事务块。
 *  使用GET命令读取键mykey的当前值。
 *  使用SET命令修改键mykey的值为"NewValue"。
 *  使用EXEC命令执行事务。

在MULTI和EXEC之间的命令会被作为一个事务执行，如果某个命令执行失败，那么整个事务都会回滚。

## Scripting（LUA脚本） ##

Redis支持使用Lua脚本执行原子操作，Lua脚本在Redis服务器端执行，可以避免多次网络往返。通过执行Lua脚本，可以实现复杂的逻辑和操作，例如条件判断和循环等。

使用Lua脚本，可以使用EVAL或者EVALSHA命令来执行脚本。EVAL命令接受完整的Lua脚本作为参数，而EVALSHA命令接受已经执行过的脚本的SHA1哈希值作为参数。

<table> 
 <thead> 
  <tr> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
   <th align="left">格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">EVAL</td> 
   <td align="left">执行给定的Lua脚本</td> 
   <td align="left">EVAL script numkeys key [key …] arg [arg …]</td> 
  </tr> 
  <tr> 
   <td align="left">EVALSHA</td> 
   <td align="left">执行预先缓存的Lua脚本，通过脚本的SHA1哈希值来标识脚本</td> 
   <td align="left">EVALSHA sha1 numkeys key [key …] arg [arg …]</td> 
  </tr> 
 </tbody> 
</table>

示例：

EVAL "return 2+2" 0

执行了一个简单的Lua脚本，计算了2+2的值。

EVALSHA abf7ef848f97a50d28e452df8e3f131732f36bcf 0

执行了一个已经缓存的Lua脚本，该脚本的SHA1哈希值为abf7ef848f97a50d28e452df8e3f131732f36bcf。

参考：[https://redis.com.cn/commands.html][https_redis.com.cn_commands.html]

[91a4222fb9d842f896dcc7a440cd117b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/0a3591e5bc2446ea87ef72c8ba3ae04a.png
[fa014466f79a4f81a7a3f11e5ce62922.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/b814573f17f54e22b973ada113d744e4.png
[https_redis.com.cn_commands.html]: https://redis.com.cn/commands.html