yrl's blog
0%

redis-命令

发表于 更新于 分类于 ，

常见命令

1
2
3
4
5
6
7
8
redis-cli #链接客户端
select dbnum #选择数据库
flushdb #清除当前数据库数据
flushall #清除所有数据库数据
scan #游标扫描匹配的key
KEYS  # 查找所有符合给定模式 pattern 的 key
dbsize #返回当前数据库的 key 的数量
del # 删除给定的一个或多个 key

String

简介:String是Redis最基础的数据结构类型，它是二进制安全的，可以存储图片或者序列化的对象，值最大存储为512M
简单使用举例: set key value、get key等
应用场景：共享session、分布式锁，计数器、限流。
内部编码有3种，int（8字节长整型）/embstr（小于等于39字节字符串）/raw（大于39个字节字符串）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
127.0.0.1:6379> help @string

  APPEND key value
      summary: Append a value to a key
      since: 2.0.0
      # 如果键 key 已经存在并且它的值是一个字符串， APPEND 命令将把 value 追加到键 key 现有值的末尾。
      # 如果 key 不存在， APPEND 就简单地将键 key 的值设为 value ， 就像执行 SET key value 一样。
      # 返回追加 value 之后， 键 key 的值的长度。

  BITCOUNT key [start end]
      summary: Count set bits in a string
      since: 2.6.0
      # 对指定的bit索引位置区间的bit值进行统计
  
  BITOP operation destkey key [key ...]
      summary: Perform bitwise operations between strings
      since: 2.6.0
      # 在多个键（包含字符串值）之间执行按位操作并将结果存储在目标键中，operation支持四个按位运算：AND，OR，XOR和NOT

  BITPOS key bit [start] [end]
      summary: Find first bit set or clear in a string
      since: 2.8.7
      # 查找字符串中第一个设置为1或0的bit的索引位，从指定索引的左边开始寻找

  DECR key
      summary: Decrement the integer value of a key by one
      since: 1.0.0
      # 为键 key 储存的数字值减去一。
      # 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECR 操作。
      # 如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误。
      # 本操作的值限制在 64 位(bit)有符号数字表示之内。
      # 返回键 key 在执行减一操作之后的值。

  DECRBY key decrement
      summary: Decrement the integer value of a key by the given number
      since: 1.0.0
      # 将键 key 储存的整数值减去减量 decrement 。
      # 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECRBY 命令。
      # 如果键 key 储存的值不能被解释为数字， 那么 DECRBY 命令将返回一个错误。
      # 本操作的值限制在 64 位(bit)有符号数字表示之内。
      # 返回键在执行减法操作之后的值。

  GET key
      summary: Get the value of a key
      since: 1.0.0
      # 如果键 key 不存在， 那么返回特殊值 nil ； 否则， 返回键 key 的值
      # 如果键 key 的值并非字符串类型， 那么返回一个错误， 因为 GET 命令只能用于字符串值

  GETBIT key offset
      summary: Returns the bit value at offset in the string value stored at key
      since: 2.2.0
      # 返回指定bit索引偏移量的值

  GETRANGE key start end
      summary: Get a substring of the string stored at a key
      since: 2.4.0
      # 返回键 key 储存的字符串值的指定部分， 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。
      # 负数偏移量表示从字符串的末尾开始计数， -1 表示最后一个字符， -2 表示倒数第二个字符， 以此类推。
      # GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

  GETSET key value
      summary: Set the string value of a key and return its old value
      since: 1.0.0
      # 将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值。
      # 返回给定键 key 的旧值。
      # 如果键 key 没有旧值， 也即是说， 键 key 在被设置之前并不存在， 那么命令返回 nil 
      # 当键 key 存在但不是字符串类型时， 命令返回一个错误。
      
  INCR key
      summary: Increment the integer value of a key by one
      since: 1.0.0
      # 为键 key 储存的数字值加上一。
      # 如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。
      # 如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。
      # 本操作的值限制在 64 位(bit)有符号数字表示之内。
      # 返回键 key 在执行加一操作之后的值。

  INCRBY key increment
      summary: Increment the integer value of a key by the given amount
      since: 1.0.0
      # 为键 key 储存的数字值加上增量 increment 。
      # 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 INCRBY 命令。
      # 如果键 key 储存的值不能被解释为数字， 那么 INCRBY 命令将返回一个错误。
      # 本操作的值限制在 64 位(bit)有符号数字表示之内。
      # 返回在加上增量 increment 之后， 键 key 当前的值。
      
  INCRBYFLOAT key increment
      summary: Increment the float value of a key by the given amount
      since: 2.6.0
      # 为键 key 储存的值加上浮点数增量 increment 。
      # 如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。
      # 如果命令执行成功， 那么键 key 的值会被更新为执行加法计算之后的新值， 并且新值会以字符串的形式返回给调用者。
      # 无论是键 key 的值还是增量 increment ， 都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示， 但是， 执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存， 也即是， 它们总是由一个数字， 一个（可选的）小数点和一个任意长度的小数部分组成（比如 3.14 、 69.768 ，诸如此类)， 小数部分尾随的 0 会被移除， 如果可能的话， 命令还会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。
      # 此外， 无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 命令的计算结果最多只保留小数点的后十七位。
      # 当以下任意一个条件发生时， 命令返回一个错误：1）键 key 的值不是字符串类型。 2）键 key 当前的值或者给定的增量 increment 不能被解释(parse)为双精度浮点数。
      
  MGET key [key ...]
      summary: Get the values of all the given keys
      since: 1.0.0
      # 返回给定的一个或多个字符串键的值

  MSET key value [key value ...]
      summary: Set multiple keys to multiple values
      since: 1.0.1
      # 同时为多个键设置值。
      # 如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。
      # MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。
      # MSET 命令总是返回 OK 

  MSETNX key value [key value ...]
      summary: Set multiple keys to multiple values, only if none of the keys exist
      since: 1.0.1
      # 当且仅当所有给定键都不存在时， 为所有给定键设置值。
      # 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
      # MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。
      # 当所有给定键都设置成功时， 命令返回 1 ； 如果因为某个给定键已经存在而导致设置未能成功执行， 那么命令返回 0 。

  PSETEX key milliseconds value
      summary: Set the value and expiration in milliseconds of a key
      since: 2.6.0
      # 这个命令和 SETEX 命令相似， 但它以毫秒为单位设置 key 的生存时间， 而不是像 SETEX 命令那样以秒为单位进行设置。
      # 命令在设置成功时返回 OK 

  SET key value [EX seconds] [PX milliseconds] [NX|XX]
      summary: Set the string value of a key
      since: 1.0.0
      # 将字符串值 value 关联到 key 。
      # 如果 key 已经持有其他值， SET 就覆写旧值， 无视类型
      # 当 SET 命令对一个带有生存时间（TTL）的键进行设置之后， 该键原有的 TTL 将被清除。
      #从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改：
            EX seconds ： 将键的过期时间设置为 seconds 秒。 执行 SET key value EX seconds 的效果等同于执行 SETEX key seconds value 。
            PX milliseconds ： 将键的过期时间设置为 milliseconds 毫秒。 执行 SET key value PX milliseconds 的效果等同于执行 PSETEX key milliseconds value 。
            NX ： 只在键不存在时， 才对键进行设置操作。 执行 SET key value NX 的效果等同于执行 SETNX key value 。
            XX ： 只在键已经存在时， 才对键进行设置操作。

  SETBIT key offset value
      summary: Sets or clears the bit at offset in the string value stored at key
      since: 2.2.0

  SETEX key seconds value
      summary: Set the value and expiration of a key
      since: 2.0.0
      # 将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。
      # 如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。
      # SETEX 和SET EXPIRE这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的时候非常实用

  SETNX key value
      summary: Set the value of a key, only if the key does not exist
      since: 1.0.0
      # 只在键 key 不存在的情况下， 将键 key 的值设置为 value 。
      # 若键 key 已经存在， 则 SETNX 命令不做任何动作
      # SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
      # 设置成功时返回 1 ， 设置失败时返回 0 。

  SETRANGE key offset value
      summary: Overwrite part of a string at key starting at the specified offset
      since: 2.2.0
      # 从偏移量 offset 开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。
      # 不存在的键 key 当作空白字符串处理。
      # SETRANGE 命令会确保字符串足够长以便将 value 设置到指定的偏移量上， 如果键 key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长，但你设置的 offset 是 10 )， 那么原字符和偏移量之间的空白将用零字节(zerobytes, "\x00" )进行填充。
      # 因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内， 所以用户能够使用的最大偏移量为 2^29-1(536870911) ， 如果你需要使用比这更大的空间， 请使用多个 key 。
      
  STRLEN key
      summary: Get the length of the value stored in a key
      since: 2.2.0
      # 返回键 key 储存的字符串值的长度。
      # 当键 key 不存在时， 命令返回 0 。
      # 当 key 储存的不是字符串值时， 返回一个错误。

