一、Key(键)

1. DEL

格式：DEL key [key …]
删除给定的一个或多个 key 。
不存在的 key 会被忽略。
可用版本： >= 1.0.0
时间复杂度： O(N)， N 为被删除的 key 的数量。
删除单个字符串类型的 key ，时间复杂度为O(1)。
删除单个列表、集合、有序集合或哈希表类型的 key ，时间复杂度为O(M)， M 为以上数据结构内的元素数量。
返回值： 被删除 key 的数量。

示例：

# 删除单个 key
redis> SET name huangz
OK
redis> DEL name
(integer) 1
# 删除一个不存在的 key
redis> EXISTS phone
(integer) 0
redis> DEL phone # 失败，没有 key 被删除
(integer) 0
# 同时删除多个 key
redis> SET name "redis"
OK
redis> SET type "key-value store"
OK
redis> SET website "redis.com"
OK
redis> DEL name type website
(integer) 3

2. KEYS

格式：keys pattern
查找所有符合给定模式 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)来代替。
可用版本：>= 1.0.0
时间复杂度： O(N)， N 为数据库中 key 的数量。
返回值： 符合给定模式的 key 列表。

示例：

redis> MSET one 1 two 2 three 3 four 4 # 一次设置 4 个 key
OK
redis> KEYS *o*
1) "four"
2) "two"
3) "one"
redis> KEYS t??
1) "two"
redis> KEYS t[w]*
1) "two"
redis> KEYS *     # 匹配数据库内所有 key
1) "four"
2) "three"
3) "two"
4) "one"

3. RANDOMKEY

格式：randomkey
从当前数据库中随机返回(不删除)一个 key 。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值：
当数据库不为空时，返回一个 key 。
当数据库为空时，返回 nil 。

示例：

# 数据库不为空
redis> MSET fruit "apple" drink "beer" food "cookies" # 设置多个 key
OK
redis> RANDOMKEY
"fruit"
redis> RANDOMKEY
"food"
redis> KEYS *   # 查看数据库内所有key，证明 RANDOMKEY 并不删除 key
1) "food"
2) "drink"
3) "fruit"
# 数据库为空
redis> FLUSHDB # 删除当前数据库所有 key
OK
redis> RANDOMKEY
(nil)

4. TTL

格式：ttl key
以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值：
当 key 不存在时，返回 -2 。
当 key 存在但没有设置剩余生存时间时，返回 -1 。
否则，以秒为单位，返回 key 的剩余生存时间。
注意：在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

实例：

# 不存在的 key
redis> FLUSHDB
OK
redis> TTL key
(integer) -2
# key 存在，但没有设置剩余生存时间
redis> SET key value
OK
redis> TTL key
(integer) -1
# 有剩余生存时间的 key
redis> EXPIRE key 10086
(integer) 1
redis> TTL key
(integer) 10084

5. PTTL

格式：pttl key
这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像TTL 命令那样，以秒为单位。
可用版本：>= 2.6.0
复杂度： O(1)
返回值：
当 key 不存在时，返回 -2 。
当 key 存在但没有设置剩余生存时间时，返回 -1 。
否则，以毫秒为单位，返回 key 的剩余生存时间。
注意：在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

实例：

# 不存在的 key
redis> FLUSHDB
OK
redis> PTTL key
(integer) -2
# key 存在，但没有设置剩余生存时间
redis> SET key value
OK
redis> PTTL key
(integer) -1
# 有剩余生存时间的 key
redis> PEXPIRE key 10086
(integer) 1
redis> PTTL key
(integer) 6179

6. EXISTS

格式：exists key
检查给定 key 是否存在。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值： 若 key 存在，返回 1 ，否则返回 0 。

实例：

redis> SET db "redis"
OK
redis> EXISTS db
(integer) 1
redis> DEL db
(integer) 1
redis> EXISTS db
(integer) 0

7. MOVE

格式：move key db
将当前数据库的 key 移动到给定的数据库 db 当中。
如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者key 不存在于当前数据库，那么 MOVE 没有任何效果。
因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值： 移动成功返回 1 ，失败则返回 0 。

