Redis 备忘清单
===
本备忘单旨在快速理解 [redis](https://redis.io/) 所涉及的主要概念，提供了最常用的SQL语句，供您参考。
入门
---
### 介绍
Redis 是一个 `key-value` 存储系统类似 Memcached
- 它支持存储的 value 类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set 有序集合)和hash(哈希类型)
- 数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作
启动 Redis
```shell
$ redis-server &
```
使用 CLI 登陆 redis
```shell
$ redis-cli
```
使用 Telnet 的登陆 redis
```shell
$ telnet 127.0.0.1 6379
```
### 小试
#### Ping 测试
```shell
redis> PING
PONG
```
#### 经典 Hello World
```shell
redis> SET mykey "Hello world"
OK
redis> GET mykey
"Hello world"
```
### 数据类型
- [Strings(字符串)](#redis-字符串类型设置)
- [Lists(列表)](#redis-列表类型设置)
- [Hashes(哈希)](#redis-哈希类型设置)
- [Sets(集合)](#redis-集合类型设置)
- [Sorted Sets(有序集合)](#redis-排序集类型设置)
Redis 支持以上 5 种数据类型
Redis服务相关的命令设置
------------
### COMMAND
```
COMMAND
```
#### 例子
```shell
redis> COMMAND
1) 1) "georadius_ro"
2) (integer) -6
3) 1) "readonly"
2) "movablekeys"
4) (integer) 1
5) (integer) 1
6) (integer) 1
7) 1) "@read"
2) "@geo"
3) "@slow"
2) 1) "zpopmin"
2) (integer) -2
3) 1) "write"
2) "fast"
........
```
获取 Redis 命令详细信息的数组
### 一些引用(可能有帮助)
<!--rehype:wrap-class=col-span-2 row-span-4-->
:- | --
:- | --
[ACL LOAD](https://redis.io/commands/acl-load) | 从配置的 ACL 文件重新加载 ACL
[ACL SAVE](https://redis.io/commands/acl-save) | 将当前的 ACL 规则保存在配置的 ACL 文件中
[ACL LIST](https://redis.io/commands/acl-list) | 以 ACL 配置文件格式列出当前的 ACL 规则
[ACL USERS](https://redis.io/commands/acl-users) | 列出所有配置的ACL规则的用户名
[ACL GETUSER](https://redis.io/commands/acl-getuser) | 获取特定 ACL 用户的规则
[ACL SETUSER](https://redis.io/commands/acl-setuser) | 修改或创建特定 ACL 用户的规则
[ACL DELUSER](https://redis.io/commands/acl-deluser) | 删除指定的 ACL 用户和关联的规则
[ACL CAT](https://redis.io/commands/acl-cat) | 列出 ACL 类别或类别内的命令
[ACL GENPASS](https://redis.io/commands/acl-genpass) | 生成用于 ACL 用户的伪随机安全密码
[ACL WHOAMI](https://redis.io/commands/acl-whoami) | 返回关联到当前连接的用户的名称
[ACL LOG](https://redis.io/commands/acl-log) | 列出由于 ACL 到位而被拒绝的最新事件
[ACL HELP](https://redis.io/commands/acl-help) | 显示有关ACL访问控制的帮助信息
[BGREWRITEAOF](https://redis.io/commands/bgrewriteaof) | 异步重写 append-only 文件
[BGSAVE](https://redis.io/commands/bgsave) | 将数据集异步保存到磁盘
[CONFIG GET](https://redis.io/commands/config-get) | 获取配置参数的值
[CONFIG REWRITE](https://redis.io/commands/config-rewrite) | 用内存中的配置重写配置文件
[CONFIG SET](https://redis.io/commands/config-set) | 将配置参数设置为给定值
[CONFIG RESETSTAT](https://redis.io/commands/config-resetstat) | 重置 INFO 返回的统计数据
[DBSIZE](https://redis.io/commands/dbsize) | 返回所选数据库中的键数
[DEBUG OBJECT](https://redis.io/commands/debug-object) | 获取某个key的调试信息
[DEBUG SEGFAULT](https://redis.io/commands/debug-segfault) | 使服务器崩溃
[FLUSHALL](https://redis.io/commands/flushall) | 从所有数据库中删除所有密钥
[FLUSHDB](https://redis.io/commands/flushdb) | 从当前数据库中删除所有键
[LOLWUT](https://redis.io/commands/lolwut) | 显示一些计算机信息和 Redis 版本
[LASTSAVE](https://redis.io/commands/lastsave) | 获取上次成功保存到磁盘的 UNIX 时间戳
[MEMORY DOCTOR](https://redis.io/commands/memory-doctor) | 输出内存问题报告
[MEMORY HELP](https://redis.io/commands/memory-help) | 显示有关内存的使用帮助
[MEMORY MALLOC-STATS](https://redis.io/commands/memory-malloc-stats) | 显示分配器内部统计
[MEMORY PURGE](https://redis.io/commands/memory-purge) | 要求分配器释放内存
[MEMORY STATS](https://redis.io/commands/memory-stats) | 显示内存使用详情(该死，运维的我经常用到)
[MEMORY USAGE](https://redis.io/commands/memory-usage) | 估计一个键的内存使用
[MODULE LIST](https://redis.io/commands/module-list) | 列出服务器加载的所有模块
[MODULE LOAD](https://redis.io/commands/module-load) | 加载模块
[MODULE UNLOAD](https://redis.io/commands/module-unload) | 卸载模块
[MONITOR](https://redis.io/commands/monitor) | 实时监听服务器收到的所有请求
[SAVE](https://redis.io/commands/save) | 将数据集同步保存到磁盘
[SHUTDOWN](https://redis.io/commands/shutdown) | 将数据集同步保存到磁盘，然后关闭服务器
[~~SLAVEOF~~](https://redis.io/commands/slaveof) | 使服务器成为另一个实例的副本，或将其提升为主服务器<br> _(从Redis 5开始<red>弃用</red>，改成 `REPLICAOF`了)_
[REPLICAOF](https://redis.io/commands/replicaof) | 使服务器成为另一个实例的副本，或将其提升为主服务器
[SLOWLOG](https://redis.io/commands/slowlog) | 管理 Redis 慢查询日志
[SWAPDB](https://redis.io/commands/swapdb) | 交换两个Redis数据库
[SYNC](https://redis.io/commands/sync) | 用于复制的内部命令(主)
[PSYNC](https://redis.io/commands/psync) | 用于复制的内部命令(备)
[LATENCY DOCTOR](https://redis.io/commands/latency-doctor) | 返回人类可读的延迟分析报告
[LATENCY GRAPH](https://redis.io/commands/latency-graph) | 返回事件的延迟图
[LATENCY HISTORY](https://redis.io/commands/latency-history) | 返回事件的时间戳延迟样本
[LATENCY LATEST](https://redis.io/commands/latency-latest) | 返回所有事件的最新延迟样本
[LATENCY RESET](https://redis.io/commands/latency-reset) | 重置一个或多个事件的延迟数据
[LATENCY HELP](https://redis.io/commands/latency-help) | 显示有关不同子命令的有用文本
### COMMAND COUNT
```
COMMAND COUNT
```
#### 例子
```shell
redis> COMMAND COUNT
(integer) 217
```
获取 Redis 命令总数
### COMMAND GETKEYS
```
COMMAND GETKEYS
```
#### 例子
```shell
redis> COMMAND GETKEYS MSET a b c d e f
1) "a"
2) "c"
3) "e"
redis> COMMAND GETKEYS EVAL "not consulted" 3 key1 key2 key3 arg1 arg2 arg3 argN
1) "key1"
2) "key2"
3) "key3"
redis> COMMAND GETKEYS SORT mylist ALPHA STORE outlist
1) "mylist"
2) "outlist"
```
给定完整的 Redis 命令提取密钥
### COMMAND INFO
```
COMMAND INFO command-name [command-name ...]
```
#### 例子
```shell
redis> COMMAND INFO get set eval
1) 1) "get"
2) (integer) 2
3) 1) "readonly"
2) "fast"
4) (integer) 1
5) (integer) 1
6) (integer) 1
7) 1) "@read"
2) "@string"
3) "@fast"
2) 1) "set"
2) (integer) -3
3) 1) "write"
2) "denyoom"
4) (integer) 1
5) (integer) 1
6) (integer) 1
7) 1) "@write"
2) "@string"
3) "@slow"
3) 1) "eval"
2) (integer) -3
3) 1) "noscript"
2) "movablekeys"
4) (integer) 0
5) (integer) 0
6) (integer) 0
7) 1) "@slow"
2) "@scripting"
```
获取特定 Redis 命令详细信息的数组
### INFO
```
INFO [section]
```
#### 例子
```shell
redis> INFO
# Server
redis_version:6.1.240
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:a26db646ea64a07c
redis_mode:standalone
os:Linux 5.4.0-1017-aws x86_64
......
```
获取有关服务器的信息和统计信息
### ROLE
```
ROLE
```
#### 例子
```shell
redis> ROLE
1) "master"
2) (integer) 0
3) (empty list or set)
```
返回实例在复制上下文中的角色
### TIME
```
TIME
```
#### 例子
```shell
redis> TIME
1) "1609040690"
2) "558952"
redis> TIME
1) "1609040690"
2) "559206"
```
返回当前服务器时间
Redis一些通用的命令
------------
### 一些引用(可能有帮助)
:- | --
:- | --
[COPY](https://redis.io/commands/copy) | 复制键值对
[MIGRATE](https://redis.io/commands/migrate) | 以原子方式将键值对从 Redis 实例传输到另一个实例
[MOVE](https://redis.io/commands/move) | 将键值对移动到另一个数据库
[OBJECT](https://redis.io/commands/object) | 检查 Redis 对象的内部结构
[RESTORE](https://redis.io/commands/restore) | 使用提供的序列化值创建键值对，之前使用 DUMP 获得
[SORT](https://redis.io/commands/sort) | 对列表、集合或有序集合中的元素进行排序
[WAIT](https://redis.io/commands/wait) | 等待在当前连接的上下文中发送的所有写命令的同步复制
[SCAN](https://redis.io/commands/scan) | 增量迭代键空间
### DEL
```
DEL key [key ...]
```
#### 例子
```shell
redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> DEL key1 key2 key3
(integer) 2
```
删除键值对
### DUMP
```
DUMP key
```
#### 例子
```shell
redis> SET mykey 10
"OK"
redis> DUMP mykey
"\u0000\xC0\n\t\u0000\xBEm\u0006\x89Z(\u0000\n"
```
返回存储在指定键中的值的序列化版本
### EXISTS
```
EXISTS key [key ...]
```
#### 例子
```shell
redis> SET key1 "Hello"
"OK"
redis> EXISTS key1
(integer) 1
redis> EXISTS nosuchkey
(integer) 0
redis> SET key2 "World"
"OK"
redis> EXISTS key1 key2 nosuchkey
(integer) 2
```
判断键值对是否存在
### EXPIRE
```
EXPIRE key seconds
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10
redis> SET mykey "Hello World"
"OK"
redis> TTL mykey
(integer) -1
```
设置键值对的生存时间(以秒为单位)
### EXPIREAT
```
EXPIREAT key timestamp
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> EXISTS mykey
(integer) 1
redis> EXPIREAT mykey 1293840000
(integer) 1
redis> EXISTS mykey
(integer) 0
```
将键值对的到期时间设置为 UNIX 时间戳
### KEYS
```
KEYS pattern
```
#### 例子
```shell
redis> MSET firstname Jack lastname Stuntman age 35
"OK"
redis> KEYS *name*
1) "firstname"
2) "lastname"
redis> KEYS a??
1) "age"
redis> KEYS *
1) "firstname"
2) "age"
3) "lastname"
```
查找与给定模式匹配的所有键
### PERSIST
```
PERSIST key
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10
redis> PERSIST mykey
(integer) 1
redis> TTL mykey
(integer) -1
```
从键值对中删除过期时间
### PEXPIRE
```
PEXPIRE key milliseconds
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> PEXPIRE mykey 1500
(integer) 1
redis> TTL mykey
(integer) 1
redis> PTTL mykey
(integer) 1499
```
设置键的生存时间(以毫秒为单位)
### PEXPIREAT
```
PEXPIREAT key milliseconds-timestamp
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> PEXPIREAT mykey 1555555555005
(integer) 1
redis> TTL mykey
(integer) -2
redis> PTTL mykey
(integer) -2
```
将键值对的到期时间设置为以毫秒为单位指定的 UNIX 时间戳
### PTTL
```
PTTL key
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 1
(integer) 1
redis> PTTL mykey
(integer) 1000
```
以毫秒为单位获取键值对的生存时间
### RENAME
```
RENAME key newkey
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> RENAME mykey myotherkey
"OK"
redis> GET myotherkey
"Hello"
```
重命名键值对
### RENAMENX
```
RENAMENX key newkey
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> SET myotherkey "World"
"OK"
redis> RENAMENX mykey myotherkey
(integer) 0
redis> GET myotherkey
"World"
```
重命名键值对，仅当新键值对不存在时
### TOUCH
```
TOUCH key [key ...]
```
#### 例子
```shell
redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> TOUCH key1 key2
(integer) 2
```
更改键值对的最后访问时间。返回指定的现有键的数量
### TTL
```
TTL key
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10
```
获得一个键的值的时间(有点绕口，但意思是对的)
### TYPE
```
TYPE key
```
#### 例子
```shell
redis> SET key1 "value"
"OK"
redis> LPUSH key2 "value"
(integer) 1
redis> SADD key3 "value"
(integer) 1
redis> TYPE key1
"string"
redis> TYPE key2
"list"
redis> TYPE key3
"set"
```
确定存储在键中的类型
### UNLINK
```
UNLINK key [key ...]
```
#### 例子
```shell
redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> UNLINK key1 key2 key3
(integer) 2
```
在另一个线程中异步删除一个键。否则它就像 DEL，但不是阻塞的
Redis 连接相关的命令
------
### 一些引用(可能有帮助)
<!--rehype:wrap-class=row-span-2-->
:- | --
:- | --
[AUTH](https://redis.io/commands/auth) | 向服务器进行身份验证
[CLIENT CACHING](https://redis.io/commands/client-caching) | 指示服务器在下一个请求中是否跟踪键
[CLIENT KILL](https://redis.io/commands/client-kill) | 终止客户端的连接
[CLIENT LIST](https://redis.io/commands/client-list) | 获取客户端连接列表
[CLIENT GETNAME](https://redis.io/commands/client-getname) | 获取当前连接名称
[CLIENT GETREDIR](https://redis.io/commands/client-getredir) | 获取跟踪通知重定向客户端 ID(如果有)
[CLIENT PAUSE](https://redis.io/commands/client-pause) | 停止处理来自客户端的命令一段时间
[CLIENT REPLY](https://redis.io/commands/client-reply) | 指示服务器是否回复命令
[CLIENT SETNAME](https://redis.io/commands/client-setname) | 设置当前连接名称
[CLIENT TRACKING](https://redis.io/commands/client-tracking) | 启用或禁用服务器辅助客户端缓存支持
[CLIENT UNBLOCK](https://redis.io/commands/client-unblock) | 取消阻止来自不同连接的阻塞命令中阻塞的客户端
[HELLO](https://redis.io/commands/hello) | 切换Redis协议
[QUIT](https://redis.io/commands/quit) | 关闭连接
[RESET](https://redis.io/commands/reset) | 重置连接
[SELECT](https://redis.io/commands/select) | 更改为当前连接选择的数据库
### CLIENT ID
```shell
CLIENT ID
```
#### 例子
```shell
redis> CLIENT ID
ERR Unknown or disabled command 'CLIENT'
```
返回当前连接的客户端 ID
### CLIENT INFO
```shell
CLIENT INFO
```
#### 例子
```shell
redis> CLIENT INFO
"id=55542 addr=127.0.0.1:58710 laddr=127.0.0.1:6379 fd=8 name= age=114920 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=40928 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 events=r cmd=client user=default redir=-1\n"
```
返回有关当前客户端连接的信息。
### ECHO
```shell
ECHO message
```
#### 例子
```shell
redis> ECHO "Hello World!"
"Hello World!"
```
回显给定的字符串
### PING
```shell
PING [message]
```
#### 例子
```shell
redis> PING
"PONG"
redis> PING "hello world"
"hello world"
```
ping 服务器
Redis 字符串类型设置
------------
### APPEND
```shell
APPEND key value
```
#### 例子
```shell
redis> EXISTS mykey
(integer) 0
redis> APPEND mykey "Hello"
(integer) 5
redis> APPEND mykey " World"
(integer) 11
redis> GET mykey
"Hello World"
```
将值附加到键,可以理解为追加作用
### BITCOUNT
```shell
BITCOUNT key [start end]
```
#### 例子
```shell
redis> SET mykey "foobar"
"OK"
redis> BITCOUNT mykey
(integer) 26
redis> BITCOUNT mykey 0 0
(integer) 4
redis> BITCOUNT mykey 1 1
(integer) 6
```
计算字符串中的集合位
### BITFIELD
```shell
BITFIELD key [GET type offset] [SET type offset value]
[INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]
```
#### 例子
```shell
redis> BITFIELD mykey INCRBY i5 100 1 GET u4 0
1) (integer) 1
2) (integer) 0
```
对字符串执行任意位域整数运算
### BITOP
```shell
BITOP operation destkey key [key ...]
```
#### 例子
```shell
redis> SET key1 "foobar"
"OK"
redis> SET key2 "abcdef"
"OK"
redis> BITOP AND dest key1 key2
(integer) 6
redis> GET dest
"`bc`ab"
```
在字符串之间执行按位运算
### BITPOS
```shell
BITPOS key bit [start] [end]
```
#### 例子
```shell
redis> SET mykey "\xff\xf0\x00"
"OK"
redis> BITPOS mykey 0
(integer) 12
redis> SET mykey "\x00\xff\xf0"
"OK"
redis> BITPOS mykey 1 0
(integer) 8
redis> BITPOS mykey 1 2
(integer) 16
redis> set mykey "\x00\x00\x00"
"OK"
redis> BITPOS mykey 1
(integer) -1
```
查找字符串中设置或清除的第一位
### DECR
```shell
DECR key
```
#### 例子
```shell
redis> SET mykey "10"
"OK"
redis> DECR mykey
(integer) 9
redis> SET mykey "234293482390480948029348230948"
"OK"
redis> DECR mykey
ERR ERR value is not an integer or out of range
```
将键的整数值减一
### DECRBY
```shell
DECRBY key decrement
```
#### 例子
```shell
redis> SET mykey "10"
"OK"
redis> DECRBY mykey 3
(integer) 7
```
将键的整数值减去给定的数字
### GET
```shell
GET key
```
#### 例子
```shell
redis> GET nonexisting
(nil)
redis> SET mykey "Hello"
"OK"
redis> GET mykey
"Hello"
```
获取key的值
### GETBIT
```shell
GETBIT key offset
```
#### 例子
```shell
redis> SETBIT mykey 7 1
(integer) 0
redis> GETBIT mykey 0
(integer) 0
redis> GETBIT mykey 7
(integer) 1
redis> GETBIT mykey 100
(integer) 0
```
返回存储在 `key` 处的字符串值中 `offset` 处的位值
### GETRANGE
```shell
GETRANGE key start end
```
#### 例子
```shell
redis> SET mykey "This is a string"
"OK"
redis> GETRANGE mykey 0 3
"This"
redis> GETRANGE mykey -3 -1
"ing"
redis> GETRANGE mykey 0 -1
"This is a string"
redis> GETRANGE mykey 10 100
"string"
```
获取存储在键中的字符串的子字符串
### GETSET
```shell
GETSET key value
```
#### 例子
```shell
redis> INCR mycounter
(integer) 1
redis> GETSET mycounter "0"
"1"
redis> GET mycounter
"0"
```
设置键的字符串值并返回其旧值
### INCR
```shell
INCR key
```
#### 例子
```shell
redis> SET mykey "10"
"OK"
redis> INCR mykey
(integer) 11
redis> GET mykey
"11"
```
将键的整数值加一
### MSETNX
```shell
MSETNX key value [key value ...]
```
#### 例子
```shell
redis> MSETNX key1 "Hello" key2 "there"
(integer) 1
redis> MSETNX key2 "new" key3 "world"
(integer) 0
redis> MGET key1 key2 key3
1) "Hello"
2) "there"
3) (nil)
```
仅当不存在任何键时，将多个键设置为多个值
### INCRBYFLOAT
```shell
INCRBYFLOAT key increment
```
#### 例子
```shell
redis> SET mykey 10.50
"OK"
redis> INCRBYFLOAT mykey 0.1
"10.6"
redis> INCRBYFLOAT mykey -5
"5.6"
redis> SET mykey 5.0e3
"OK"
redis> INCRBYFLOAT mykey 2.0e2
"5200"
```
将键的浮点值增加给定的数量
### MGET
```shell
MGET key [key ...]
```
#### 例子
```shell
redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> MGET key1 key2 nonexisting
1) "Hello"
2) "World"
3) (nil)
```
获取所有给定键的值
### MSET
```shell
MSET key value [key value ...]
```
#### 例子
```shell
redis> MSET key1 "Hello" key2 "World"
"OK"
redis> GET key1
"Hello"
redis> GET key2
"World"
```
将多个键设置为多个值
### INCRBY
```shell
INCRBY key increment
```
#### 例子
```shell
redis> SET mykey "10"
"OK"
redis> INCRBY mykey 5
(integer) 15
```
将键的整数值增加给定的数量
### PSETEX
```shell
PSETEX key milliseconds value
```
#### 例子
```shell
redis> PSETEX mykey 1000 "Hello"
"OK"
redis> PTTL mykey
(integer) 1000
redis> GET mykey
"Hello"
```
设置键的值和过期时间(以毫秒为单位)
### SET
```shell
SET key value [EX seconds|PX milliseconds|KEEPTTL] [NX|XX]
[GET]
```
#### 例子
```shell
redis> SET mykey "Hello"
"OK"
redis> GET mykey
"Hello"
redis> SET anotherkey "will expire in a minute" EX 60
"OK"
```
设置键的字符串值,可以理解为创建、设置、重设的作用
### SETBIT
```shell
SETBIT key offset value
```
#### 例子
```shell
redis> SETBIT mykey 7 1
(integer) 0
redis> SETBIT mykey 7 0
(integer) 1
redis> GET mykey
"\u0000"
```
设置或清除存储在键中的字符串值中偏移量处的位
### SETEX
```shell
SETEX key seconds value
```
#### 例子
```shell
redis> SETEX mykey 10 "Hello"
"OK"
redis> TTL mykey
(integer) 10
redis> GET mykey
"Hello"
```
设置密钥的值和过期时间
### SETNX
```shell
SETNX key value
```
#### 例子
```shell
redis> SETNX mykey "Hello"
(integer) 1
redis> SETNX mykey "World"
(integer) 0
redis> GET mykey
"Hello"
```
设置键的值，仅当键不存在时
### SETRANGE
```shell
SETRANGE key offset value
```
#### 例子
```shell
redis> SET key1 "Hello World"
"OK"
redis> SETRANGE key1 6 "Redis"
(integer) 11
redis> GET key1
"Hello Redis"
```
覆盖从指定偏移量开始的键处的字符串的一部分
### STRLEN
```shell
STRLEN key
```
#### 例子
```shell
redis> SET mykey "Hello world"
"OK"
redis> STRLEN mykey
(integer) 11
redis> STRLEN nonexisting
(integer) 0
```
获取存储在键中的值的长度
### STRALGO
```shell
STRALGO LCS algo-specific-argument [algo-specific-argument
...]
```
#### 例子
```shell
redis> STRALGO LCS KEYS key1 key2 IDX
1) "matches"
2) 1) 1) 1) (integer) 4
2) (integer) 7
2) 1) (integer) 5
2) (integer) 8
2) 1) 1) (integer) 2
2) (integer) 3
2) 1) (integer) 0
2) (integer) 1
3) "len"
4) (integer) 6
```
针对字符串运行算法(目前为 LCS)
Redis 集合类型设置
------------
### SADD
```shell
SADD key member [member ...]
```
#### 例子
```shell
redis> SADD myset "Hello"
(integer) 1
redis> SADD myset "World"
(integer) 1
redis> SADD myset "World"
(integer) 0
redis> SMEMBERS myset
1) "Hello"
2) "World"
```
将一个或多个成员添加到集合
### SCARD
```shell
SCARD key
```
#### 例子
```shell
redis> SADD myset "Hello"
(integer) 1
redis> SADD myset "World"
(integer) 1
redis> SCARD myset
(integer) 2
```
获取集合中的成员数
### SDIFF
```shell
SDIFF key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SDIFF key1 key2
1) "a"
2) "b"
```
减去多组
### SDIFFSTORE
```shell
SDIFFSTORE destination key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SDIFFSTORE key key1 key2
(integer) 2
redis> SMEMBERS key
1) "a"
2) "b"
```
减去多个集合并将结果集合存储在一个键中
### SINTER
```shell
SINTER key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SINTER key1 key2
1) "c"
```
交叉多个集合
### SINTERSTORE
```shell
SINTERSTORE destination key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SINTERSTORE key key1 key2
(integer) 1
redis> SMEMBERS key
1) "c"
```
将多个集合相交并将结果集合存储在一个键中
### SISMEMBER
```shell
SISMEMBER key member
```
#### 例子
```shell
redis> SADD myset "one"
(integer) 1
redis> SISMEMBER myset "one"
(integer) 1
redis> SISMEMBER myset "two"
(integer) 0
```
确定给定值是否是集合的成员
### SMISMEMBER
```shell
SMISMEMBER key member [member ...]
```
#### 例子
```shell
redis> SADD myset "one"
(integer) 1
redis> SADD myset "one"
(integer) 0
redis> SMISMEMBER myset "one" "notamember"
1) (integer) 1
2) (integer) 0
```
返回与集合的给定元素关联的成员资格
### SMEMBERS
```
SMEMBERS key
```
#### 例子
```shell
redis> SADD myset "Hello"
(integer) 1
redis> SADD myset "World"
(integer) 1
redis> SMEMBERS myset
1) "Hello"
2) "World"
```
获取集合中的所有成员
### SMOVE
```
SMOVE source destination member
```
#### 例子
```shell
redis> SADD myset "one"
(integer) 1
redis> SADD myset "two"
(integer) 1
redis> SADD myotherset "three"
(integer) 1
redis> SMOVE myset myotherset "two"
(integer) 1
redis> SMEMBERS myset
1) "one"
redis> SMEMBERS myotherset
1) "two"
2) "three"
```
将成员从一组移到另一组
### SPOP
```
SPOP key [count]
```
#### 例子
```shell
redis> SADD myset "one"
(integer) 1
redis> SADD myset "two"
(integer) 1
redis> SADD myset "three"
(integer) 1
redis> SPOP myset
"two"
redis> SMEMBERS myset
1) "one"
2) "three"
redis> SADD myset "four"
(integer) 1
redis> SADD myset "five"
(integer) 1
redis> SPOP myset 3
1) "four"
2) "five"
3) "three"
redis> SMEMBERS myset
1) "one"
```
从集合中删除并返回一个或多个随机成员
### SRANDMEMBER
```
SRANDMEMBER key [count]
```
#### 例子
```shell
redis> SADD myset one two three
(integer) 3
redis> SRANDMEMBER myset
"three"
redis> SRANDMEMBER myset 2
1) "two"
2) "three"
redis> SRANDMEMBER myset -5
1) "one"
2) "two"
3) "three"
4) "three"
5) "one"
```
从一组中获取一个或多个随机成员
### SREM
```
SREM key member [member ...]
```
#### 例子
```shell
redis> SADD myset "one"
(integer) 1
redis> SADD myset "two"
(integer) 1
redis> SADD myset "three"
(integer) 1
redis> SREM myset "one"
(integer) 1
redis> SREM myset "four"
(integer) 0
redis> SMEMBERS myset
1) "two"
2) "three"
```
从集合中删除一个或多个成员
### SUNION
```
SUNION key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SUNION key1 key2
1) "a"
2) "c"
3) "e"
4) "b"
5) "d"
```
添加多组
### SUNIONSTORE
```
SUNIONSTORE destination key [key ...]
```
#### 例子
```shell
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SUNIONSTORE key key1 key2
(integer) 5
redis> SMEMBERS key
1) "a"
2) "c"
3) "e"
4) "b"
5) "d"
```
添加多个集合并将结果集合存储在一个键中
Redis 列表类型设置
------------
### 一些引用(可能有帮助)
:- | --
:- | --
[BRPOPLPUSH](https://redis.io/commands/brpoplpush) | 从列表中弹出一个元素，将其推入另一个列表并返回；或阻塞直到有一个可用
[BLMOVE](https://redis.io/commands/blmove) | 从列表中弹出一个元素，将其推入另一个列表并返回；或阻塞直到有一个可用
### BLPOP
```
BLPOP key [key ...] timeout
```
#### 例子
```shell
redis> DEL list1 list2
(integer) 0
redis> RPUSH list1 a b c
(integer) 3
redis> BLPOP list1 list2 0
1) "list1"
2) "a"
```
删除并获取列表中的第一个元素，或者阻塞直到有一个元素可用
### BRPOP
```
BRPOP key [key ...] timeout
```
#### 例子
```shell
redis> DEL list1 list2
(integer) 0
redis> RPUSH list1 a b c
(integer) 3
redis> BRPOP list1 list2 0
1) "list1"
2) "c"
```
删除并获取列表中的最后一个元素，或者阻塞直到有一个可用
### LINDEX
```
LINDEX key index
```
#### 例子
```shell
redis> LPUSH mylist "World"
(integer) 1
redis> LPUSH mylist "Hello"
(integer) 2
redis> LINDEX mylist 0
"Hello"
redis> LINDEX mylist -1
"World"
redis> LINDEX mylist 3
(nil)
```
通过索引从列表中获取元素
### LINSERT
```
LINSERT key BEFORE|AFTER pivot element
```
#### 例子
```shell
redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSH mylist "World"
(integer) 2
redis> LINSERT mylist BEFORE "World" "There"
(integer) 3
redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"
```
在列表中的另一个元素之前或之后插入一个元素
### LLEN
```
LLEN key
```
#### 例子
```shell
redis> LPUSH mylist "World"
(integer) 1
redis> LPUSH mylist "Hello"
(integer) 2
redis> LLEN mylist
(integer) 2
```
获取列表的长度
### LPOP
```
LPOP key [count]
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LPOP mylist
"one"
redis> LRANGE mylist 0 -1
1) "two"
2) "three"
```
删除并获取列表中的第一个元素
### LPOS
```
LPOS key element [RANK rank] [COUNT num-matches] [MAXLEN len]
```
#### 例子
```shell
redis> RPUSH mylist a b c d 1 2 3 4 3 3 3
(integer) 11
redis> LPOS mylist 3
(integer) 6
redis> LPOS mylist 3 COUNT 0 RANK 2
1) (integer) 8
2) (integer) 9
3) (integer) 10
```
返回列表中匹配元素的索引
### LPUSH
```
LPUSH key element [element ...]
```
#### 例子
```shell
redis> LPUSH mylist "world"
(integer) 1
redis> LPUSH mylist "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "world"
```
将一个或多个元素添加到列表中
### LPUSHX
```
LPUSHX key element [element ...]
```
#### 例子
```shell
redis> LPUSH mylist "World"
(integer) 1
redis> LPUSHX mylist "Hello"
(integer) 2
redis> LPUSHX myotherlist "Hello"
(integer) 0
redis> LRANGE mylist 0 -1
1) "Hello"
2) "World"
redis> LRANGE myotherlist 0 -1
(empty list or set)
```
仅当列表存在时才将元素添加到列表中
### LRANGE
```
LRANGE key start stop
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LRANGE mylist 0 0
1) "one"
redis> LRANGE mylist -3 2
1) "one"
2) "two"
3) "three"
redis> LRANGE mylist -100 100
1) "one"
2) "two"
3) "three"
redis> LRANGE mylist 5 10
(empty list or set)
```
从列表中获取一系列元素
### LREM
```
LREM key count element
```
#### 例子
```shell
redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "hello"
(integer) 2
redis> RPUSH mylist "foo"
(integer) 3
redis> RPUSH mylist "hello"
(integer) 4
redis> LREM mylist -2 "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "foo"
```
从列表中删除元素
### LSET
```
LSET key index element
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LSET mylist 0 "four"
"OK"
redis> LSET mylist -2 "five"
"OK"
redis> LRANGE mylist 0 -1
1) "four"
2) "five"
3) "three"
```
通过索引设置列表中元素的值
### LTRIM
```
LTRIM key start stop
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LTRIM mylist 1 -1
"OK"
redis> LRANGE mylist 0 -1
1) "two"
2) "three"
```
将列表修剪到指定范围
### RPOP
```
RPOP key [count]
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOP mylist
"three"
redis> LRANGE mylist 0 -1
1) "one"
2) "two"
```
删除并获取列表中的最后一个元素
### RPOPLPUSH
```
RPOPLPUSH source destination
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOPLPUSH mylist myotherlist
"three"
redis> LRANGE mylist 0 -1
1) "one"
2) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
```
删除列表中的最后一个元素，将其添加到另一个列表中并返回
### LMOVE
```
LMOVE source destination LEFT|RIGHT LEFT|RIGHT
```
#### 例子
```shell
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LMOVE mylist myotherlist RIGHT LEFT
"three"
redis> LMOVE mylist myotherlist LEFT RIGHT
"one"
redis> LRANGE mylist 0 -1
1) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
2) "one"
```
从列表中弹出一个元素，将其推入另一个列表并返回
### RPUSH
```
RPUSH key element [element ...]
```
#### 例子
```shell
redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "world"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "world"
```
将一个或多个元素附加到列表
### RPUSHX
```
RPUSHX key element [element ...]
```
#### 例子
```shell
redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSHX mylist "World"
(integer) 2
redis> RPUSHX myotherlist "World"
(integer) 0
redis> LRANGE mylist 0 -1
1) "Hello"
2) "World"
redis> LRANGE myotherlist 0 -1
(empty list or set)
```
仅当列表存在时才将元素附加到列表
Redis 哈希类型设置
------------
### HDEL
```
HDEL key field [field ...]
```
#### 例子
```shell
redis> HSET myhash field1 "foo"
(integer) 1
redis> HDEL myhash field1
(integer) 1
redis> HDEL myhash field2
(integer) 0
```
删除一个或多个哈希字段
### HEXISTS
```
HEXISTS key field
```
#### 例子
```shell
redis> HSET myhash field1 "foo"
(integer) 1
redis> HEXISTS myhash field1
(integer) 1
redis> HEXISTS myhash field2
(integer) 0
```
判断哈希字段是否存在
### HGET
```
HGET key field
```
#### 例子
```shell
redis> HSET myhash field1 "foo"
(integer) 1
redis> HGET myhash field1
"foo"
redis> HGET myhash field2
(nil)
```
获取哈希字段的值
### HGETALL
```
HGETALL key
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HGETALL myhash
1) "field1"
2) "Hello"
3) "field2"
4) "World"
```
获取哈希中的所有字段和值
### HINCRBY
```
HINCRBY key field increment
```
#### 例子
```shell
redis> HSET myhash field 5
(integer) 1
redis> HINCRBY myhash field 1
(integer) 6
redis> HINCRBY myhash field -1
(integer) 5
redis> HINCRBY myhash field -10
(integer) -5
```
将哈希字段的整数值增加给定的数字
### HINCRBYFLOAT
```
HINCRBYFLOAT key field increment
```
#### 例子
```shell
redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
"10.6"
redis> HINCRBYFLOAT mykey field -5
"5.6"
redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
"5200"
```
将哈希字段的浮点值增加给定的数量
### HKEYS
```
HKEYS key
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HKEYS myhash
1) "field1"
2) "field2"
```
获取哈希中的所有字段
### HLEN
```
HLEN key
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HLEN myhash
(integer) 2
```
获取哈希中的字段数
### HMGET
```
HMGET key field [field ...]
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HMGET myhash field1 field2 nofield
1) "Hello"
2) "World"
3) (nil)
```
获取所有给定哈希字段的值
### HMSET
```
HMSET key field value [field value ...]
```
#### 例子
```shell
redis> HMSET myhash field1 "Hello" field2 "World"
"OK"
redis> HGET myhash field1
"Hello"
redis> HGET myhash field2
"World"
```
将多个哈希字段设置为多个值
### HSET
```
HSET key field value [field value ...]
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HGET myhash field1
"Hello"
```
设置哈希字段的字符串值
### HSETNX
```
HSETNX key field value
```
#### 例子
```shell
redis> HSETNX myhash field "Hello"
(integer) 1
redis> HSETNX myhash field "World"
(integer) 0
redis> HGET myhash field
"Hello"
```
设置哈希字段的值，仅当该字段不存在时
### HSTRLEN
```
HSTRLEN key field
```
#### 例子
```shell
redis> HMSET myhash f1 HelloWorld f2 99 f3 -256
"OK"
redis> HSTRLEN myhash f1
(integer) 10
redis> HSTRLEN myhash f2
(integer) 2
redis> HSTRLEN myhash f3
(integer) 4
```
获取哈希字段值的长度
### HVALS
```
HVALS key
```
#### 例子
```shell
redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HVALS myhash
1) "Hello"
2) "World"
```
获取哈希中的所有值
Redis 排序集类型设置
------------
### BZPOPMIN
```
BZPOPMIN key [key ...] timeout
```
#### 例子
```shell
redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMIN zset1 zset2 0
1) "zset1"
2) "a"
3) "0"
```
从一个或多个排序集合中删除并返回得分最低的成员，或者阻塞直到一个可用
### BZPOPMAX
```
BZPOPMAX key [key ...] timeout
```
#### 例子
```shell
redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMAX zset1 zset2 0
1) "zset1"
2) "c"
3) "2"
```
从一个或多个排序集合中删除并返回得分最高的成员，或者阻塞直到一个可用
### ZADD
<!--rehype:wrap-class=row-span-2-->
```
ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score
member ...]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 1 "uno"
(integer) 1
redis> ZADD myzset 2 "two" 3 "three"
(integer) 2
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "uno"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"
```
将一个或多个成员添加到有序集合中，或者更新其分数(如果它已经存在)
### ZCARD
```
ZCARD key
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZCARD myzset
(integer) 2
```
获取有序集合中的成员数
### ZSCORE
```
ZSCORE key member
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZSCORE myzset "one"
"1"
```
获取与排序集中给定成员关联的分数
### ZCOUNT
```
ZCOUNT key min max
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZCOUNT myzset -inf +inf
(integer) 3
redis> ZCOUNT myzset (1 3
(integer) 2
```
计算得分在给定值内的排序集中的成员
### ZDIFF
```
ZDIFF numkeys key [key ...] [WITHSCORES]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset1 3 "three"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZDIFF 2 zset1 zset2
1) "three"
redis> ZDIFF 2 zset1 zset2 WITHSCORES
1) "three"
2) "3"
```
减去多个排序集
### ZDIFFSTORE
```
ZDIFFSTORE destination numkeys key [key ...]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset1 3 "three"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZDIFFSTORE out 2 zset1 zset2
(integer) 1
redis> ZRANGE out 0 -1 WITHSCORES
1) "three"
2) "3"
```
减去多个排序集并将生成的排序集存储在新键中
### ZINCRBY
```
ZINCRBY key increment member
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZINCRBY myzset 2 "one"
"3"
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "two"
2) "2"
3) "one"
4) "3"
```
增加排序集中成员的分数
### ZINTER
```
ZINTER numkeys key [key ...] [WEIGHTS weight [weight ...]]
[AGGREGATE SUM|MIN|MAX] [WITHSCORES]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZINTER 2 zset1 zset2
1) "one"
2) "two"
redis> ZINTER 2 zset1 zset2 WITHSCORES
1) "one"
2) "2"
3) "two"
4) "4"
```
与多个排序集相交
### ZINTERSTORE
```
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight
[weight ...]] [AGGREGATE SUM|MIN|MAX]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 2
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "two"
4) "10"
```
将多个排序集相交并将生成的排序集存储在新键中
### ZLEXCOUNT
```
ZLEXCOUNT key min max
```
#### 例子
```shell
redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e
(integer) 5
redis> ZADD myzset 0 f 0 g
(integer) 2
redis> ZLEXCOUNT myzset - +
(integer) 7
redis> ZLEXCOUNT myzset [b [f
(integer) 5
```
计算给定词典范围之间的有序集合中的成员数
### ZPOPMAX
```
ZPOPMAX key [count]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMAX myzset
1) "three"
2) "3"
```
删除并返回排序集中得分最高的成员
### ZPOPMIN
```
ZPOPMIN key [count]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMIN myzset
1) "one"
2) "1"
```
删除并返回排序集中得分最低的成员
### ZRANGE
```
ZRANGE key start stop [WITHSCORES]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANGE myzset 0 -1
1) "one"
2) "two"
3) "three"
redis> ZRANGE myzset 2 3
1) "three"
redis> ZRANGE myzset -2 -1
1) "two"
2) "three"
```
按索引返回排序集中的一系列成员
### ZRANGEBYLEX
```
ZRANGEBYLEX key min max [LIMIT offset count]
```
#### 例子
```shell
redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis> ZRANGEBYLEX myzset - [c
1) "a"
2) "b"
3) "c"
redis> ZRANGEBYLEX myzset - (c
1) "a"
2) "b"
redis> ZRANGEBYLEX myzset [aaa (g
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"
```
按词典顺序返回排序集中的一系列成员
### ZREVRANGEBYLEX
```
ZREVRANGEBYLEX key max min [LIMIT offset count]
```
#### 例子
```shell
redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis> ZREVRANGEBYLEX myzset [c -
1) "c"
2) "b"
3) "a"
redis> ZREVRANGEBYLEX myzset (c -
1) "b"
2) "a"
redis> ZREVRANGEBYLEX myzset (g [aaa
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
```
返回排序集中的一系列成员，按字典范围，从高到低的字符串排序。
### ZRANGEBYSCORE
```
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANGEBYSCORE myzset -inf +inf
1) "one"
2) "two"
3) "three"
redis> ZRANGEBYSCORE myzset 1 2
1) "one"
2) "two"
redis> ZRANGEBYSCORE myzset (1 2
1) "two"
redis> ZRANGEBYSCORE myzset (1 (2
(empty list or set)
```
按分数返回排序集中的一系列成员
### ZRANK
```
ZRANK key member
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZRANK myzset "three"
(integer) 2
redis> ZRANK myzset "four"
(nil)
```
确定有序集合中成员的索引
### ZREM
```
ZREM key member [member ...]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREM myzset "two"
(integer) 1
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "three"
4) "3"
```
从有序集合中移除一个或多个成员
### ZREMRANGEBYLEX
```
ZREMRANGEBYLEX key min max
```
#### 例子
```shell
redis> ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
(integer) 5
redis> ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
(integer) 5
redis> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "alpha"
4) "b"
5) "c"
6) "d"
7) "e"
8) "foo"
9) "zap"
10) "zip"
redis> ZREMRANGEBYLEX myzset [alpha [omega
(integer) 6
redis> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "zap"
4) "zip"
```
删除给定词典范围之间的排序集中的所有成员
### ZREMRANGEBYRANK
```
ZREMRANGEBYRANK key start stop
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREMRANGEBYRANK myzset 0 1
(integer) 2
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "three"
2) "3"
```
删除给定索引内排序集中的所有成员
### ZREMRANGEBYSCORE
```
ZREMRANGEBYSCORE key min max
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREMRANGEBYSCORE myzset -inf (2
(integer) 1
redis> ZRANGE myzset 0 -1 WITHSCORES
1) "two"
2) "2"
3) "three"
4) "3"
```
删除给定分数内排序集中的所有成员
### ZREVRANGE
```
ZREVRANGE key start stop [WITHSCORES]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANGE myzset 0 -1
1) "three"
2) "two"
3) "one"
redis> ZREVRANGE myzset 2 3
1) "one"
redis> ZREVRANGE myzset -2 -1
1) "two"
2) "one"
```
按索引返回排序集中的一系列成员，分数从高到低排序
### ZREVRANGEBYSCORE
```
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANGEBYSCORE myzset +inf -inf
1) "three"
2) "two"
3) "one"
redis> ZREVRANGEBYSCORE myzset 2 1
1) "two"
2) "one"
redis> ZREVRANGEBYSCORE myzset 2 (1
1) "two"
redis> ZREVRANGEBYSCORE myzset (2 (1
(empty list or set)
```
按分数返回排序集中的一系列成员，分数从高到低排序
### ZREVRANK
```
ZREVRANK key member
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANK myzset "one"
(integer) 2
redis> ZREVRANK myzset "four"
(nil)
```
确定一个成员在有序集合中的索引，分数从高到低排序
### ZUNION
```
ZUNION numkeys key [key ...] [WEIGHTS weight [weight ...]]
[AGGREGATE SUM|MIN|MAX] [WITHSCORES]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNION 2 zset1 zset2
1) "one"
2) "three"
3) "two"
redis> ZUNION 2 zset1 zset2 WITHSCORES
1) "one"
2) "2"
3) "three"
4) "3"
5) "two"
6) "4"
```
添加多个排序集
### ZMSCORE
```
ZMSCORE key member [member ...]
```
#### 例子
```shell
redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZMSCORE myzset "one" "two" "nofield"
1) "1"
2) "2"
3) (nil)
```
获取与排序集中给定成员关联的分数
### ZUNIONSTORE
```
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight
[weight ...]] [AGGREGATE SUM|MIN|MAX]
```
#### 例子
```shell
redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 3
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "three"
4) "9"
5) "two"
6) "10"
```
添加多个排序集并将生成的排序集存储在新键中
Redis地图坐标集类型设置
------------
<!--rehype:body-class=cols-2-->
### GEOADD
```
GEOADD key longitude latitude member [longitude latitude member ...]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEODIST Sicily Palermo Catania
"166274.1516"
redis> GEORADIUS Sicily 15 37 100 km
1) "Catania"
redis> GEORADIUS Sicily 15 37 200 km
1) "Palermo"
2) "Catania"
```
在使用排序集表示的地理空间索引中添加一个或多个地理空间项
### GEOHASH
```
GEOHASH key member [member ...]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEOHASH Sicily Palermo Catania
1) "sqc8b49rny0"
2) "sqdtr74hyu0"
```
将地理空间索引的成员作为标准 geohash 字符串返回
### GEOPOS
```
GEOPOS key member [member ...]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEOPOS Sicily Palermo Catania NonExisting
1) 1) "13.36138933897018433"
2) "38.11555639549629859"
2) 1) "15.08726745843887329"
2) "37.50266842333162032"
3) (nil)
```
返回地理空间索引成员的经度和纬度
### GEODIST
```
GEODIST key member1 member2 [m|km|ft|mi]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEODIST Sicily Palermo Catania
"166274.1516"
redis> GEODIST Sicily Palermo Catania km
"166.2742"
redis> GEODIST Sicily Palermo Catania mi
"103.3182"
redis> GEODIST Sicily Foo Bar
(nil)
```
返回地理空间索引的两个成员之间的距离
### GEORADIUS
<!--rehype:wrap-class=row-span-3-->
```
GEORADIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT
count] [ASC|DESC] [STORE key] [STOREDIST key]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEORADIUS Sicily 15 37 200 km WITHDIST
1) 1) "Palermo"
2) "190.4424"
2) 1) "Catania"
2) "56.4413"
redis> GEORADIUS Sicily 15 37 200 km WITHCOORD
1) 1) "Palermo"
2) 1) "13.36138933897018433"
2) "38.11555639549629859"
2) 1) "Catania"
2) 1) "15.08726745843887329"
2) "37.50266842333162032"
redis> GEORADIUS Sicily 15 37 200 km WITHDIST WITHCOORD
1) 1) "Palermo"
2) "190.4424"
3) 1) "13.36138933897018433"
2) "38.11555639549629859"
2) 1) "Catania"
2) "56.4413"
3) 1) "15.08726745843887329"
2) "37.50266842333162032"
```
查询表示地理空间索引的排序集，以获取与某个点的给定最大距离匹配的成员
### GEORADIUSBYMEMBER
```
GEORADIUSBYMEMBER key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]
[ASC|DESC] [STORE key] [STOREDIST key]
```
#### 例子
```shell
redis> GEOADD Sicily 13.583333 37.316667 "Agrigento"
(integer) 1
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEORADIUSBYMEMBER Sicily Agrigento 100 km
1) "Agrigento"
2) "Palermo"
```
查询表示地理空间索引的排序集，以获取与成员的给定最大距离相匹配的成员
### GEOSEARCH
```
GEOSEARCH key [FROMMEMBER member] [FROMLONLAT longitude latitude] [BYRADIUS radius m|km|ft|mi]
[BYBOX width height m|km|ft|mi] [ASC|DESC] [COUNT count] [WITHCOORD] [WITHDIST] [WITHHASH]
```
#### 例子
```shell
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEOADD Sicily 12.758489 38.788135 "edge1" 17.241510 38.788135 "edge2"
(integer) 2
redis> GEOSEARCH Sicily FROMLONLAT 15 37 BYRADIUS 200 km ASC
1) "Catania"
2) "Palermo"
redis> GEOSEARCH Sicily FROMLONLAT 15 37 BYBOX 400 400 km ASC
1) "Catania"
2) "Palermo"
3) "edge2"
4) "edge1"
```
查询表示地理空间索引的排序集，以获取框或圆区域内的成员。
### 一些引用(可能有帮助)
:- | --
:- | --
[GEOSEARCHSTORE](https://redis.io/commands/geosearchstore) | 查询表示地理空间索引的排序集以获取框或圆区域内的成员，并将结果存储在另一个键中
<!--rehype:className=style-list-->
Redis超文本日志类型设置
------------
### PFADD
```shell
PFADD key element [element ...]
```
#### 例子
```shell
redis> PFADD hll a b c d e f g
(integer) 1
redis> PFCOUNT hll
(integer) 7
```
将指定的元素添加到指定的HyperLogLog。
### PFCOUNT
```shell
PFCOUNT key [key ...]
```
#### 例子
```shell
redis> PFADD hll foo bar zap
(integer) 1
redis> PFADD hll zap zap zap
(integer) 0
redis> PFADD hll foo bar
(integer) 0
redis> PFCOUNT hll
(integer) 3
redis> PFADD some-other-hll 1 2 3
(integer) 1
redis> PFCOUNT hll some-other-hll
(integer) 6
```
返回HyperLogLog在键处观察到的集合的近似基数。
### PFMERGE
```shell
PFMERGE destkey sourcekey [sourcekey ...]
```
#### 例子
```shell
redis> PFADD hll1 foo bar zap a
(integer) 1
redis> PFADD hll2 a b c foo
(integer) 1
redis> PFMERGE hll3 hll1 hll2
"OK"
redis> PFCOUNT hll3
(integer) 6
```
将N个不同的HyperLogLogs合并成一个。
Redis流命令
------------
<!--rehype:body-class=cols-2-->
### 一些引用(可能有帮助)
:- | --
:- | --
[XINFO](https://redis.io/commands/xinfo) | 获取有关流和消费者组的信息
[XDEL](https://redis.io/commands/xdel) | 从流中删除指定的条目。返回实际删除的项目数，如果某些 ID 不存在，则可能与传递的 ID 数不同
[XREAD](https://redis.io/commands/xread) | 返回多个流中从未见过的元素，其 ID 大于调用者为每个流报告的 ID
[XGROUP](https://redis.io/commands/xgroup) | 创建、销毁和管理消费者组
[XREADGROUP](https://redis.io/commands/xreadgroup) | 使用消费者组从流中返回新条目，或访问给定消费者的待处理条目的历史记录
[XCLAIM](https://redis.io/commands/xclaim) | 更改(或获取)消费者组中消息的所有权，就好像消息已传递给指定的消费者一样
[XPENDING](https://redis.io/commands/xpending) | 从流消费者组待定条目列表中返回信息和条目，这些信息是已获取但从未确认的消息
<!--rehype:className=style-list-->
### XADD
```
XADD key [MAXLEN [=|~] length] [NOMKSTREAM] *|ID field value [field value ...]
```
#### 例子
```shell
redis> XADD mystream * name Sara surname OConnor
"1609040574632-0"
redis> XADD mystream * field1 value1 field2 value2 field3 value3
"1609040574632-1"
redis> XLEN mystream
(integer) 2
redis> XRANGE mystream - +
1) 1) "1609040574632-0"
2) 1) "name"
2) "Sara"
3) "surname"
4) "OConnor"
2) 1) "1609040574632-1"
2) 1) "field1"
2) "value1"
3) "field2"
4) "value2"
5) "field3"
6) "value3"
```
将新条目附加到流
### XTRIM
```shell
XTRIM key MAXLEN [=|~] length
```
#### 例子
```shell
redis> XADD mystream * field1 A field2 B field3 C field4 D
"1609040575750-0"
redis> XTRIM mystream MAXLEN 2
(integer) 0
redis> XRANGE mystream - +
1) 1) "1609040575750-0"
2) 1) "field1"
2) "A"
3) "field2"
4) "B"
5) "field3"
6) "C"
7) "field4"
8) "D"
```
将流修剪为(大约如果传递了“~”)特定大小
### XRANGE
```shell
XRANGE key start end [COUNT count]
```
#### 例子
```shell
redis> XADD writers * name Virginia surname Woolf
"1609040578002-0"
redis> XADD writers * name Jane surname Austen
"1609040578002-1"
redis> XADD writers * name Toni surname Morrison
"1609040578003-0"
redis> XADD writers * name Agatha surname Christie
"1609040578003-1"
redis> XADD writers * name Ngozi surname Adichie
"1609040578003-2"
redis> XLEN writers
(integer) 5
redis> XRANGE writers - + COUNT 2
1) 1) "1609040578002-0"
2) 1) "name"
2) "Virginia"
3) "surname"
4) "Woolf"
2) 1) "1609040578002-1"
2) 1) "name"
2) "Jane"
3) "surname"
4) "Austen"
```
返回流中的一系列元素，其 ID 与指定的 ID 间隔相匹配
### XREVRANGE
<!--rehype:wrap-class=row-span-2-->
```shell
XREVRANGE key end start [COUNT count]
```
#### 例子
```shell
redis> XADD writers * name Virginia surname Woolf
"1609040579130-0"
redis> XADD writers * name Jane surname Austen
"1609040579130-1"
redis> XADD writers * name Toni surname Morrison
"1609040579130-2"
redis> XADD writers * name Agatha surname Christie
"1609040579131-0"
redis> XADD writers * name Ngozi surname Adichie
"1609040579131-1"
redis> XLEN writers
(integer) 5
redis> XREVRANGE writers + - COUNT 1
1) 1) "1609040579131-1"
2) 1) "name"
2) "Ngozi"
3) "surname"
4) "Adichie"
```
返回流中的一系列元素，ID 与指定的 ID 间隔相匹配，与 XRANGE 相比，顺序相反(从大到小的 ID)
### XLEN
```shell
XLEN key
```
#### 例子
```shell
redis> XADD mystream * item 1
"1609040580250-0"
redis> XADD mystream * item 2
"1609040580250-1"
redis> XADD mystream * item 3
"1609040580251-0"
redis> XLEN mystream
(integer) 3
```
返回流中的条目数
### XACK
```shell
XACK key group ID [ID ...]
```
#### 例子
```shell
redis> XACK mystream mygroup 1526569495631-0
ERR Unknown or disabled command 'XACK'
```
将待处理消息标记为已正确处理，有效地将其从消费者组的待处理条目列表中删除，该命令的返回值是成功确认的消息数，即我们实际能够在 `PEL` 中解析的 `ID`
集群方面的东西
------------
<!--rehype:body-class=cols-2-->
### 节点、集群
<!--rehype:wrap-class=row-span-3-->
:- | --
:- | --
| [CLUSTER ADDSLOTS](https://redis.io/commands/cluster-addslots) | 为接收节点分配新的哈希槽 |
| [CLUSTER BUMPEPOCH](https://redis.io/commands/cluster-bumpepoch) | 提前集群配置纪元 |
| [CLUSTER COUNT-FAILURE-REPORTS](https://redis.io/commands/cluster-count-failure-reports) | 返回给定节点的活动故障报告数 |
| [CLUSTER COUNTKEYSINSLOT](https://redis.io/commands/cluster-countkeysinslot) | 返回指定哈希槽中本地键的个数 |
| [CLUSTER DELSLOTS](https://redis.io/commands/cluster-delslots) | 在接收节点中将哈希槽设置为未绑定 |
| [CLUSTER FAILOVER](https://redis.io/commands/cluster-failover) | 强制副本对其主副本执行手动故障转移 |
| [CLUSTER FLUSHSLOTS](https://redis.io/commands/cluster-flushslots) | 删除节点自身的slot信息 |
| [CLUSTER FORGET](https://redis.io/commands/cluster-forget) | 从节点表中删除一个节点 |
| [CLUSTER GETKEYSINSLOT](https://redis.io/commands/cluster-getkeysinslot) | 返回指定哈希槽中的本地键名 |
| [CLUSTER INFO](https://redis.io/commands/cluster-info) | 提供有关 Redis 集群节点状态的信息 |
| [CLUSTER KEYSLOT](https://redis.io/commands/cluster-keyslot) | 返回指定键的哈希槽 |
| [CLUSTER MEET](https://redis.io/commands/cluster-meet) | 强制节点集群与另一个节点握手 |
| [CLUSTER MYID](https://redis.io/commands/cluster-myid) | 返回节点id |
| [CLUSTER NODES](https://redis.io/commands/cluster-nodes) | 获取节点的集群配置 |
| [CLUSTER REPLICATE](https://redis.io/commands/cluster-replicate) | 将节点重新配置为指定主节点的副本 |
| [CLUSTER RESET](https://redis.io/commands/cluster-reset) | 重置 Redis 集群节点 |
| [CLUSTER SAVECONFIG](https://redis.io/commands/cluster-saveconfig) | 强制节点将集群状态保存在磁盘上 |
| [CLUSTER SET-CONFIG-EPOCH](https://redis.io/commands/cluster-set-config-epoch) | 在新节点中设置配置纪元 |
| [CLUSTER SETSLOT](https://redis.io/commands/cluster-setslot) | 将哈希槽绑定到特定节点 |
| [CLUSTER SLAVES](https://redis.io/commands/cluster-slaves) | 列出指定主节点的副本节点 |
| [CLUSTER REPLICAS](https://redis.io/commands/cluster-replicas) | 列出指定主节点的副本节点 |
| [CLUSTER SLOTS](https://redis.io/commands/cluster-slots) | 获取集群插槽数组到节点映射 |
| [READONLY](https://redis.io/commands/readonly) | 为到集群副本节点的连接启用读取查询 |
| [READWRITE](https://redis.io/commands/readwrite) | 禁用对集群副本节点连接的读取查询 |
### 交易
:- | --
:- | --
[DISCARD](https://redis.io/commands/discard) | 丢弃 MULTI 之后发出的所有命令
[EXEC](https://redis.io/commands/exec) | 执行 MULTI 之后发出的所有命令
[MULTI](https://redis.io/commands/multi) | 标记事务块的开始
[UNWATCH](https://redis.io/commands/unwatch) | 忘记所有监视的键
[WATCH](https://redis.io/commands/watch) | 观察给定的键以确定MULTI/EXEC块的执行
### 脚本
:- | --
:- | --
[EVAL](https://redis.io/commands/eval) | 执行 Lua 脚本服务器端
[EVALSHA](https://redis.io/commands/evalsha) | 执行 Lua 脚本服务器端
[SCRIPT DEBUG](https://redis.io/commands/script-debug) | 为执行的脚本设置调试模式
[SCRIPT EXISTS](https://redis.io/commands/script-exists) | 检查脚本缓存中是否存在脚本
[SCRIPT FLUSH](https://redis.io/commands/script-flush) | 从脚本缓存中删除所有脚本
[SCRIPT KILL](https://redis.io/commands/script-kill) | 终止当前正在执行的脚本
[SCRIPT LOAD](https://redis.io/commands/script-load) | 将指定的 Lua 脚本加载到脚本缓存中
### 发布操作
:- | --
:- | --
[PSUBSCRIBE](https://redis.io/commands/psubscribe) | 侦听发布到与给定模式匹配的频道的消息
[PUBSUB](https://redis.io/commands/pubsub) | 检查 Pub/Sub 子系统的状态
[PUBLISH](https://redis.io/commands/publish) | 向频道发布消息
[PUNSUBSCRIBE](https://redis.io/commands/punsubscribe) | 停止监听发布到与给定模式匹配的频道的消息
[SUBSCRIBE](https://redis.io/commands/subscribe) | 收听发布到给定频道的消息
[UNSUBSCRIBE](https://redis.io/commands/unsubscribe) | 停止收听发布到给定频道的消息