Hash

简介：在Redis中，哈希类型是指v（值）本身又是一个键值对（k-v）结构
简单使用举例：hset key field value 、hget key field
内部编码：ziplist（压缩列表） 、hashtable（哈希表）
应用场景：缓存用户信息等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
127.0.0.1:6379> help @hash

  HDEL key field [field ...]
      summary: Delete one or more hash fields
      since: 2.0.0
      # 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略
      # 被成功移除的域的数量，不包括被忽略的域。

  HEXISTS key field
      summary: Determine if a hash field exists
      since: 2.0.0
      # 检查给定域 field 是否存在于哈希表 hash 当中。
      # 在给定field存在时返回 1 ， 在给定field不存在时返回 0 。

  HGET key field
      summary: Get the value of a hash field
      since: 2.0.0
      # 返回哈希表中给定域的值。
      # 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil 。

  HGETALL key
      summary: Get all the fields and values in a hash
      since: 2.0.0
      # 返回哈希表 key 中，所有的域和值

  HINCRBY key field increment
      summary: Increment the integer value of a hash field by the given number
      since: 2.0.0
      # 为哈希表 key 中的域 field 的值加上增量 increment 。
      # 增量也可以为负数，相当于对给定域进行减法操作。
      # 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。
      # 如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
      # 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。
      # 本操作的值被限制在 64 位(bit)有符号数字表示之内。
      
  HINCRBYFLOAT key field increment
      summary: Increment the float value of a hash field by the given amount
      since: 2.6.0
      # 为哈希表 key 中的域 field 加上浮点数增量 increment 
      # 如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。
      # 如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。
      # 当以下任意一个条件发生时，返回一个错误：1)域 field 的值不是字符串类型 2)域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数
      
  HKEYS key
      summary: Get all the fields in a hash
      since: 2.0.0
      # 返回哈希表 key 中的所有域。

  HLEN key
      summary: Get the number of fields in a hash
      since: 2.0.0
      # 返回哈希表 key 中域的数量。
      # 当 key 不存在时，返回 0 。

  HMGET key field [field ...]
      summary: Get the values of all the given hash fields
      since: 2.0.0
      # 返回哈希表 key 中，一个或多个给定域的值。
      # 如果给定的域不存在于哈希表，那么返回一个 nil 值。
      # 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

  HMSET key field value [field value ...]
      summary: Set multiple hash fields to multiple values
      since: 2.0.0
      # 同时将多个 field-value (域-值)对设置到哈希表 key 中
      # 此命令会覆盖哈希表中已存在的域。
      # 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

  HSCAN key cursor [MATCH pattern] [COUNT count]
      summary: Incrementally iterate hash fields and associated values
      since: 2.8.0
      # 用于迭代哈希键中的键值对
      # 以上列出的四个命令都支持增量式迭代， 它们每次执行都只会返回少量元素， 所以这些命令可以用于生产环境， 而不会出现像 KEYS 命令、 SMEMBERS 命令带来的问题 —— 当 KEYS 命令被用于处理一个大的数据库时， 又或者 SMEMBERS 命令被用于处理一个大的集合键时， 它们可能会阻塞服务器达数秒之久。
      # 不过， 增量式迭代命令也不是没有缺点的： 举个例子， 使用 SMEMBERS 命令可以返回集合键当前包含的所有元素， 但是对于 SCAN 这类增量式迭代命令来说， 因为在对键进行增量式迭代的过程中， 键可能会被修改， 所以增量式迭代命令只能对被返回的元素提供有限的保证 （offer limited guarantees about the returned elements）。
      # 返回的每个元素都是一个键值对，一个键值对由一个键和一个值组成。

  HSET key field value
      summary: Set the string value of a hash field
      since: 2.0.0
      # 将哈希表 hash 中域 field 的值设置为 value 。
      # 如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。
      # 如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。
      # 当 HSET 命令在哈希表中新创建 field 域并成功为它设置值时， 命令返回 1 ； 如果域 field 已经存在于哈希表， 并且 HSET 命令成功使用新值覆盖了它的旧值， 那么命令返回 0 
      
  HSETNX key field value
      summary: Set the value of a hash field, only if the field does not exist
      since: 2.0.0
      # 当且仅当域 field 尚未存在于哈希表的情况下， 将它的值设置为 value 。
      # 如果给定域已经存在于哈希表当中， 那么命令将放弃执行设置操作。
      # 如果哈希表 hash 不存在， 那么一个新的哈希表将被创建并执行 HSETNX 命令。
      # 在设置成功时返回 1 ， 在给定域已经存在而放弃执行设置操作时返回 0 。

  HSTRLEN key field
      summary: Get the length of the value of a hash field
      since: 3.2.0
      # 返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）。
      # 如果给定的键或者域不存在， 那么命令返回 0 。

  HVALS key
      summary: Get all the values in a hash
      since: 2.0.0
      # 返回哈希表 key 中所有域的值。