实例：

# key 存在于当前数据库
redis> SELECT 0 #redis 默认使用数据库 0，为了清晰起见，这里再显式指定一次。
OK
redis> SET song "secret base - Zone"
OK
redis> MOVE song 1 # 将 song 移动到数据库 1
(integer) 1
redis> EXISTS song # song 已经被移走
(integer) 0
redis> SELECT 1 # 使用数据库 1
OK
redis:1> EXISTS song # 证实 song 被移到了数据库 1 (注意命令提示符变成了"redis:1"，表明正在使用数据库 1)
(integer) 1
# 当 key 不存在的时候
redis:1> EXISTS fake_key
(integer) 0
redis:1> MOVE fake_key 0 # 试图从数据库 1 移动一个不存在的 key 到数据库0，失败
(integer) 0
redis:1> select 0 # 使用数据库0
OK
redis> EXISTS fake_key # 证实 fake_key 不存在
(integer) 0
# 当源数据库和目标数据库有相同的 key 时
redis> SELECT 0 # 使用数据库0
OK
redis> SET favorite_fruit "banana"
OK
redis> SELECT 1 # 使用数据库1
OK
redis:1> SET favorite_fruit "apple"
OK
redis:1> SELECT 0 # 使用数据库0，并试图将 favorite_fruit 移动到数据库 1
OK
redis> MOVE favorite_fruit 1 # 因为两个数据库有相同的 key，MOVE 失败
(integer) 0
redis> GET favorite_fruit # 数据库 0 的 favorite_fruit 没变
"banana"
redis> SELECT 1
OK
redis:1> GET favorite_fruit # 数据库 1 的 favorite_fruit 也没变
"apple"

8. RENAME

格式：rename key newkey
将 key 改名为 newkey 。
当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
当 newkey 已经存在时， RENAME 命令将覆盖旧值。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值： 改名成功时提示 OK ，失败时候返回一个错误。

实例：

# key 存在且 newkey 不存
redis> SET message "hello world"
OK
redis> RENAME message greeting
OK
redis> EXISTS message # message 不复存在
(integer) 0
redis> EXISTS greeting # greeting 取而代之
(integer) 1
# 当 key 不存在时，返回错误
redis> RENAME fake_key never_exists
(error) ERR no such key
# newkey 已存在时， RENAME 会覆盖旧 newkey
redis> SET pc "lenovo"
OK
redis> SET personal_computer "dell"
OK
redis> RENAME pc personal_computer  # 相当于 pc 的 value "lenovo" 换了一个地址引用 personal_computer  
OK
redis> GET pc
(nil)
redis:1> GET personal_computer # 原来的值 dell 被覆盖了
"lenovo"

9. RENAMENX

格式：renamenx key newkey
当且仅当 newkey 不存在时，将 key 改名为 newkey 。
当 key 不存在时，返回一个错误。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值：
修改成功时，返回 1 。
如果 newkey 已经存在，返回 0 。

实例：

# newkey 不存在，改名成功
redis> SET player "MPlyaer"
OK
redis> EXISTS best_player
(integer) 0
redis> RENAMENX player best_player
(integer) 1
# newkey 存在时，失败
redis> SET animal "bear"
OK
redis> SET favorite_animal "butterfly"
OK
redis> RENAMENX animal favorite_animal
(integer) 0
redis> get animal
"bear"
redis> get favorite_animal
"butterfly"

10. TYPE

格式：type key
返回 key 所存储的值的类型。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值：
none (key 不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)

实例：

# 字符串
redis> SET weather "sunny"
OK
redis> TYPE weather
string
# 列表
redis> LPUSH book_list "programming in scala"
(integer) 1
redis> TYPE book_list
list
# 集合
redis> SADD pat "dog"
(integer) 1
redis> TYPE pat
set

11. EXPIRE

