Redis 数据库速查备忘单

精选 Redis 常用指令与核心速查备忘单，涵盖字符串 String、列表 List、哈希 Hash、集合 Set、有序集合 Sorted Set、GEO 地理位置、HyperLogLog、事务及集群命令。

#🚀 入门指引

#快速启动与连接 (Getting started)

启动 Redis 服务端

$ redis-server

使用 Redis CLI 终端客户端连接

$ redis-cli

使用 Telnet 工具连接 Redis

$ telnet 127.0.0.1 6379

#Hello World 示例

心跳测试 (Ping)

redis> PING
PONG

键值对操作 (Hello World)

redis> SET mykey "Hello world"
OK
redis> GET mykey
"Hello world"

#基础数据类型 (Basic Data types)

字符串 (Strings)
列表 (Lists)
哈希 (Hashes)
无序集合 (Sets)
有序集合 (Sorted Sets)

Redis 原生支持 5 种基础核心数据结构

#Redis 字符串命令 (String)

#APPEND 尾部追加

APPEND key value

使用示例

redis> EXISTS mykey
(integer) 0
redis> APPEND mykey "Hello"
(integer) 5
redis> APPEND mykey " World"
(integer) 11
redis> GET mykey
"Hello World"

向指定 Key 对应的字符串末尾追加文本

#BITCOUNT 比特位统计

BITCOUNT key [start end]

使用示例

redis> SET mykey "foobar"
"OK"
redis> BITCOUNT mykey
(integer) 26
redis> BITCOUNT mykey 0 0
(integer) 4
redis> BITCOUNT mykey 1 1
(integer) 6

统计字符串中被设置为 1 的比特位 (Bit) 数量

#BITFIELD 位域操作

BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]

使用示例

redis> BITFIELD mykey INCRBY i5 100 1 GET u4 0
1) (integer) 1
2) (integer) 0

在字符串上执行任意二进制位域整数运算

#BITOP 按位运算

BITOP operation destkey key [key ...]

使用示例

redis> SET key1 "foobar"
"OK"
redis> SET key2 "abcdef"
"OK"
redis> BITOP AND dest key1 key2
(integer) 6
redis> GET dest
"`bc`ab"

在多个字符串 Key 之间执行按位运算 (AND/OR/XOR/NOT)

#BITPOS 比特位定位

BITPOS key bit [start] [end]

使用示例

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

寻找字符串中首个被设置为 0 或 1 的比特位位置

#DECR 自减 1

DECR key

使用示例

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

将 Key 存储的整数值减 1

#DECRBY 指定步长自减

DECRBY key decrement

使用示例

redis> SET mykey "10"
"OK"
redis> DECRBY mykey 3
(integer) 7

将 Key 存储的整数值减去指定的数值

#GET 获取键值

GET key

使用示例

redis> GET nonexisting
(nil)
redis> SET mykey "Hello"
"OK"
redis> GET mykey
"Hello"

获取指定 Key 对应的字符串值

#GETBIT 获取指定比特位

GETBIT key offset

使用示例

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 截取子字符串

GETRANGE key start end

使用示例

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 设置新值并返回旧值

GETSET key value

使用示例

redis> INCR mycounter
(integer) 1
redis> GETSET mycounter "0"
"1"
redis> GET mycounter
"0"

设置字符串新值的同时原子地返回其旧值

#INCR 自增 1

INCR key

使用示例

redis> SET mykey "10"
"OK"
redis> INCR mykey
(integer) 11
redis> GET mykey
"11"

将 Key 存储的整数值加 1

#MSETNX 批量互斥设置

MSETNX key value [key value ...]

使用示例

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)

仅当所有传入的 Key 均不存在时，批量设置多个键值对

#INCRBYFLOAT 浮点数自增

INCRBYFLOAT key increment

使用示例

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"

为指定 Key 存储的浮点数值增加给定的增量

#MGET 批量获取键值

MGET key [key ...]

使用示例

redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> MGET key1 key2 nonexisting
1) "Hello"
2) "World"
3) (nil)

一次性获取多个 Key 的值

#MSET 批量设置键值

MSET key value [key value ...]

使用示例