List

简介：列表（list）类型是用来存储多个有序的字符串，一个列表最多可以存储2^32-1个元素。
简单实用举例：lpush key value [value …] 、lrange key start end
内部编码：ziplist（压缩列表）、linkedlist（链表）
应用场景：消息队列，文章列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
127.0.0.1:6379> help @list

  BLPOP key [key ...] timeout
      summary: Remove and get the first element in a list, or block until one is available
      since: 2.0.0
      # BLPOP 是列表的阻塞式(blocking)弹出原语。
      # 它是 LPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
      # 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。
      # 如果列表为空，返回一个 nil 。 否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值
      
  BRPOP key [key ...] timeout
      summary: Remove and get the last element in a list, or block until one is available
      since: 2.0.0
      # BRPOP 是列表的阻塞式(blocking)弹出原语。
      # 它是 RPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
      # 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
      # 假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

  BRPOPLPUSH source destination timeout
      summary: Pop a value from a list, push it to another list and return it; or block until one is available
      since: 2.2.0
      # BRPOPLPUSH 是 RPOPLPUSH source destination 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH source destination 一样。
      # 当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH key value [value …] 或 RPUSH key value [value …] 命令为止。
      # 超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。
      # 假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。

  LINDEX key index
      summary: Get an element from a list by its index
      since: 1.0.0
      # 返回列表 key 中，下标为 index 的元素。
      # 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推
      # 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
      # 如果 key 不是列表类型，返回一个错误。

  LINSERT key BEFORE|AFTER pivot value
      summary: Insert an element before or after another element in a list
      since: 2.2.0
      # 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后 。
      # 当 pivot 不存在于列表 key 时，不执行任何操作，返回 -1 。
      # 当 key 不存在时， key 被视为空列表，不执行任何操作，返回 0 。
      # 如果 key 不是列表类型，返回一个错误。

  LLEN key
      summary: Get the length of a list
      since: 1.0.0
      # 返回列表 key 的长度。
      # 如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
      # 如果 key 不是列表类型，返回一个错误。

  LPOP key
      summary: Remove and get the first element in a list
      since: 1.0.0
      # 移除并返回列表 key 的头元素。
      # 列表的头元素。 当 key 不存在时，返回 nil 。

  LPUSH key value [value ...]
      summary: Prepend one or multiple values to a list
      since: 1.0.0
      # 将一个或多个值 value 插入到列表 key 的表头
      # 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
      # 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
      # 当 key 存在但不是列表类型时，返回一个错误

  LPUSHX key value
      summary: Prepend a value to a list, only if the list exists
      since: 2.2.0
      # 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
      # 和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。

  LRANGE key start stop
      summary: Get a range of elements from a list
      since: 1.0.0
      # 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
      # 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
      # 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
      # 如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表
      # 如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

  LREM key count value
      summary: Remove elements from a list
      since: 1.0.0
      # 根据参数 count 的值，移除列表中与参数 value 相等的元素。
      # count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
      # count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
      # count = 0 : 移除表中所有与 value 相等的值。

  LSET key index value
      summary: Set the value of an element in a list by its index
      since: 1.0.0
      # 将列表 key 下标为 index 的元素的值设置为 value 。
      # 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

  LTRIM key start stop
      summary: Trim a list to the specified range
      since: 1.0.0
      # 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

  RPOP key
      summary: Remove and get the last element in a list
      since: 1.0.0
      # 移除并返回列表 key 的尾元素。

  RPOPLPUSH source destination
      summary: Remove the last element in a list, prepend it to another list and return it
      since: 1.2.0
      # 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：
      #     将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
      #     将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
      # 如果 source 不存在，值 nil 被返回，并且不执行其他动作。
      # 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

  RPUSH key value [value ...]
      summary: Append one or multiple values to a list
      since: 1.0.0
      # 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
      # 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。
      # 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。
      # 当 key 存在但不是列表类型时，返回一个错误。

  RPUSHX key value
      summary: Append a value to a list, only if the list exists
      since: 2.2.0
      # 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
      # 和 RPUSH key value [value …] 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