格式：expire key seconds
为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
1.在 Redis 中，带有生存时间的 key 被称为『可挥发』(volatile)的。
2.生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值，而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。
比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPUSH 命令，或者对一个哈希
表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。
3.另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。
RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。
4.使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久化』(persistent) key 。
5.更新生存时间：
可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。
6.过期时间的精确度：
在 Redis 2.4 版本中，过期时间的延迟在 1 秒钟之内 —— 也即是，就算 key 已经过期，但它还是可能在过期之后一秒钟之内被访问到，而在新的 Redis 2.6 版本中，延迟被降低到 1 毫秒之内。
7.Redis 2.1.3 之前的不同之处：
在 Redis 2.1.3 之前的版本中，修改一个带有生存时间的 key 会导致整个 key 被删除，这一行为是受当时复制(replication)层的限制而作出的，现在这一限制已经被修复。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值：
设置成功返回 1 。
当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

实例：

redis> SET cache_page "www.google.com"
OK
redis> EXPIRE cache_page 30 # 设置过期时间为 30 秒
(integer) 1
redis> TTL cache_page # 查看剩余生存时间
(integer) 23
redis> EXPIRE cache_page 30000 # 更新过期时间
(integer) 1
redis> TTL cache_page
(integer) 29996

应用：导航会话

假设你有一项 web 服务，打算根据用户最近访问的 N 个页面来进行物品推荐，并且假设用户停止阅览超过 60 秒，那么就清空阅览记录(为了减少物品推荐的计算量，并且保持推荐物品的新鲜度)。
这些最近访问的页面记录，我们称之为『导航会话』(Navigation session)，可以用 INCR 和 RPUSH 命令在 Redis 中实现它：每当用户阅览一个网页的时候，执行以下代码：

MULTI
RPUSH pagewviews.user:<userid> http://.....
EXPIRE pagewviews.user:<userid> 60
EXEC

如果用户停止阅览超过 60 秒，那么它的导航会话就会被清空，当用户重新开始阅览的时候，系统又会重新记录导航会话，继续进行物品推荐。

12. PEXPIRE

格式：pexpire key milliseconds
这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
可用版本：>= 2.6.0
时间复杂度： O(1)
返回值：
设置成功，返回 1
key 不存在或设置失败，返回 0

实例：

redis> SET mykey "Hello"
OK
redis> PEXPIRE mykey 1500
(integer) 1
redis> TTL mykey # TTL 的返回值以秒为单位
(integer) 2
redis> PTTL mykey # PTTL 可以给出准确的毫秒数
(integer) 1499

13. EXPIREAT

格式：expireat key timestamp
EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。
不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
可用版本：>= 1.2.0
时间复杂度： O(1)
返回值：
如果生存时间设置成功，返回 1 。
当 key 不存在或没办法设置生存时间，返回 0 。

实例：

redis> SET cache www.google.com
OK
redis> EXPIREAT cache 1355292000 # 这个 key 将在 2012.12.12 过期
(integer) 1
redis> TTL cache
(integer) 45081860

14. PEXPIREAT

格式：pexpireat key milliseconds
这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
可用版本：>= 2.6.0
时间复杂度： O(1)
返回值：
如果生存时间设置成功，返回 1 。
当 key 不存在或没办法设置生存时间时，返回 0 。

实例：

redis> SET mykey "Hello"
OK
redis> PEXPIREAT mykey 1555555555005
(integer) 1
redis> TTL mykey # TTL 返回秒
(integer) 223157079
redis> PTTL mykey # PTTL 返回毫秒
(integer) 223157079318

15. PERSIST

格式：persist key
移除给定 key 的生存时间，将这个 key 从『可挥发』的(带生存时间 key )转换成『持久化』的(一个不带生存时间、永不过期的 key )。
可用版本： >= 2.2.0
时间复杂度： O(1)
返回值：
当生存时间移除成功时，返回 1 .
如果 key 不存在或 key 没有设置生存时间，返回 0 。

实例：

