当前命令集未注明统一参考版本 >= 1.x
格式：DEL key [key …]
时间复杂度： 删N为O ( N ) ，删单个key，为O ( 1 )；
返回值： 受影响的数量
删除单个 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查找所有符合给定模式 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)来代替。
时间复杂度： O ( N ) N为key的size
返回值： 匹配到的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" 从当前数据库中随机返回(不删除)一个 key
时间复杂度： 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)格式：ttl key
时间复杂度： 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格式：pttl key
参考版本：>= 2.6X
时间复杂度： 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格式：exists key
时间复杂度： 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将当前数据库的 key 移动到给定的数据库 db 当中
如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者key 不存在于当前数据库，那么 MOVE 没有任何效果
因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)
时间复杂度： 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"将 key 改名为 newkey
当 key 和 newkey 相同，或者 key 不存在时，返回一个错误
当 newkey 已经存在时， RENAME 命令将覆盖旧值
时间复杂度： 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 #这里相当于value换了一个新的地址引用 OK redis> GET pc (nil) redis:1> GET personal_computer # 原来的值 dell 被覆盖了 "lenovo"当且仅当 newkey 不存在时，将 key 改名为 newkey
当 key 不存在时，返回一个错误
时间复杂度： 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"返回 key 所储存的值的类型
时间复杂度： 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为给定 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 命令，新指定的生存时间会取代旧的生存时间。
过期时间的精确度 在 Redis 2.4 版本中，过期时间的延迟在 1 秒钟之内 —— 也即是，就算 key 已经过期，但它还是可能在过期后一秒钟之内被访问到，而在新的 Redis 2.6 版本中，延迟被降低到 1 毫秒之内。
Redis 2.1.3 之前的不同之处 在 Redis 2.1.3 之前的版本中，修改一个带有生存时间的 key 会导致整个 key 被删除，这一行为是受当时复制(replication)层的限制而作出的，现在这一限制已经被修复。
时间复杂度： 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 秒，那么它的导航会话就会被清空，当用户重新开始阅览的时候，系统又会重新记录导航会话，继续进行物品推荐。
这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位
参考版本： >= 2.6X时间复杂度： 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) 1499EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间
不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)
参考版本： >= 1.2X时间复杂度： 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这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位
参考版本： >= 2.6X时间复杂度： 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移除给定 key 的生存时间，将这个 key 从『可挥发』的(带生存时间 key )转换成『持久化』的(一个不带生存时间、永不过期的 key )。
参考版本： >= 2.2X时间复杂度： 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格式：sort key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern …]] [ASC | DESC] [ALPHA] [STORE destination]
返回或保存给定列表、集合、有序集合 key 中经过排序的元素
排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较
一般 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"修饰符可以组合使用。以下例子返回降序(从大到小)的前 5 个对象
redis> SORT rank LIMIT 0 5 DESC 1) "78" 2) "67" 3) "56" 4) "55" 5) "50"使用外部 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"只获取对象而不排序
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 操作和上面介绍的其他数据结构(列表、集合、有序集合)没有什么不同。
时间复杂度：O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。
如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
返回值：没有使用 STORE 参数，返回列表形式的排序结果。
使用 STORE 参数，返回排序结果的元素数量。
1. OBJECT 命令有多个子命令：
OBJECT REFCOUNT <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。OBJECT ENCODING <key> 返回给定 key 锁储存的值所使用的内部表示(representation)OBJECT IDLETIME <key> 返回给定 key 自储存以来的空转时间(idle， 没有被读取也没有被写入)，以秒为单位。 2. 对象可以以多种方式编码：
字符串可以被编码为 raw (一般字符串)或 int (用字符串表示 64 位数字是为了节约空间)。列表可以被编码为 ziplist 或 linkedlist 。ziplist 是为节约大小较小的列表空间而作的特殊表示。集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。有序集合可以被编码为 ziplist 或者 skiplist 格式。ziplist 用于表示小的有序集合，而 skiplist 则用于表示任何大小的有序集合。假如你做了什么让 Redis 没办法再使用节省空间的编码时(比如将一个只有 1 个元素的集合扩展为一个有 100 万个元素的集合)，特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。
参考版本： >= 2.2X
时间复杂度： O ( 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 15820123123 # 大的数字也被编码为字符串 OK redis> OBJECT ENCODING phone "raw" redis> SET age 20 # 短数字被编码为 int OK redis> OBJECT ENCODING age "int"格式：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. <font color="grey">key 可能存在于两个实例</font> 2. <font color="grey">key 可能只存在于当前实例</font> - 唯一不可能发生的情况就是丢失 key ，因此，如果一个客户端执行 MIGRATE 命令，并且不幸遇上 IOERR 错误，那么这个客户端唯一要做的就是检查自己数据库上的 key 是否已经被正确地删除。
- 如果有其他错误发生，那么 MIGRATE 保证 key 只会出现在当前实例中。（当然，目标实例的给定数据库上可能有和 key 同名的键，不过这和 MIGRATE 命令没有关系）。
参考版本： >= 2.6X
时间复杂度：
这个命令在源实例上实际执行 DUMP 命令和 DEL 命令，在目标实例执行 RESTORE 命令，查看以上命令的文档可以看到详细的复杂度说明。
key 数据在两个实例之间传输的复杂度为 O(N)
返回值： 迁移成功时返回 OK ，否则返回相应的错误 $ ./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"格式：dump key
序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为Redis 键
序列化生成的值有以下几个特点：
它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。
值的编码格式和 RDB 文件保持一致。
RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么Redis 会拒绝对这个值进行反序列化操作。
序列化的值不包括任何生存时间信息。
参考版本： >= 2.6X时间复杂度：查找给定键的复杂度为 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)未完待续。。。。