redis> MSET key1 "Hello" key2 "World"
"OK"
redis> GET key1
"Hello"
redis> GET key2
"World"

一次性批量设置多个键值对

#INCRBY 指定步长自增

INCRBY key increment

使用示例

redis> SET mykey "10"
"OK"
redis> INCRBY mykey 5
(integer) 15

将 Key 存储的整数值增加指定的数值

#PSETEX 毫秒级过期设置

PSETEX key milliseconds value

使用示例

redis> PSETEX mykey 1000 "Hello"
"OK"
redis> PTTL mykey
(integer) 1000
redis> GET mykey
"Hello"

设置 Key 的值并指定毫秒级过期时间

#SET 设置键值

SET key value [EX seconds|PX milliseconds|KEEPTTL] [NX|XX] [GET]

使用示例

redis> SET mykey "Hello"
"OK"
redis> GET mykey
"Hello"
redis> SET anotherkey "will expire in a minute" EX 60
"OK"

设置指定 Key 的字符串值

#SETBIT 设置比特位

SETBIT key offset value

使用示例

redis> SETBIT mykey 7 1
(integer) 0
redis> SETBIT mykey 7 0
(integer) 1
redis> GET mykey
"\u0000"

设置或清除 Key 对应字符串中 offset 位置处的比特值

#SETEX 秒级过期设置

SETEX key seconds value

使用示例

redis> SETEX mykey 10 "Hello"
"OK"
redis> TTL mykey
(integer) 10
redis> GET mykey
"Hello"

设置 Key 的值并指定秒级过期时间

#SETNX 互斥设置 (不存在时才设置)

SETNX key value

使用示例

redis> SETNX mykey "Hello"
(integer) 1
redis> SETNX mykey "World"
(integer) 0
redis> GET mykey
"Hello"

仅在 Key 不存在时设置其值 (常用于分布式锁基础实现)

#SETRANGE 范围覆盖替换

SETRANGE key offset value

使用示例

redis> SET key1 "Hello World"
"OK"
redis> SETRANGE key1 6 "Redis"
(integer) 11
redis> GET key1
"Hello Redis"

从指定偏移量开始覆写替换字符串的部分内容

#STRLEN 获取字符串长度

STRLEN key

使用示例

redis> SET mykey "Hello world"
"OK"
redis> STRLEN mykey
(integer) 11
redis> STRLEN nonexisting
(integer) 0

获取指定 Key 存储字符串的字节长度

#STRALGO 字符串算法分析

STRALGO LCS algo-specific-argument [algo-specific-argument ...]

使用示例

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 集合命令 (Set)

#SADD 添加集合元素

SADD key member [member ...]

使用示例

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 获取集合大小

SCARD key

使用示例

redis> SADD myset "Hello"
(integer) 1
redis> SADD myset "World"
(integer) 1
redis> SCARD myset
(integer) 2

获取集合中成员元素的总个数

#SDIFF 集合求差集

SDIFF key [key ...]

使用示例

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 差集存储

SDIFFSTORE destination key [key ...]

使用示例

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"

计算集合之间的差集并存储到目标 Key 中

#SINTER 集合求交集

SINTER key [key ...]

使用示例

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 交集存储

SINTERSTORE destination key [key ...]

使用示例

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"

计算集合之间的交集并存储到目标 Key 中

#SISMEMBER 存在性校验

SISMEMBER key member

使用示例

redis> SADD myset "one"
(integer) 1
redis> SISMEMBER myset "one"
(integer) 1
redis> SISMEMBER myset "two"
(integer) 0

判断给定元素是否存在于集合中

#SMISMEMBER 批量存在性校验

SMISMEMBER key member [member ...]

使用示例

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

使用示例

redis> SADD myset "Hello"
(integer) 1
redis> SADD myset "World"
(integer) 1
redis> SMEMBERS myset
1) "Hello"
2) "World"

返回集合中的所有成员元素

#SMOVE 移动元素

SMOVE source destination member

使用示例

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]

使用示例

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]

使用示例

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 ...]

使用示例

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 ...]

使用示例

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 ...]

使用示例

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"

计算集合的并集并存储到目标 Key 中

#Redis 列表命令 (List)