redis> SET mykey "Hello"
OK
redis> EXPIRE mykey 10 # 为 key 设置生存时间
(integer) 1
redis> TTL mykey
(integer) 10
redis> PERSIST mykey # 移除 key 的生存时间
(integer) 1
redis> TTL mykey
(integer) -1

16. SORT

格式：sort key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern …]]
[ASC | DESC] [ALPHA] [STORE destination]
返回或保存给定列表、集合、有序集合 key 中经过排序的元素。
排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
可用版本：>= 1.0.0
时间复杂度：
O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。
如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
返回值：
没有使用 STORE 参数，返回列表形式的排序结果。
使用 STORE 参数，返回排序结果的元素数量。

（1）一般 SORT 用法

最简单的 SORT 使用方法是 SORT key 。
假设 today_cost 是一个保存数字的列表， SORT 命令默认会返回该列表值的递增(从小到大)排序结果。

实例：

# 将数据一一加入到列表中
redis> LPUSH today_cost 30
(integer) 1
redis> LPUSH today_cost 1.5
(integer) 2
redis> LPUSH today_cost 10
(integer) 3
redis> LPUSH today_cost 8
(integer) 4
# 排序
redis> SORT today_cost
1) "1.5"
2) "8"
3) "10"
4) "30"

当数据集中保存的是字符串值时，可以用 ALPHA 修饰符(modifier)进行排序：

# 将数据一一加入到列表中
redis> LPUSH website "www.reddit.com"
(integer) 1
redis> LPUSH website "www.slashdot.com"
(integer) 2
redis> LPUSH website "www.infoq.com"
(integer) 3
# 默认排序
redis> SORT website
1) "www.infoq.com"
2) "www.slashdot.com"
3) "www.reddit.com"
# 按字符排序
redis> SORT website ALPHA
1) "www.infoq.com"
2) "www.reddit.com"
3) "www.slashdot.com"

如果你正确设置了 !LC_COLLATE 环境变量的话，Redis 能识别 UTF-8 编码。
排序之后返回的元素数量可以通过 LIMIT 修饰符进行限制。
LIMIT 修饰符接受两个参数： offset 和 count 。
offset 指定要跳过的元素数量， count 指定跳过 offset 个指定的元素之后，要返回多少个对象。

以下例子返回排序结果的前 5 个对象( offset 为 0 表示没有元素被跳过)：

# 将数据一一加入到列表中
redis> LPUSH rank 30
(integer) 1
redis> LPUSH rank 56
(integer) 2
redis> LPUSH rank 42
(integer) 3
redis> LPUSH rank 22
(integer) 4
redis> LPUSH rank 0
(integer) 5
redis> LPUSH rank 11
(integer) 6
redis> LPUSH rank 32
(integer) 7
redis> LPUSH rank 67
(integer) 8
redis> LPUSH rank 50
(integer) 9
redis> LPUSH rank 44
(integer) 10
redis> LPUSH rank 55
(integer) 11
# 排序
redis> SORT rank LIMIT 0 5 # 返回排名前五的元素
1) "0"
2) "11"
3) "22"
4) "30"
5) "32"

（2）使用外部 key 进行排序

有时候你会希望使用外部的 key 作为权重来比较元素，代替默认的对比方法。
假设现在有用户(user)数据如下：

id 数据保存在 key 名为 user_id 的列表中。
name 数据保存在 key 名为 user_name_{id} 的列表中
level 数据保存在 user_level_{id} 的 key 中。

# 先将要使用的数据加入到数据库中
# admin
redis> LPUSH user_id 1
(integer) 1
redis> SET user_name_1 admin
OK
redis> SET user_level_1 9999
OK
# huangz
redis> LPUSH user_id 2
(integer) 2
redis> SET user_name_2 huangz
OK
redis> SET user_level_2 10
OK
# jack
redis> LPUSH user_id 59230
(integer) 3
redis> SET user_name_59230 jack
OK
redis> SET user_level_59230 3
OK
# hacker
redis> LPUSH user_id 222
(integer) 4
redis> SET user_name_222 hacker
OK
redis> SET user_level_222 9999
OK