Set

简介：集合（set）类型也是用来保存多个的字符串元素，但是不允许重复元素
简单使用举例：sadd key element [element …]、smembers key
内部编码：intset（整数集合）、hashtable（哈希表）
应用场景：用户标签,生成随机数抽奖、社交需求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
127.0.0.1:6379> help @set

  SADD key member [member ...]
      summary: Add one or more members to a set
      since: 1.0.0
      # 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
      # 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
      # 当 key 不是集合类型时，返回一个错误。

  SCARD key
      summary: Get the number of members in a set
      since: 1.0.0
      # 返回集合 key 的基数(集合中元素的数量)。
      # 当 key 不存在时，返回 0 。

  SDIFF key [key ...]
      summary: Subtract multiple sets
      since: 1.0.0
      # 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
      # 不存在的 key 被视为空集。

  SDIFFSTORE destination key [key ...]
      summary: Subtract multiple sets and store the resulting set in a key
      since: 1.0.0
      # 这个命令的作用和 SDIFF key [key …] 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
      # 如果 destination 集合已经存在，则将其覆盖。
      # destination 可以是 key 本身

  SINTER key [key ...]
      summary: Intersect multiple sets
      since: 1.0.0
      # 返回一个集合的全部成员，该集合是所有给定集合的交集。
      # 不存在的 key 被视为空集。
      # 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

  SINTERSTORE destination key [key ...]
      summary: Intersect multiple sets and store the resulting set in a key
      since: 1.0.0
      # 这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
      # 如果 destination 集合已经存在，则将其覆盖。
      # destination 可以是 key 本身。

  SISMEMBER key member
      summary: Determine if a given value is a member of a set
      since: 1.0.0
      # 判断 member 元素是否集合 key 的成员。
      # 如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

  SMEMBERS key
      summary: Get all the members in a set
      since: 1.0.0
      # 返回集合 key 中的所有成员。
      # 不存在的 key 被视为空集合。

  SMOVE source destination member
      summary: Move a member from one set to another
      since: 1.0.0
      # 将 member 元素从 source 集合移动到 destination 集合。
      # 如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。
      # 当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。
      # 当 source 或 destination 不是集合类型时，返回一个错误。
      # 如果 member 元素被成功移除，返回 1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

  SPOP key
      summary: Remove and return a random member from a set
      since: 1.0.0
      # 移除并返回集合中的一个随机元素。
      # 如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER key [count] 命令。
      # 被移除的随机元素。 当 key 不存在或 key 是空集时，返回 nil 。

  SRANDMEMBER key [count]
      summary: Get one or multiple random members from a set
      since: 1.0.0
      # 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。
      # 从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数：
      #     如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
      #     如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
      # 该操作和 SPOP key 相似，但 SPOP key 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

  SREM key member [member ...]
      summary: Remove one or more members from a set
      since: 1.0.0
      # 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
      # 当 key 不是集合类型，返回一个错误。
      # 被成功移除的元素的数量，不包括被忽略的元素。

  SSCAN key cursor [MATCH pattern] [COUNT count]
      summary: Incrementally iterate Set elements
      since: 2.8.0
      # 用于迭代set键中的键值对
      # 以上列出的四个命令都支持增量式迭代， 它们每次执行都只会返回少量元素， 所以这些命令可以用于生产环境， 而不会出现像 KEYS 命令、 SMEMBERS 命令带来的问题 —— 当 KEYS 命令被用于处理一个大的数据库时， 又或者 SMEMBERS 命令被用于处理一个大的集合键时， 它们可能会阻塞服务器达数秒之久。
      # 不过， 增量式迭代命令也不是没有缺点的： 举个例子， 使用 SMEMBERS 命令可以返回集合键当前包含的所有元素， 但是对于 SCAN 这类增量式迭代命令来说， 因为在对键进行增量式迭代的过程中， 键可能会被修改， 所以增量式迭代命令只能对被返回的元素提供有限的保证 （offer limited guarantees about the returned elements）。

  SUNION key [key ...]
      summary: Add multiple sets
      since: 1.0.0
      # 返回一个集合的全部成员，该集合是所有给定集合的并集。
      # 不存在的 key 被视为空集。

  SUNIONSTORE destination key [key ...]
      summary: Add multiple sets and store the resulting set in a key
      since: 1.0.0
      # 这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
      # 如果 destination 已经存在，则将其覆盖。
      # destination 可以是 key 本身。
      # 结果集中的元素数量。