#常用命令列表 (Misc)

命令名称	功能描述
BRPOPLPUSH	从列表弹出元素并压入另一个列表（带阻塞等待）
BLMOVE	阻塞式列表元素移动

#BLPOP 阻塞式左侧弹出

BLPOP key [key ...] timeout

使用示例

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

使用示例

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

使用示例

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

使用示例

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

使用示例

redis> LPUSH mylist "World"
(integer) 1
redis> LPUSH mylist "Hello"
(integer) 2
redis> LLEN mylist
(integer) 2

获取列表的长度（元素个数）

#LPOP 左侧弹出

LPOP key [count]

使用示例

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]

使用示例

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 ...]

使用示例

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 ...]

使用示例

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

使用示例

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

使用示例

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"

根据 count 参数移除列表中匹配的元素

#LSET 按索引设置元素

LSET key index element

使用示例

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

使用示例

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]

使用示例

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

使用示例

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

使用示例

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 ...]

使用示例

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 ...]

使用示例

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 哈希命令 (Hash)

#HDEL 删除哈希字段

HDEL key field [field ...]

使用示例

redis> HSET myhash field1 "foo"
(integer) 1
redis> HDEL myhash field1
(integer) 1
redis> HDEL myhash field2
(integer) 0

删除哈希表中的一个或多个字段

#HEXISTS 判断字段是否存在

HEXISTS key field

使用示例

redis> HSET myhash field1 "foo"
(integer) 1
redis> HEXISTS myhash field1
(integer) 1
redis> HEXISTS myhash field2
(integer) 0

查看哈希表中指定字段是否存在

#HGET 获取字段值

HGET key field

使用示例

redis> HSET myhash field1 "foo"
(integer) 1
redis> HGET myhash field1
"foo"
redis> HGET myhash field2
(nil)

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

#HGETALL 获取所有字段与值

HGETALL key

使用示例

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

使用示例

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

使用示例

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

使用示例

redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HKEYS myhash
1) "field1"
2) "field2"

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

#HLEN 获取字段数量

HLEN key

使用示例

redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HLEN myhash
(integer) 2

获取哈希表中包含的字段数量

#HMGET 批量获取字段值

HMGET key field [field ...]

使用示例

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 ...]

使用示例

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 ...]

使用示例

redis> HSET myhash field1 "Hello"
(integer) 1
redis> HGET myhash field1
"Hello"

设置哈希表中字段的值

#HSETNX 字段不存在时设置

HSETNX key field value

使用示例

redis> HSETNX myhash field "Hello"
(integer) 1
redis> HSETNX myhash field "World"
(integer) 0
redis> HGET myhash field
"Hello"

仅在字段不存在时，才设置哈希字段的值

#HSTRLEN 获取字段值长度

HSTRLEN key field

使用示例

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

使用示例

redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HVALS myhash
1) "Hello"
2) "World"

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

#Redis 有序集合命令 (Sorted Set)

#BZPOPMIN 阻塞弹出最小值

BZPOPMIN key [key ...] timeout

使用示例

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

使用示例

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 添加有序集合成员

ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]

使用示例

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"

向有序集合添加元素或更新已有成员的分值 (Score)

#ZCARD 获取有序集合成员数

ZCARD key

使用示例

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZCARD myzset
(integer) 2

获取有序集合中成员的总个数

#ZSCORE 获取成员分值

ZSCORE key member

使用示例

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZSCORE myzset "one"
"1"

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

#ZCOUNT 按分值区间统计

ZCOUNT key min max

使用示例

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]

使用示例

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 ...]

使用示例

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"

计算有序集合差集并保存到新的 Key 中

#ZINCRBY 成员分值自增

ZINCRBY key increment member

使用示例

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]

使用示例

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]

使用示例

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"

计算交集并存储到新的 Key 中

#ZLEXCOUNT 字典序区间统计

ZLEXCOUNT key min max

使用示例

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]

使用示例

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]

使用示例

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]

使用示例

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]

使用示例

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]

使用示例

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]

使用示例

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

使用示例

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)

获取成员按分值从低到高的排名索引 (0-indexed)

#ZREM 删除有序集合成员

ZREM key member [member ...]