如果希望按 level 从大到小排序 user_id ，可以使用以下命令：

redis> SORT user_id BY user_level_* DESC
1) "222" # hacker
2) "1" # admin
3) "2" # huangz
4) "59230" # jack

但是有时候只是返回相应的 id 没有什么用，你可能更希望排序后返回 id 对应的用户名，这样更友好一点，使用 GET 选项可以做到这一点：

redis> SORT user_id BY user_level_* DESC GET user_name_*
1) "hacker"
2) "admin"
3) "huangz"
4) "jack"

可以多次地、有序地使用 GET 操作来获取更多外部 key 。
比如你不但希望获取用户名，还希望连用户的密码也一并列出，可以使用以下命令：

# 先添加一些测试数据
redis> SET user_password_222 "hey,im in"
OK
redis> SET user_password_1 "a_long_long_password"
OK
redis> SET user_password_2 "nobodyknows"
OK
redis> SET user_password_59230 "jack201022"
OK
# 获取 name 和 password
redis> SORT user_id BY user_level_* DESC GET user_name_* GET user_password_*
1) "hacker" # 用户名
2) "hey,im in" # 密码
3) "jack"
4) "jack201022"
5) "huangz"
6) "nobodyknows"
7) "admin"
8) "a_long_long_password"
# 注意 GET 操作是有序的，GET user_name_* GET user_password_* 和 GET user_password_* GET user_name_*返回的结果位置不同
redis> SORT user_id BY user_level_* DESC GET user_password_* GET user_name_*
1) "hey,im in" # 密码
2) "hacker" # 用户名
3) "jack201022"
4) "jack"
5) "nobodyknows"
6) "huangz"
7) "a_long_long_password"
8) "admin"

GET 还有一个特殊的规则—— “GET #” ，用于获取被排序对象(我们这里的例子是user_id )的当前元素。
比如你希望 user_id 按 level 排序，还要列出 id 、 name 和 password ，可以使用以下命令：

redis> SORT user_id BY user_level_* DESC GET # GET user_name_* GET user_password_*
1) "222" # id
2) "hacker" # name
3) "hey,im in" # password
4) "1"
5) "admin"
6) "a_long_long_password"
7) "2"
8) "huangz"
9) "nobodyknows"
10) "59230"
11) "jack"
12) "jack201022"

（3）只获取对象而不排序

BY 修饰符可以将一个不存在的 key 当作权重，让 SORT 跳过排序操作。
该方法用于你希望获取外部对象而又不希望引起排序开销时使用。

# 确保fake_key 不存在
redis> EXISTS fake_key
(integer) 0
# 以 fake_key 作 BY 参数，不排序，只 GET name 和 GET password
redis> SORT user_id BY fake_key GET # GET user_name_* GET user_password_*
1) "222" # id
2) "hacker" # user_name
3) "hey,im in" # password
4) "59230"
5) "jack"
6) "jack201022"
7) "2"
8) "huangz"
9) "nobodyknows"
10) "1"
11) "admin"
12) "a_long_long_password"

（4）保存排序结果

默认情况下， SORT 操作只是简单地返回排序结果，如果你希望保存排序结果，可以给 STORE 选项指定一个 key 作为参数，排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在，则覆盖。)

redis> EXISTS user_info_sorted_by_level # 确保指定 key 不存在
(integer) 0
redis> SORT user_id BY user_level_* GET # GET user_name_* GET user_password_* STORE user_info_sorted_by_level # 排序
(integer) 12 # 显示有 12 条结果被保存了
redis> LRANGE user_info_sorted_by_level 0 11 # 查看排序结果
1) "59230"
2) "jack"
3) "jack201022"
4) "2"
5) "huangz"
6) "nobodyknows"
7) "222"
8) "hacker"
9) "hey,im in"
10) "1"
11) "admin"
12) "a_long_long_password"