Sorted Set

简介：已排序的字符串集合，同时元素不能重复
简单格式举例：zadd key score member [score member …]，zrank key member
底层内部编码：ziplist（压缩列表）、skiplist（跳跃表）
应用场景：排行榜，社交需求（如用户点赞）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
127.0.0.1:6379> help @sorted_set

  ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
      summary: Add one or more members to a sorted set, or update its score if it already exists
      since: 1.2.0
      # 将一个或多个 member 元素及其 score 值加入到有序集 key 当中
      # 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
      # score 值可以是整数值或双精度浮点数。
      # 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
      # 当 key 存在但不是有序集类型时，返回一个错误。

  ZCARD key
      summary: Get the number of members in a sorted set
      since: 1.2.0
      # 当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。

  ZCOUNT key min max
      summary: Count the members in a sorted set with scores within the given values
      since: 2.0.0
      # 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

  ZINCRBY key increment member
      summary: Increment the score of a member in a sorted set
      since: 1.2.0
      # 为有序集 key 的成员 member 的 score 值加上增量 increment 。
      # 可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
      # 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
      # 当 key 不是有序集类型时，返回一个错误。
      # score 值可以是整数值或双精度浮点数
      # member 成员的新 score 值，以字符串形式表示。

  ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
      summary: Intersect multiple sorted sets and store the resulting sorted set in a new key
      since: 2.0.0
      # 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
      # 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
      # WEIGHTS指定对应key的权重，redis该key对应值得分值乘上权重系数，再根据AGGREGATE聚合函数统计，默认相加
      # 保存到 destination 的结果集的基数。

  ZLEXCOUNT key min max
      summary: Count the number of members in a sorted set between a given lexicographical range
      since: 2.8.9
      # 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。
      # 这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 min 参数和 max 参数的意义一样。

  ZRANGE key start stop [WITHSCORES]
      summary: Return a range of members in a sorted set, by index
      since: 1.2.0
      # 返回有序集 key 中，指定区间内的成员。
      # 其中成员的位置按 score 值递增(从小到大)来排序。
      # 具有相同 score 值的成员按字典序(lexicographical order )来排列。
      # 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE key start stop [WITHSCORES] 命令。
      # 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
      # 超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
      # 可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

  ZRANGEBYLEX key min max [LIMIT offset count]
      summary: Return a range of members in a sorted set, by lexicographical range
      since: 2.8.9
      # 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
      # 如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。
      # 命令会使用 C 语言的 memcmp() 函数， 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。
      # 可选的 LIMIT offset count 参数用于获取指定范围内的匹配元素 （就像 SQL 中的 SELECT LIMIT offset count 语句）。 需要注意的一点是， 如果 offset 参数的值非常大的话， 那么命令在返回结果之前， 需要先遍历至 offset 所指定的位置， 这个操作会为命令加上最多 O(N) 复杂度。
      # 合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。
      # 特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素。

  ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
      summary: Return a range of members in a sorted set, by score
      since: 1.0.5
      # 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
      # 具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。
      # 可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
      # 可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。 该选项自 Redis 2.0 版本起可用。
      # min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
      # 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

  ZRANK key member
      summary: Determine the index of a member in a sorted set
      since: 2.0.0
      # 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
      # 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
      # 使用 ZREVRANK key member 命令可以获得成员按 score 值递减(从大到小)排列的排名。
      # 如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

  ZREM key member [member ...]
      summary: Remove one or more members from a sorted set
      since: 1.2.0
      # 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
      # 当 key 存在但不是有序集类型时，返回一个错误。

  ZREMRANGEBYLEX key min max
      summary: Remove all members in a sorted set between the given lexicographical range
      since: 2.8.9
      # 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。
      # 这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 min 参数和 max 参数的意义一样。
      # 返回被移除的元素数量。

  ZREMRANGEBYRANK key start stop
      summary: Remove all members in a sorted set within the given indexes
      since: 2.0.0
      # 移除有序集 key 中，指定排名(rank)区间内的所有成员。
      # 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
      # 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
      # 返回被移除的元素数量。

  ZREMRANGEBYSCORE key min max
      summary: Remove all members in a sorted set within the given scores
      since: 1.2.0
      # 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
      # 自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 命令。
      # 返回被移除的元素数量。

  ZREVRANGE key start stop [WITHSCORES]
      summary: Return a range of members in a sorted set, by index, with scores ordered from high to low
      since: 1.2.0
      # 返回有序集 key 中，指定区间内的成员。
      # 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
      # 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。

  ZREVRANGEBYLEX key max min [LIMIT offset count]
      summary: Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
      since: 2.8.9
      #参见ZRANGEBYLEX，列表排列从大到小

  ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
      summary: Return a range of members in a sorted set, by score, with scores ordered from high to low
      since: 2.2.0
      # 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
      # 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。
      # 除了成员按 score 值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 命令一样。

  ZREVRANK key member
      summary: Determine the index of a member in a sorted set, with scores ordered from high to low
      since: 2.0.0
      # 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
      # 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。
      # 使用 ZRANK key member 命令可以获得成员按 score 值递增(从小到大)排列的排名。

  ZSCAN key cursor [MATCH pattern] [COUNT count]
      summary: Incrementally iterate sorted sets elements and associated scores
      since: 2.8.0
      # 用于迭代zset键中的键值对
      # 以上列出的四个命令都支持增量式迭代， 它们每次执行都只会返回少量元素， 所以这些命令可以用于生产环境， 而不会出现像 KEYS 命令、 SMEMBERS 命令带来的问题 —— 当 KEYS 命令被用于处理一个大的数据库时， 又或者 SMEMBERS 命令被用于处理一个大的集合键时， 它们可能会阻塞服务器达数秒之久。
      # 不过， 增量式迭代命令也不是没有缺点的： 举个例子， 使用 SMEMBERS 命令可以返回集合键当前包含的所有元素， 但是对于 SCAN 这类增量式迭代命令来说， 因为在对键进行增量式迭代的过程中， 键可能会被修改， 所以增量式迭代命令只能对被返回的元素提供有限的保证 （offer limited guarantees about the returned elements）。

  ZSCORE key member
      summary: Get the score associated with the given member in a sorted set
      since: 1.2.0
      # 返回有序集 key 中，成员 member 的 score 值。
      # 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

  ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
      summary: Add multiple sorted sets and store the resulting sorted set in a new key
      since: 2.0.0
      # 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
      # 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
      # 使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
      # 使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。
      #     默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
      # 保存到 destination 的结果集的基数。

