Redis命令参考手册——KEY（键）

1、DEL

格式：DEL key [key …]
删除给定的一个或多个key。 不存在的key会被忽略。
可用版本

>=1.0.0

时间复杂度：
0(N)，N为被删除的key的数量 删除单个字符串类型的key，时间复杂度为0(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?ll0 匹配 hello，hallo和hxllo等。 KEYS hllo 匹配hllo和heeeeello等。 KEYS h[ae]llo 匹配hello和hallo，但不匹配hillo。 特殊符号用\隔开 警告：KEYS的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用Redis的集合结构（set）来代替。
可用版本

>=1.0.0

时间复杂度：
0(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

时间复杂度：
0(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

时间复杂度：
0(1)
返回值：
当key不存在时，返回-2. 当key存在但没有设置剩余生存时间，返回-1。 否则，以秒为单位，返回key的剩余生存时间。 注：在Redis2.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

时间复杂度：
0(1)
返回值：
当key不存在时，返回-2. 当key存在但没有设置剩余生存时间，返回-1。 否则，以秒为单位，返回key的剩余生存时间。 注：在Redis2.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

时间复杂度：
0(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

时间复杂度：
0(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

时间复杂度：
0(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
OK  #这里相当于value换了一个新的地址引用
redis> GET pc
(nil)
redis:1> GET personal_computer # 原来的值 dell 被覆盖了
"lenovo"

9、RENAMENX

格式：renamex key newkey
当且仅当newkey不存在时，将key改名为newkey。 当key不存在时，返回一个错误。
可用版本

>=1.0.0

时间复杂度：
0(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

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

>=1.0.0

时间复杂度：
0(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: http://…
EXPIRE pagewviews.user: 60
EXEC
如果用户停止阅览超过 60 秒，那么它的导航会话就会被清空，当用户重新开始阅览的 时候，系统又会重新记录导航会话，继续进行物品推荐。

12、PEXPIRE

格式：pexpire key milliseconds
这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
可用版本

>=2.6.0

时间复杂度：
0(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 时间戳(unixtimestamp)。
可用版本

>=1.2.0

时间复杂度：
0(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

时间复杂度：
0(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

时间复杂度：
0(1)
返回值：
如果生存时间设置成功，返回1。 当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 中经过排序的元素。 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
一般用法
最简单的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"

修饰符可以组合使用。以下例子返回降序(从大到小)的前 5 个对象。

redis> SORT rank LIMIT 0 5 DESC
1) "78"
2) "67"
3) "56"
4) "55"
5) "50"

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

id	name	level
1	admin	999
2	huangz	10
59230	jack	3
222	hacker	9999

id 数据保存在 key 名为 user_id 的列表中。 name 数据保存在 key 名为username{id} 的列表中 level 数据保存在userlevel{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"

只获取对象而不排序
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"

保存排序结果
默认情况下， 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 命令。
在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 操作和上面介绍的其他数据结构(列表、集合、有序集合)没有什么不同。
可用版本：

>=1.0.0

时间复杂度：
O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。 如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
返回值：
没有使用 STORE 参数，返回列表形式的排序结果。 使用 STORE 参数，返回排序结果的元素数量。

17、OBJECT

格式：object subcommand [arguments [arguments]]
OBJECT 命令允许从内部察看给定 key 的 Redis 对象。 它通常用在除错(debugging)或者了解为了节省空间而对 key 使用特殊编码的情况。 当将 Redis 用作缓存程序时，你也可以通过 OBJECT 命令中的信息，决定 key 的驱逐策略(eviction policies)。
OBJECT命令有多个子命令：
1.OBJECT REFCOUNT 返回给定 key 引用所储存的值的次数。此命令主要用于除错。 2.OBJECT ENCODING 返回给定 key 锁储存的值所使用的内部表示(representation)。 3.OBJECT IDLETIME 返回给定 key 自储存以来的空转时间(idle， 没有被读取也没有被写入)，以秒为单位。
对象可以以多种方式编码：
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)。
可用版本：

>=2.2.3

时间复杂度：
0(1)
返回值：
REFCOUNT 和IDLETIME 返回数字。 ENCODING 返回相应的编码类型。
示例代码：

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 [phone] # 大的数字也被编码为字符串
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