使用示例

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

使用示例

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

使用示例

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

使用示例

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]

使用示例

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]

使用示例

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

使用示例

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]

使用示例

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 ...]

使用示例

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]

使用示例

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"

计算有序集合的并集并存储到新 Key 中

#Redis 地理位置命令 (Geo)

#GEOADD 添加地理位置

GEOADD key longitude latitude member [longitude latitude member ...]

使用示例

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"

添加地理位置经纬度与名称到 GEO 集合中

#GEOHASH 获取 GeoHash 哈希串

GEOHASH key member [member ...]

使用示例

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 ...]

使用示例

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]

使用示例

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 按中心点半径查询

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

使用示例

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]

使用示例

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]

使用示例

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"

灵活在矩形框或圆域空间内检索 GEO 位置

#GEO 搜索结果存储 (Misc)

命令名称	功能描述
GEOSEARCHSTORE	检索地理位置并将匹配结果直接保存至目标 Key 中

#Redis Hyperloglog 统计命令

#PFADD 添加元素到 HLL

PFADD key element [element ...]

使用示例

redis> PFADD hll a b c d e f g
(integer) 1
redis> PFCOUNT hll
(integer) 7

向 HyperLogLog 基数统计结构中添加元素

#PFCOUNT 基数基准估算

PFCOUNT key [key ...]

使用示例

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 集合中唯一基数（如独立访问 UV）的近似值

#PFMERGE 合并 HyperLogLog

PFMERGE destkey sourcekey [sourcekey ...]

使用示例

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

将多个 HyperLogLog 基数数据合并至目标 Key 中

#Redis 服务器控制命令 (Server)

#COMMAND 命令详情

COMMAND

使用示例

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 支持的所有命令的详细属性数组

#服务管理命令大全 (Misc)

命令名称	功能描述
ACL LOAD	从 ACL 配置文件中重新加载用户权限规则
ACL SAVE	将当前内存中的 ACL 规则保存回配置文件
ACL LIST	以配置格式列出所有 ACL 访问控制规则
ACL USERS	列出系统配置的所有用户名
ACL GETUSER	获取指定 ACL 用户的权限规则细节
ACL SETUSER	修改或创建 ACL 用户的访问权限规则
ACL DELUSER	删除指定的 ACL 用户及其所有规则
ACL CAT	查看 ACL 权限分类及各分类包含的命令
ACL GENPASS	生成用于 ACL 的强随机安全密码
ACL WHOAMI	返回当前连接生效的 ACL 用户名
ACL LOG	查看因 ACL 校验拒绝引发的最近安全事件日志
ACL HELP	显示 ACL 子命令使用帮助手册
BGREWRITEAOF	在后台异步重写 AOF 持久化日志
BGSAVE	在后台异步将内存快照 RDB 保存到磁盘
CONFIG GET	读取指定配置参数的当前运行时数值
CONFIG REWRITE	使用内存最新配置重写 redis.conf 配置文件
CONFIG SET	动态修改指定配置参数的数值
CONFIG RESETSTAT	重置 INFO 命令统计的各种计数器
DBSIZE	返回当前选中数据库中的 Key 总数
DEBUG OBJECT	打印指定 Key 的底层调试数据结构信息
DEBUG SEGFAULT	触发服务端段错误崩塌崩溃（测试用）
FLUSHALL	彻底清空所有数据库中的全部 Key
FLUSHDB	彻底清空当前选中的数据库中的 Key
LOLWUT	艺术字形式展示 Redis 版本与致敬文字
LASTSAVE	返回上一次成功将数据保存到磁盘的 UNIX 时间戳
MEMORY DOCTOR	输出内存诊断与优化建议报告
MEMORY HELP	展示 MEMORY 内存子命令的帮助说明
MEMORY MALLOC-STATS	显示内存分配器 (jemalloc) 的内部统计信息
MEMORY PURGE	请求内存分配器主动释放空闲碎片内存
MEMORY STATS	输出服务端内存占用的详细报告
MEMORY USAGE	评估指定 Key 及其值占用的实际内存字节数
MODULE LIST	列出服务端已加载的所有扩展 Module
MODULE LOAD	动态加载指定的 Module 扩展库
MODULE UNLOAD	卸载指定的 Module 扩展库
MONITOR	实时监听并打印服务端收到的所有请求命令
SAVE	同步阻塞将数据持久化保存到 RDB 文件
SHUTDOWN	安全保存数据并关闭 Redis 服务端程序
SLAVEOF	将当前节点配置为从节点 (Redis 5+ 建议改用 REPLICAOF)
REPLICAOF	修改主从复制配置（指定主节点或独立为主节点）
SLOWLOG	管理与读取 Redis 慢查询日志
SWAPDB	互换两个 Redis 数据库中的所有 Key 数据
SYNC	主从复制内部全量同步命令
PSYNC	主从复制内部增量/全量同步命令
LATENCY DOCTOR	输出可读的系统时延分析报告
LATENCY GRAPH	返回特定事件的时延图形展示
LATENCY HISTORY	返回特定事件的时延采样历史记录
LATENCY LATEST	返回所有事件的最新时延采样数据
LATENCY RESET	重置一个或多个事件的时延统计数据
LATENCY HELP	展示 LATENCY 时延分析命令使用说明