Generic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
127.0.0.1:6379> help @generic

  DEL key [key ...]
      summary: Delete a key
      since: 1.0.0
      # 删除给定的一个或多个 key 。
      # 不存在的 key 会被忽略。
      # 被删除 key 的数量。
   
  DUMP key
      summary: Return a serialized version of the value stored at the specified key.
      since: 2.6.0
      # 序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为 Redis 键。
      # 序列化生成的值有以下几个特点：
      #     它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。
      #     值的编码格式和 RDB 文件保持一致。
      #     RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么 Redis 会拒绝对这个值进行反序列化操作。
      # 序列化的值不包括任何生存时间信息。
      # 如果 key 不存在，那么返回 nil 。 否则，返回序列化之后的值。

  EXISTS key [key ...]
      summary: Determine if a key exists
      since: 1.0.0
      # 检查给定 key 是否存在。
      # 若 key 存在，返回 1 ，否则返回 0 。

  EXPIRE key seconds
      summary: Set a key's time to live in seconds
      since: 1.0.0
      # 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
      # 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。
      # 可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。
      # 在 Redis 2.1.3 之前的版本中，修改一个带有生存时间的 key 会导致整个 key 被删除，这一行为是受当时复制(replication)层的限制而作出的，现在这一限制已经被修复。
      # 使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久的』(persistent) key 。

  EXPIREAT key timestamp
      summary: Set the expiration for a key as a UNIX timestamp
      since: 1.2.0
      # EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。
      # 不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
      # 如果生存时间设置成功，返回 1 ； 当 key 不存在或没办法设置生存时间，返回 0 。

  KEYS pattern
      summary: Find all keys matching the given pattern
      since: 1.0.0
      # 查找所有符合给定模式 pattern 的 key
      #     KEYS * 匹配数据库中所有 key 。
      #     KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
      #     KEYS h*llo 匹配 hllo 和 heeeeello 等。
      #     KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
      # KEYS 的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的 key ，你最好还是用 Redis 的集合结构(set)来代替。

  MIGRATE host port key destination-db timeout [COPY] [REPLACE]
      summary: Atomically transfer a key from a Redis instance to another one.
      since: 2.6.0
      # 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
      # 这个命令是一个原子操作，它在执行的时候会阻塞进行迁移的两个实例，直到以下任意结果发生：迁移成功，迁移失败，等待超时。
      # 命令的内部实现是这样的：它在当前实例对给定 key 执行 DUMP 命令 ，将它序列化，然后传送到目标实例，目标实例再使用 RESTORE 对数据进行反序列化，并将反序列化所得的数据添加到数据库中；当前实例就像目标实例的客户端那样，只要看到 RESTORE 命令返回 OK ，它就会调用 DEL 删除自己数据库上的 key 。
      # timeout 参数以毫秒为格式，指定当前实例和目标实例进行沟通的最大间隔时间。这说明操作并不一定要在 timeout 毫秒内完成，只是说数据传送的时间不能超过这个 timeout 数。
      # MIGRATE 命令需要在给定的时间规定内完成 IO 操作。如果在传送数据时发生 IO 错误，或者达到了超时时间，那么命令会停止执行，并返回一个特殊的错误： IOERR 。当 IOERR 出现时，有以下两种可能：
      #     key 可能存在于两个实例
      #     key 可能只存在于当前实例
      # 唯一不可能发生的情况就是丢失 key ，因此，如果一个客户端执行 MIGRATE 命令，并且不幸遇上 IOERR 错误，那么这个客户端唯一要做的就是检查自己数据库上的 key 是否已经被正确地删除。
      # 如果有其他错误发生，那么 MIGRATE 保证 key 只会出现在当前实例中。（当然，目标实例的给定数据库上可能有和 key 同名的键，不过这和 MIGRATE 命令没有关系）

  MOVE key db
      summary: Move a key to another database
      since: 1.0.0
      # 将当前数据库的 key 移动到给定的数据库 db 当中。
      # 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
      # 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
      # 移动成功返回 1 ，失败则返回 0 。
      
  OBJECT subcommand [arguments [arguments ...]]
      summary: Inspect the internals of Redis objects
      since: 2.2.3
      # OBJECT 命令允许从内部察看给定 key 的 Redis 对象， 它通常用在除错(debugging)或者了解为了节省空间而对 key 使用特殊编码的情况。 当将Redis用作缓存程序时，你也可以通过 OBJECT 命令中的信息，决定 key 的驱逐策略(eviction policies)。
      # OBJECT 命令有多个子命令：
      #     OBJECT REFCOUNT <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。
      #     OBJECT ENCODING <key> 返回给定 key 锁储存的值所使用的内部表示(representation)。
      #     OBJECT IDLETIME <key> 返回给定 key 自储存以来的空闲时间(idle， 没有被读取也没有被写入)，以秒为单位。
      # 对象可以以多种方式编码：
      #     字符串可以被编码为 raw (一般字符串)或 int (为了节约内存，Redis 会将字符串表示的 64 位有符号整数编码为整数来进行储存）。
      #     列表可以被编码为 ziplist 或 linkedlist 。 ziplist 是为节约大小较小的列表空间而作的特殊表示。
      #     集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。
      #     哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。
      #     有序集合可以被编码为 ziplist 或者 skiplist 格式。 ziplist 用于表示小的有序集合，而 skiplist 则用于表示任何大小的有序集合。
      # 假如你做了什么让 Redis 没办法再使用节省空间的编码时(比如将一个只有 1 个元素的集合扩展为一个有 100 万个元素的集合)，特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。
      # REFCOUNT 和 IDLETIME 返回数字。 ENCODING 返回相应的编码类型。

  PERSIST key
      summary: Remove the expiration from a key
      since: 2.2.0
      # 移除给定 key 的生存时间，将这个 key 从“易失的”(带生存时间 key )转换成“持久的”(一个不带生存时间、永不过期的 key )。
      # 当生存时间移除成功时，返回 1 . 如果 key 不存在或 key 没有设置生存时间，返回 0 

  PEXPIRE key milliseconds
      summary: Set a key's time to live in milliseconds
      since: 2.6.0
      # 这个命令和 expireat 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 expireat 那样，以秒为单位。
      # 设置成功，返回 1 key 不存在或设置失败，返回 0

  PEXPIREAT key milliseconds-timestamp
      summary: Set the expiration for a key as a UNIX timestamp specified in milliseconds
      since: 2.6.0
      # 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
      # 设置成功，返回 1 key 不存在或设置失败，返回 0

  PTTL key
      summary: Get the time to live for a key in milliseconds
      since: 2.6.0
      # 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
      #     当 key 不存在时，返回 -2 。
      #     当 key 存在但没有设置剩余生存时间时，返回 -1 。
      #     否则，以毫秒为单位，返回 key 的剩余生存时间。
      # 在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

  RANDOMKEY -
      summary: Return a random key from the keyspace
      since: 1.0.0
      # 从当前数据库中随机返回(不删除)一个 key 。
      # 当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil 。

  RENAME key newkey
      summary: Rename a key
      since: 1.0.0
      # 将 key 改名为 newkey 。
      # 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
      # 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
      # 改名成功时提示 OK ，失败时候返回一个错误。

  RENAMENX key newkey
      summary: Rename a key, only if the new key does not exist
      since: 1.0.0
      # 当且仅当 newkey 不存在时，将 key 改名为 newkey 。
      # 当 key 不存在时，返回一个错误。
      # 修改成功时，返回 1 ； 如果 newkey 已经存在，返回 0 。
     
  RESTORE key ttl serialized-value [REPLACE]
      summary: Create a key using the provided serialized value, previously obtained using DUMP.
      since: 2.6.0
      # 反序列化给定的序列化值，并将它和给定的 key 关联。
      # 参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。
      # RESTORE 在执行反序列化之前会先对序列化值的 RDB 版本和数据校验和进行检查，如果 RDB 版本不相同或者数据不完整的话，那么 RESTORE 会拒绝进行反序列化，并返回一个错误。
      # 如果键 key 已经存在， 并且给定了 REPLACE 选项， 那么使用反序列化得出的值来代替键 key 原有的值； 相反地， 如果键 key 已经存在， 但是没有给定 REPLACE 选项， 那么命令返回一个错误。

  SCAN cursor [MATCH pattern] [COUNT count]
      summary: Incrementally iterate the keys space
      since: 2.8.0
      # SCAN 命令及其相关的 SSCAN 命令、 HSCAN 命令和 ZSCAN 命令都用于增量地迭代（incrementally iterate）一集元素（a collection of elements）：
      #     SCAN 命令用于迭代当前数据库中的数据库键。
      #     SSCAN 命令用于迭代集合键中的元素。
      #     HSCAN 命令用于迭代哈希键中的键值对。
      #     ZSCAN 命令用于迭代有序集合中的元素（包括元素成员和元素分值）。
      # 以上列出的四个命令都支持增量式迭代， 它们每次执行都只会返回少量元素， 所以这些命令可以用于生产环境， 而不会出现像 KEYS 命令、 SMEMBERS 命令带来的问题 —— 当 KEYS 命令被用于处理一个大的数据库时， 又或者 SMEMBERS 命令被用于处理一个大的集合键时， 它们可能会阻塞服务器达数秒之久。
      # 不过， 增量式迭代命令也不是没有缺点的： 举个例子， 使用 SMEMBERS 命令可以返回集合键当前包含的所有元素， 但是对于 SCAN 这类增量式迭代命令来说， 因为在对键进行增量式迭代的过程中， 键可能会被修改， 所以增量式迭代命令只能对被返回的元素提供有限的保证 （offer limited guarantees about the returned elements）。

  SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination]
      summary: Sort the elements in a list, set or sorted set
      since: 1.0.0
      # 返回或保存给定列表、集合、有序集合 key 中经过排序的元素。
      # 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
      # 最简单的 SORT 使用方法是 SORT key 和 SORT key DESC ：
      #     SORT key 返回键值从小到大排序的结果。
      #     SORT key DESC 返回键值从大到小排序的结果。
      # 因为 SORT 命令默认排序对象为数字， 当需要对字符串进行排序时， 需要显式地在 SORT 命令之后添加 ALPHA 修饰符。
      # 如果系统正确地设置了 LC_COLLATE 环境变量的话，Redis能识别 UTF-8 编码。
      # 排序之后返回元素的数量可以通过 LIMIT 修饰符进行限制， 修饰符接受 offset 和 count 两个参数：
      #     offset 指定要跳过的元素数量。
      #     count 指定跳过 offset 个指定的元素之后，要返回多少个对象。
      # 其他玩法请自行查阅资料

  TTL key
      summary: Get the time to live for a key
      since: 1.0.0
      # 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
      # 当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间。

  TYPE key
      summary: Determine the type stored at key
      since: 1.0.0
      # 返回 key 所储存的值的类型。

  WAIT numslaves timeout
      summary: Wait for the synchronous replication of all the write commands sent in the context of the current connection
      since: 3.0.0
      # 等待在当前连接上下文中发送的所有写命令的同步复制