一个有趣的用法是将 SORT 结果保存，用 EXPIRE 为结果集设置生存时间，这样结果集就成了 SORT 操作的一个缓存。
这样就不必频繁地调用 SORT 操作了，只有当结果集过期时，才需要再调用一次 SORT操作。
有时候为了正确实现这一用法，你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端，同一时间进行 SORT 操作，并保存为结果集)，具体参见 SETNX 命令。

（5）在 GET 和 BY 中使用哈希表

可以使用哈希表特有的语法，在 SORT 命令中进行 GET 和 BY 操作。

# 假设现在我们的用户表新增了一个 serial 项来为作为每个用户的序列号
# 序列号以哈希表的形式保存在 serial 哈希域内。
redis> HMSET serial 1 23131283 2 23810573 222 502342349 59230 2435829758
OK
# 用 serial 中值的大小为根据，对 user_id 进行排序
redis> SORT user_id BY *->serial
1) "59230"
2) "222"
3) "2"
4) "1"

符号 “->” 用于分割哈希表的键名(key name)和索引域(hash field)，格式为 “key->field” 。
除此之外，哈希表的 BY 和 GET 操作和上面介绍的其他数据结构(列表、集合、有序集合)没有什么不同。

17. OBJECT

格式：object subcommand [arguments [arguments]]
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， 没有被读取也没有被写入)，以秒为单位。
可用版本：>= 2.2.3
时间复杂度： O(1)
返回值：
REFCOUNT 和 IDLETIME 返回数字。
ENCODING 返回相应的编码类型。

对象可以以多种方式编码：
1 字符串可以被编码为 raw (一般字符串)或 int (用字符串表示64 位数字是为了节约空间)。
2 列表可以被编码为 ziplist 或 linkedlist 。 ziplist 是为节约大小较小的列表空间而作的特殊表示。
3 集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。
4 哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。
5 有序集合可以被编码为 ziplist 或者 skiplist 格式。 ziplist 用于表示小的有序集合，而 skiplist 则用于表示任何大小的有序集合。

假如你做了什么让 Redis 没办法再使用节省空间的编码时(比如将一个只有 1 个元素的集合扩展为一个有 100 万个元素的集合)，特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。

实例：

redis> SET game "COD" # 设置一个字符串
OK
redis> OBJECT REFCOUNT game # 只有一个引用
(integer) 1
redis> OBJECT IDLETIME game # 等待一会。。。然后查看空转时间
(integer) 90
redis> GET game # 提取game， 让它处于活跃(active)状态
"COD"
redis> OBJECT IDLETIME game # 不再处于空转
(integer) 0
redis> OBJECT ENCODING game # 字符串的编码方式
"raw"
redis> SET phone 15820123123 # 大的数字也被编码为字符串
OK
redis> OBJECT ENCODING phone
"raw"
redis> SET age 20 # 短数字被编码为 int
OK
redis> OBJECT ENCODING age
"int"

18. MIGRATE

格式：migrate host port key destination-db timeout
将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。

这个命令是一个原子操作，它在执行的时候会阻塞进行迁移的两个实例，直到以下任意结果发生：迁移成功，迁移失败，等到超时。

命令的内部实现是这样的：它在当前实例对给定 key 执行 DUMP 命令 ，将它序列化，然后传送到目标实例，目标实例再使用 RESTORE 对数据进行反序列化，并将反序列化所得的数据添加到数据库中；当前实例就像目标实例的客户端那样，只要看到 RESTORE 命令返
回 OK ，它就会调用 DEL 删除自己数据库上的 key 。

timeout 参数以毫秒为格式，指定当前实例和目标实例进行沟通的最大间隔时间。这说明操作并不一定要在 timeout 毫秒内完成，只是说数据传送的时间不能超过这个 timeout 数。

MIGRATE 命令需要在给定的时间规定内完成 IO 操作。如果在传送数据时发生 IO 错误，或者达到了超时时间，那么命令会停止执行，并返回一个特殊的错误： IOERR 。 当 IOERR 出现时，有以下两种可能：
1、key 可能存在于两个实例
2、key 可能只存在于当前实例