#COMMAND COUNT 命令总数

COMMAND COUNT

使用示例

redis> COMMAND COUNT
(integer) 217

获取 Redis 当前支持的命令总数

#COMMAND GETKEYS 提取命令中的 Key

COMMAND GETKEYS

使用示例

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 命令并提取其中包含的所有 Key

#COMMAND INFO 查询指定命令详情

COMMAND INFO command-name [command-name ...]

使用示例

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]

使用示例

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
......

返回 Redis 服务器的各种状态信息与统计指标

#ROLE 节点角色

ROLE

使用示例

redis> ROLE
1) "master"
2) (integer) 0
3) (empty list or set)

返回当前 Redis 实例在主从架构中的具体角色 (master/slave/sentinel)

#TIME 服务器时间

TIME

使用示例

redis> TIME
1) "1609040690"
2) "558952"
redis> TIME
1) "1609040690"
2) "559206"

返回 Redis 服务器当前的 UNIX 时间戳与微秒数

#Redis 通用键命令 (Generic)

#常用键操作 (Misc)

命令名称	功能描述
COPY	复制指定 Key 到目标 Key
MIGRATE	原子地将 Key 迁移转交到另一个 Redis 实例
MOVE	将当前 Key 移动到同实例下的另一个 DB 数据库
OBJECT	检查 Redis Key 底层对象的内部存储编码
RESTORE	使用 DUMP 序列化数据重新还原生成 Key
SORT	对 List、Set 或 Sorted Set 中的元素进行排序
WAIT	阻塞等待写命令同步复制到指定数量的从节点
SCAN	基于游标渐进式游标遍历当前 DB 中的 Key

#DEL 删除 Key

DEL key [key ...]

使用示例

redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> DEL key1 key2 key3
(integer) 2

删除一个或多个指定的 Key

#DUMP 序列化 Key

DUMP key

使用示例

redis> SET mykey 10
"OK"
redis> DUMP mykey
"\u0000\xC0\n\t\u0000\xBEm\u0006\x89Z(\u0000\n"

返回指定 Key 存储值的序列化二进制字节表示

#EXISTS 判断 Key 是否存在

EXISTS key [key ...]

使用示例

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

检查给定的一个或多个 Key 是否存在于数据库中

#EXPIRE 设置秒级生存时间

EXPIRE key seconds

使用示例

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

为指定 Key 设置 TTL 生存时间（秒）

#EXPIREAT UNIX 时间戳过期

EXPIREAT key timestamp

使用示例

redis> SET mykey "Hello"
"OK"
redis> EXISTS mykey
(integer) 1
redis> EXPIREAT mykey 1293840000
(integer) 1
redis> EXISTS mykey
(integer) 0

使用精确的 UNIX 时间戳指定 Key 的过期失效时刻

#KEYS 通配符搜索 Key

KEYS pattern

使用示例

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"

查找符合给定通配符模式的所有 Key (注意：生产线上应慎用，避免阻塞单线程)

#PERSIST 移除过期时间

PERSIST key

使用示例

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