Transactions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
127.0.0.1:6379> help @transactions

  DISCARD -
      summary: Discard all commands issued after MULTI
      since: 2.0.0
      # 取消事务，放弃执行事务块内的所有命令。
      # 如果正在使用 WATCH 命令监视某个(或某些) key，那么取消所有监视，等同于执行命令 UNWATCH 。

  EXEC -
      summary: Execute all commands issued after MULTI
      since: 1.2.0
      # 执行所有事务块内的命令。
      # 假如某个(或某些) key 正处于 WATCH 命令的监视之下，且事务块中有和这个(或这些) key 相关的命令，那么 EXEC 命令只在这个(或这些) key 没有被其他命令所改动的情况下执行并生效，否则该事务被打断(abort)。

  MULTI -
      summary: Mark the start of a transaction block
      since: 1.2.0
      # 标记一个事务块的开始。
      # 事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行。

  UNWATCH -
      summary: Forget about all watched keys
      since: 2.2.0
      # 取消 WATCH 命令对所有 key 的监视。
      # 如果在执行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行 UNWATCH 了。
      # 因为 EXEC 命令会执行事务，因此 WATCH 命令的效果已经产生了；而 DISCARD 命令在取消事务的同时也会取消所有对 key 的监视，因此这两个命令执行之后，就没有必要执行 UNWATCH 了。

  WATCH key [key ...]
      summary: Watch the given keys to determine execution of the MULTI/EXEC block
      since: 2.2.0
      # 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

BloomFilter

1
2
3
4
5
BF.ADD key ...options...
    # 添加key到bloom中

BF.EXISTS key ...options...
	# 判断是否存在对应的key