唯一不可能发生的情况就是丢失 key ，因此，如果一个客户端执行 MIGRATE 命令，并且不幸遇上 IOERR 错误，那么这个客户端唯一要做的就是检查自己数据库上的 key 是否已经被正确地删除。

如果有其他错误发生，那么 MIGRATE 保证 key 只会出现在当前实例中。（当然，目标实例的给定数据库上可能有和 key 同名的键，不过这和 MIGRATE 命令没有关系）。

可用版本： >= 2.6.0
时间复杂度：
这个命令在源实例上实际执行 DUMP 命令和 DEL 命令，在目标实例执行 RESTORE 命令，查看以上命令的文档可以看到详细的复杂度说明。
key 数据在两个实例之间传输的复杂度为 O(N) 。
返回值： 迁移成功时返回 OK ，否则返回相应的错误。

示例：
先启动两个 Redis 实例，一个使用默认的 6379 端口，一个使用 7777 端口。

$ ./redis-server &
[1] 3557
...
$ ./redis-server --port 7777 &
[2] 3560
...

然后用客户端连上 6379 端口的实例，设置一个键，然后将它迁移到 7777 端口的实例上：

$ ./redis-cli
redis 127.0.0.1:6379> flushdb
OK
redis 127.0.0.1:6379> SET greeting "Hello from 6379 instance"
OK
redis 127.0.0.1:6379> MIGRATE 127.0.0.1 7777 greeting 0 1000
OK
redis 127.0.0.1:6379> EXISTS greeting # 迁移成功后 key 被删除
(integer) 0

使用另一个客户端，查看 7777 端口上的实例：

$ ./redis-cli -p 7777
redis 127.0.0.1:7777> GET greeting
"Hello from 6379 instance"

19. DUMP

格式：dump key
序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为Redis 键。
序列化生成的值有以下几个特点：
1 它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。
2 值的编码格式和 RDB 文件保持一致。
3 RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么 Redis 会拒绝对这个值进行反序列化操作。
序列化的值不包括任何生存时间信息。
可用版本： >= 2.6.0
时间复杂度：
查找给定键的复杂度为 O(1) ，对键进行序列化的复杂度为 O(N*M) ，其中 N 是构成key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。
如果序列化的对象是比较小的字符串，那么复杂度为 O(1) 。
返回值：
如果 key 不存在，那么返回 nil 。
否则，返回序列化之后的值。

示例：

redis> SET greeting "hello, dumping world!"
OK
redis> DUMP greeting
"\x00\x15hello, dumping world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"
redis> DUMP not-exists-key
(nil)

20. RESTORE

格式：restore key ttl serialized-value
反序列化给定的序列化值，并将它和给定的 key 关联。
参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。
RESTORE 在执行反序列化之前会先对序列化值的 RDB 版本和数据校验和进行检查，如果 RDB 版本不相同或者数据不完整的话，那么 RESTORE 会拒绝进行反序列化，并返回一个错误。
更多信息可以参考 DUMP 命令。
可用版本： >= 2.6.0
时间复杂度：
查找给定键的复杂度为 O(1) ，对键进行反序列化的复杂度为 O(NM) ，其中 N 是构成 key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。
有序集合(sorted set)的反序列化复杂度为 O(NM*log(N)) ，因为有序集合每次插入的复杂度为 O(log(N)) 。
如果反序列化的对象是比较小的字符串，那么复杂度为 O(1) 。
返回值：
如果反序列化成功那么返回 OK ，否则返回一个错误。

示例：

redis> SET greeting "hello, dumping world!"
OK
redis> DUMP greeting
"\x00\x15hello, dumping world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"
redis> RESTORE greeting-again 0 "\x00\x15hello, dumping 
world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"
OK
redis> GET greeting-again
"hello, dumping world!"
redis> RESTORE fake-message 0 "hello moto moto blah blah" ; 使用错
误的值进行反序列化
(error) ERR DUMP payload version or checksum are wrong

今天的文章Redis命令参考手册 – Key分享到此就结束了，感谢您的阅读。