移除指定 Key 的 TTL 限制，将其还原为永久有效

#PEXPIRE 设置毫秒级生存时间

PEXPIRE key milliseconds

使用示例

redis> SET mykey "Hello"
"OK"
redis> PEXPIRE mykey 1500
(integer) 1
redis> TTL mykey
(integer) 1
redis> PTTL mykey
(integer) 1499

为指定 Key 设置 TTL 生存时间（毫秒）

#PEXPIREAT 毫秒级时间戳过期

PEXPIREAT key milliseconds-timestamp

使用示例

redis> SET mykey "Hello"
"OK"
redis> PEXPIREAT mykey 1555555555005
(integer) 1
redis> TTL mykey
(integer) -2
redis> PTTL mykey
(integer) -2

使用毫秒级 UNIX 时间戳指定 Key 的过期时刻

#PTTL 获取剩余生存时间 (毫秒)

PTTL key

使用示例

redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 1
(integer) 1
redis> PTTL mykey
(integer) 1000

获取 Key 的剩余生存有效时间（以毫秒为单位）

#RENAME 重命名 Key

RENAME key newkey

使用示例

redis> SET mykey "Hello"
"OK"
redis> RENAME mykey myotherkey
"OK"
redis> GET myotherkey
"Hello"

将指定的 Key 修改重命名为新的名称

#RENAMENX 目标不存在时重命名

RENAMENX key newkey

使用示例

redis> SET mykey "Hello"
"OK"
redis> SET myotherkey "World"
"OK"
redis> RENAMENX mykey myotherkey
(integer) 0
redis> GET myotherkey
"World"

仅在目标新 Key 名称不存在时才执行重命名

#TOUCH 更新访问时间

TOUCH key [key ...]

使用示例

redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> TOUCH key1 key2
(integer) 2

更新指定 Key 的最后访问时间，避免被内存淘汰算法（如 LRU）清退

#TTL 获取剩余生存时间 (秒)

TTL key

使用示例

redis> SET mykey "Hello"
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10

获取 Key 的剩余生存有效时间（以秒为单位；-1 表示永久，-2 表示不存在）

#TYPE 查询数据类型

TYPE key

使用示例

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"

获取指定 Key 存储值的底层数据类型

#UNLINK 异步后台删除 Key

UNLINK key [key ...]

使用示例

redis> SET key1 "Hello"
"OK"
redis> SET key2 "World"
"OK"
redis> UNLINK key1 key2 key3
(integer) 2

在后台其他线程中非阻塞异步删除 Key（比 DEL 更高效，不阻塞主线程）

#Redis 连接与会话命令 (Connection)

#会话命令列表 (Misc)

命令名称	功能描述
AUTH	客户端连接鉴权密码认证
CLIENT CACHING	设置服务端在下一次请求中是否开启客户端侧缓存追踪
CLIENT KILL	强制关闭指定的客户端连接
CLIENT LIST	获取当前连接的所有客户端信息列表
CLIENT GETNAME	获取当前客户端连接的自定义名称
CLIENT GETREDIR	获取客户端重定向绑定的客户端 ID
CLIENT PAUSE	暂停处理所有客户端发送的命令请求
CLIENT REPLY	设置服务端是否对客户端命令做出响应回复
CLIENT SETNAME	设置当前客户端连接的自定义名称
CLIENT TRACKING	开启或关闭服务端辅助的客户端侧缓存追踪
CLIENT UNBLOCK	从其他连接接触指定的被阻塞客户端
HELLO	切换或协商 Redis 通讯协议 (RESP2 / RESP3)
QUIT	主动断开并关闭当前连接
RESET	重置当前连接的状态
SELECT	切换当前连接选中的数据库索引 (0-15)

#CLIENT ID 获取客户端 ID

CLIENT ID

使用示例

redis> CLIENT ID
ERR Unknown or disabled command 'CLIENT'

返回当前连接的唯一客户端 ID

#CLIENT INFO 获取客户端详细信息

CLIENT INFO

使用示例

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 打印消息

ECHO message

使用示例

redis> ECHO "Hello World!"
"Hello World!"

回显打印传入的字符串

#PING 心跳保活测试

PING [message]

使用示例

redis> PING
"PONG"
redis> PING "hello world"
"hello world"

测试服务端连接是否正常响应

#Redis 流数据命令 (Stream)

#流命令列表 (Misc)

命令名称	功能描述
XINFO	查看 Stream 流及消费者组 (Consumer Groups) 的状态信息
XDEL	从流中根据 ID 删除指定的条目数据
XREAD	从一个或多个流中读取增量消息（支持阻塞等待）
XGROUP	创建、销毁或管理流消费者组 (Consumer Group)
XREADGROUP	使用消费者组读取流中的消息条目
XCLAIM	转移并获取未确认消息的所有权给新的消费者
XPENDING	查看消费者组中未确认消息 (Pending Messages) 的详细列表

#XADD 向流追加消息

XADD key [MAXLEN [=|~] length] [NOMKSTREAM] *|ID field value [field value ...]

使用示例

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"

向流 Stream 数据结构追加写入一条新的键值消息

#XTRIM 裁剪流数据

XTRIM key MAXLEN [=|~] length

使用示例

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"

对 Stream 进行修剪，将其控制在指定的容量上限以内

#XRANGE 范围读取流数据

XRANGE key start end [COUNT count]

使用示例

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 范围按升序读取 Stream 中的消息

#XREVRANGE 逆序范围读取流

XREVRANGE key end start [COUNT count]

使用示例

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 范围按降序逆序读取 Stream 中的消息

#XLEN 获取流消息长度

XLEN key

使用示例

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

返回 Stream 中包含的消息总条数

#XACK 确认流消息

XACK key group ID [ID ...]

使用示例

redis> XACK mystream mygroup 1526569495631-0
ERR Unknown or disabled command 'XACK'

向消费者组确认处理完指定 ID 的消息，将其从未确认列表 (PEL) 中移除

#高级特性与其他 (Miscellaneous)

#集群架构控制 (Cluster)

命令名称	功能描述
CLUSTER ADDSLOTS	向当前节点分配新的 Hash 槽位 (Slots)
CLUSTER BUMPEPOCH	递增推进集群配置纪元 (Epoch)
CLUSTER COUNT-FAILURE-REPORTS	返回指定节点当前生效的故障报告总数
CLUSTER COUNTKEYSINSLOT	返回指定 Hash 槽位中包含的 Key 数量
CLUSTER DELSLOTS	在当前节点中解绑移除指定的 Hash 槽位
CLUSTER FAILOVER	强制从节点执行手动故障转移升级为主节点
CLUSTER FLUSHSLOTS	清空当前节点自身的槽位信息配置
CLUSTER FORGET	从集群节点表中移除指定节点
CLUSTER GETKEYSINSLOT	返回指定槽位中存储的本地 Key 名称
CLUSTER INFO	获取当前 Redis 集群节点的状态信息
CLUSTER KEYSLOT	计算指定 Key 所归属的哈希槽位 ID
CLUSTER MEET	强制节点与目标 IP/端口节点建立握手连接
CLUSTER MYID	返回当前节点的唯一 Node ID
CLUSTER NODES	获取集群中所有节点的配置与拓扑状态
CLUSTER REPLICATE	将当前节点配置为指定主节点的副本从节点
CLUSTER RESET	重置集群节点 (软重置或硬重置)
CLUSTER SAVECONFIG	强制节点将当前集群状态写入磁盘配置
CLUSTER SET-CONFIG-EPOCH	设置新节点的配置纪元 Epoch
CLUSTER SETSLOT	将 Hash 槽位绑定映射到特定节点
CLUSTER SLAVES	列出指定主节点的所有从节点 (已废弃)
CLUSTER REPLICAS	列出指定主节点的所有副本从节点
CLUSTER SLOTS	获取集群槽位到节点的完整映射数组
READONLY	允许在只读从节点连接上执行读查询
READWRITE	禁止在只读从节点连接上执行读查询

#事务处理 (Transactions)

命令名称	功能描述
DISCARD	取消并丢弃 MULTI 之后发出的所有事务命令
EXEC	执行 MULTI 事务块内的所有排队命令
MULTI	标记开启一个事务代码块
UNWATCH	取消对所有 Key 的 CAS 监听
WATCH	监听指定 Key，在 MULTI/EXEC 期间若其被修改则取消事务

#Lua 脚本支持 (Scripting)

命令名称	功能描述
EVAL	在服务端原子地执行一段 Lua 脚本
EVALSHA	根据 SHA1 校验和执行缓存的 Lua 脚本
SCRIPT DEBUG	为 Lua 脚本设置调试模式
SCRIPT EXISTS	检查脚本缓存中是否存在指定的 SHA1 脚本
SCRIPT FLUSH	清空服务端脚本缓存中的所有 Lua 脚本
SCRIPT KILL	强制终止当前正在执行的无写操作长脚本
SCRIPT LOAD	将 Lua 脚本加载到服务器缓存中并返回 SHA1

#发布与订阅 (Pubsub)

命令名称	功能描述
PSUBSCRIBE	订阅符合给定通配符模式的所有频道
PUBSUB	查看与诊断 Pub/Sub 发布订阅子系统的内部状态
PUBLISH	向指定频道发布推送一条消息
PUNSUBSCRIBE	退订符合指定通配符模式的所有频道
SUBSCRIBE	订阅一个或多个频道以接收消息
UNSUBSCRIBE	退订指定的频道

Redis 数据库 速查备忘单

#🚀 入门指引

#快速启动与连接 (Getting started)

#Hello World 示例

#基础数据类型 (Basic Data types)

#Redis 字符串命令 (String)

#APPEND 尾部追加

#BITCOUNT 比特位统计

#BITFIELD 位域操作

#BITOP 按位运算

#BITPOS 比特位定位

#DECR 自减 1

#DECRBY 指定步长自减

#GET 获取键值

#GETBIT 获取指定比特位

#GETRANGE 截取子字符串

#GETSET 设置新值并返回旧值

#INCR 自增 1

#MSETNX 批量互斥设置

#INCRBYFLOAT 浮点数自增

#MGET 批量获取键值

#MSET 批量设置键值

#INCRBY 指定步长自增

#PSETEX 毫秒级过期设置

#SET 设置键值

#SETBIT 设置比特位

#SETEX 秒级过期设置

#SETNX 互斥设置 (不存在时才设置)

#SETRANGE 范围覆盖替换

#STRLEN 获取字符串长度

#STRALGO 字符串算法分析

#Redis 集合命令 (Set)

#SADD 添加集合元素

#SCARD 获取集合大小

#SDIFF 集合求差集

#SDIFFSTORE 差集存储

#SINTER 集合求交集

#SINTERSTORE 交集存储

#SISMEMBER 存在性校验

#SMISMEMBER 批量存在性校验

#SMEMBERS 获取所有成员

#SMOVE 移动元素

#SPOP 随机弹出元素

#SRANDMEMBER 随机获取元素

#SREM 删除集合元素

#SUNION 集合求并集

#SUNIONSTORE 并集存储

#Redis 列表命令 (List)

#常用命令列表 (Misc)

#BLPOP 阻塞式左侧弹出

#BRPOP 阻塞式右侧弹出

#LINDEX 索引获取元素

#LINSERT 插入元素

#LLEN 获取列表长度

#LPOP 左侧弹出

#LPOS 获取元素索引

#LPUSH 左侧入队

#LPUSHX 存在时左侧入队

#LRANGE 范围查询元素

#LREM 删除指定元素

#LSET 按索引设置元素

#LTRIM 列表修剪截断

#RPOP 右侧弹出

#RPOPLPUSH 弹出并压入

#LMOVE 列表间灵活移动

#RPUSH 右侧入队

#RPUSHX 存在时右侧入队

#Redis 哈希命令 (Hash)

#HDEL 删除哈希字段

#HEXISTS 判断字段是否存在

#HGET 获取字段值

#HGETALL 获取所有字段与值

#HINCRBY 字段整数自增

#HINCRBYFLOAT 字段浮点数自增

#HKEYS 获取所有字段名

#HLEN 获取字段数量

#HMGET 批量获取字段值

#HMSET 批量设置字段值

#HSET 设置字段值

#HSETNX 字段不存在时设置

Redis 数据库速查备忘单