Redis 常用数据结构及其控制命令整合

Posted 2020-10-06 lyh225

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Redis 常用数据结构及其控制命令整合相关的知识，希望对你有一定的参考价值。

Redis 键值支持5种基本结构，分别是字符串，列表，哈希，集合，有序集合。每一种数据结构都有对应的取值和设值命令，辅助命令，除此之外，还有一些全局命令，用来管理Redis存储的所有键。

全局命令

查看所有键

keys *

127.0.0.1:6379> keys *
1) "name"
2) "fuck"
3) "mlist"
4) "dict:test"
5) "fuck1"
6) "hello"
7) "mset"
8) "fuck2"

>> keys 会遍历所有键，当Redis存储大量键时，容易阻塞Redis的单线程运行，慎用。　　

查看键总数

dbsize

127.0.0.1:6379> dbsize
(integer) 8

>> dbsize在计算键总数的事件复杂度是O(1), dbsize不会像keys命令会去遍历所有键，而是直接获取键总数变量。

查看键是否存在

exists key

　　如果键存在则返回1，不存在返回0

127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> get name
"lyh"
127.0.0.1:6379> exists sdf
(integer) 0

删除键

del key [key ...]

>> del 可以删除任意数据结构的键，可以同时将多个以空格分隔的键同时删除

　 >> 操作成功返回1，否则返回0

127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> get name
"lyh"
127.0.0.1:6379> del name
(integer) 1
127.0.0.1:6379> exists name
(integer) 0

键过期

expire key seconds

127.0.0.1:6379> set name lyh
OK
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> expire name 10
(integer) 1 # 设置成功，返回1

查看键过期时间

ttl key

　　>> ttl 命令有三种返回值

　　>> 大于等于0的整数表示键剩余的过期时间

　　>> -1时表示键没有设置过期时间

　　>>-2时表示键不存在

127.0.0.1:6379> ttl name
(integer) 2 #
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) 0
127.0.0.1:6379> ttl name
(integer) -2

查看键的数据

type key

127.0.0.1:6379> set is:str str
OK
127.0.0.1:6379> rpush is:list 2 a dfdf fdf
(integer) 4
127.0.0.1:6379> sadd is:set 1 1 3 3
(integer) 2
127.0.0.1:6379> hmset is:hash key1 1 key2 2
OK
127.0.0.1:6379> type is:str
string
127.0.0.1:6379> type is:set
set
127.0.0.1:6379> type is:hash
hash

如果键不存在，则返回none

字符串

Redis的键都是字符串类型，只有键对应的值可以是多种数据结构的。另外，字符串的值除了可以是字符串(简单的字符串，复杂的字符串，如JSON，XML)，数字，

　甚至是二进制(图片，音频，视频)，但是值最大不能超过512M。

常用命令

　　设置值

　　set key value [ex seconds] [px milliseconds] [nx|xx]

　　>> ex seconds 为键设置秒级过期时间

　　>> px milliseconds 为键设置毫秒级过期时间

　　>> nx 键不存在才可以设置成功，用于添加

　　>> xx 键存在才可以设置成功，用于更新

　 另外，Redis还提供了setex和setnx，作用和ex，nx选项是一样的。

获取值

　　get key

　　>> 如果要获取的键不存在，则返回nil

批量设置值

mset key value [ key value ...]

批量获取值

mget key [key ...]

计数

incr key

　　>> incr命令用于对值做自增操作，返回结果有三种情况

>> 值不是整数，返回错误

>> 值是整数，返回自增后的结果

>> 键不存在，按照值为0自增，返回结果为1

对一个不在的键执行incr：

127.0.0.1:6379> exists not:exists
(integer) 0
127.0.0.1:6379> incr not:exists
(integer) 1

如果值不是整数，返回错误

127.0.0.1:6379> set notint notint
OK
127.0.0.1:6379> incr notint
(error) ERR value is not an integer or out of range

其他不常用命令

追加值到已有值后边

append key value

获取字符串长度

strlen key

设置并返回原值

getset key value

设置指定位置的字符

setrange key offset value

获取部分字符串

getrange key start end

哈希也可以叫做字典，关联数组。在Redis中，哈希类型是指键值本身又是一个键值对结构。

常用命令

设置值

　　hset key field value

　　>>成功返回1，失败返回0

　　>>Redis 同时提供了hsetnx，当要设置的哈希不在时，才可以设置

获取值

　　hget key field

　　>>键不存在返回nil

删除键

　　hdel key field [field ...]

　　>>hdel可以删除一个或多个field，返回结果为成功删除field的个数

计算哈希内部field个数

　　hlen key

批量设置或获取

　　hmget key field [field ...]

　　hmset key field value [field value...]

判读是否存在指定field

　　hexists key field

获取所有field

　　hkeys key

获取所有value

　　hvals key

获取所有field-value

　　hgetall key

递增哈希的field

hincrby key field

hincrbyfloat key field

>>hincrby 和 hincrbyfloat,就像incrby和incrbyfloat命令一样，但是他们的作用域是field

计算value的字符串长度(需要Redis3.2以上)

　　hstrlen key field

列表列表中的元素是有序的，可通过索引下标获取某个元素或者某个范围内的元素列表；列表中的元素可以是重复的。

列表的四种操作

+----------------------------------------------------+

| 操作类型 | 操作 |

| 添加 | rpush lpush linsert |

| 查 | lrange lindex llen |

| 删除 | lpop rpop ltrim lrem |

| 修改 | lset |

| 阻塞操作 | blpop brpop |

常用命令

　　从右边添加元素至列表

　　rpush key value [value ...]

127.0.0.1:6379> rpush mlist 1 a b a fdfd aa
(integer) 13
127.0.0.1:6379> lrange 0 -1
(error) ERR wrong number of arguments for ‘lrange‘ command
127.0.0.1:6379> lrange mlist 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
7) "g"
8) "1"
9) "a"
10) "b"
11) "a"
12) "fdfd"
13) "aa"

　　从左边添加元素至列表

　　lpush key value [value ...]

　　　　>> 使用方法和rpush相同，只不过从左侧插入

　　向某个元素前或者后插入元素

　　linsert key before|after pivot value

　　>> linsert 命令会从列表中找到等于pivot的元素，在其前或者后插入一个新的元素value，返回值为当前列表长度

127.0.0.1:6379> lrange mlist 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
7) "g"
8) "1"
9) "a"
10) "b"
11) "a"
12) "fdfd"
13) "aa"
127.0.0.1:6379> linsert mlist before a z
(integer) 14

获取指定范围的列表元素

lrange key start end

>> 索引下标从左到右是0到N-1，从右到左是-1到-N，更重要的是，lrange中的end选项包含了自身，这和其他编程语言不包含end很不一样

获取列表指定索引下标的元素

lindex key index

获取列表长度

llen

删除列表元素

lrem key count value

>> lrem会从列表中找到等于value的元素进行删除，根据count的不同分为三种情况

>>count > 0;从左到右，删除最多count个元素

>>count < 0;从右到左，删除count绝对值个元素

>>count = 0;删除所有元素

按照索引范围剪裁列表

ltrim key start end

127.0.0.1:6379> lrange mlist 0 -1
1) "z"
2) "a"
3) "b"
4) "c"
5) "d"
6) "e"
7) "f"
8) "g"
9) "1"
10) "a"
11) "b"
12) "a"
13) "fdfd"
14) "aa"
127.0.0.1:6379> ltrim mlist 1 4
OK
127.0.0.1:6379> lrange mlist 0 -1
1) "a"
2) "b"
3) "c"
4) "d"

修改指定索引下标的元素

lset key index newValue

阻塞操作

阻塞式弹出：blpop key [key ...] timeout; brpop key [key ...] timeout

>> blpop和brpop是lpop和rpop的阻塞版本，它们除了弹出方向不同，使用方法一样。

>> key [key ....] 多个列表的键

>>timeout 阻塞时间，如果timeout=0，客户端会一直等待下去。

集合(set), 可用来保存多个字符串元素。集合不允许有重复元素，并且集合中的元素是无序的，不能通过索引获取元素。

常用命令

集合内操作

　　添加元素

　　sadd key element [element ...]

127.0.0.1:6379> exists firstset
(integer) 0
127.0.0.1:6379> sadd firstset my name is lyh
(integer) 4

获取所有集合元素

smembers key

127.0.0.1:6379> smembers firstset
1) "name"
2) "is"
3) "lyh"
4) "my"

当集合元素过多时，使用smembers存在阻塞Redis的可能。

删除元素

srem key element [element ...]

127.0.0.1:6379> srem firstset my
(integer) 1

判断元素是否在集合中

sismember key element

如果元素在集合中，返回1，否则返回0

127.0.0.1:6379> sismember firstset my
(integer) 0
127.0.0.1:6379> sismember firstset lyh
(integer) 1

计算元素个数

scard key

127.0.0.1:6379> scard firstset
(integer) 3

随机从集合返回指定个数元素

srandmember key [count]

[count] 为可选参数，默认为1，该命令不会改变集合元素

127.0.0.1:6379> srandmember firstset
"lyh"
127.0.0.1:6379> smembers firstset
1) "name"
2) "is"
3) "lyh"
127.0.0.1:6379> srandmember firstset 2
1) "name"
2) "lyh"
127.0.0.1:6379> smembers firstset
1) "name"
2) "is"
3) "lyh"

从集合中随机弹出元素

spop key

该命令会实际从集合中去除弹出的元素

127.0.0.1:6379> smembers firstset
1) "name"
2) "is"
3) "lyh"
127.0.0.1:6379> spop firstset
"name"
127.0.0.1:6379> smembers firstset
1) "is"
2) "lyh"

集合间操作

提前设置两个集合：

127.0.0.1:6379> sadd set:1 java python javascript
(integer) 3
127.0.0.1:6379> sadd set:2 python mysql redis javascript
(integer) 4

　　求集合交集

　　sinter key [key ...

127.0.0.1:6379> sinter set:1 set:2
1) "javascript"
2) "python"

　　求集合的并集

　　sunion key [key ...]

127.0.0.1:6379> sunion set:1 set:2
1) "python"
2) "java"
3) "javascript"
4) "redis"
5) "mysql"

求集合的差集

sdiff key [key ...]

127.0.0.1:6379> sdiff set:1 set:2
1) "java"
127.0.0.1:6379> sdiff set:2 set:1
1) "mysql"
2) "redis"

将交集，并集，差集的结果保存

　　sinterstore target key [key ...]

sunionstore target key [key ...]

　　sdiffstore target key [key ...]

127.0.0.1:6379> sdiffstore set:1:2:diff set:1 set:2
(integer) 1
127.0.0.1:6379> smembers set:1:2:diff
1) "java"

有序集合，它保留了集合不能有重复成员的特性，但有序集合中的元素可以排序。比较特别的是，有序集合并不像列表那样采用索引下标作为排序依据，而是给每个元素设置一个分数作为排序的依据。不同元素的分数可以相同。有序集合可以应用于排行榜系统，社交等。

常用命令

集合内

　　添加成员

　　zadd key score member [score member ...]

　　score必须是数字，否则会报错

127.0.0.1:6379> zadd zset:1 99 math 100 english 98 art
(integer) 3
127.0.0.1:6379> zadd zset:1 name lyh
(error) ERR value is not a valid float

当首次添加member时，会返回成功添加的个数，而如果member已经存在，此时使用zadd命令，则会更新 member，返回值为0，表示没有添加新member

127.0.0.1:6379> zadd zset:1 999.9999 lyh
(integer) 1
127.0.0.1:6379> zadd zset:1 100 lyh
(integer) 0
127.0.0.1:6379> zadd zset:1 100 lyh100
(integer) 1
127.0.0.1:6379> zscore zset:1 lyh
"100"

在redis 3.2版本以后，zadd命令添加了nx, xx, ch, incr 四个选项

nx: member 必须不存在，才可以设置成功，用于添加。

127.0.0.1:6379> zadd zset:1 nx 200 lyh100
(integer) 0
127.0.0.1:6379> zscore zset:1 lyh100
"100"
127.0.0.1:6379> zadd zset:1 nx 200 lyh200
(integer) 1
127.0.0.1:6379> zscore zset:1 lyh200
"200"

xx: member必须存在，才可以设置成功，用于更新。

127.0.0.1:6379> zadd zset:1 xx 300 lyh300
(integer) 0
127.0.0.1:6379> zscore zset:1 lyh300
(nil)
127.0.0.1:6379> zadd zset:1 nx 200 lyh300
(integer) 1
127.0.0.1:6379> zscore zset:1 lyh300
"200"
127.0.0.1:6379> zadd zset:1 xx 300 lyh300
(integer) 0
127.0.0.1:6379> zscore zset:1 lyh300
"300"

ch: 返回此次操作后，有序集合元素和分数发生变化的个数

incr: 对score做增加，相当于后面介绍的zincrby

127.0.0.1:6379> zadd zset:1 incr 1 lyh300
"301"
127.0.0.1:6379> zscore zset:1 lyh300
"301"
127.0.0.1:6379> zadd zset:1 ch 300 lyh300
(integer) 1
127.0.0.1:6379> zscore zset:1 lyh300
"300"

计算成员个数

zcard key

127.0.0.1:6379> zscore zset:1 lyh300
"300"
127.0.0.1:6379> zcard zset:1
(integer) 7

计算某个成员的分数

zscore key member

127.0.0.1:6379> zscore zset:1 lyh300
"300"

计算成员的排名（排名从0开始计算）

zrank key member

zrevrank key member

zrank 是分数从低到高排名，zrevrank反之。

127.0.0.1:6379> zrank zset:1 lyh300
(integer) 6
127.0.0.1:6379> zrevrank zset:1 lyh300
(integer) 0

删除成员

zrem key member [member ...]

返回结果为成功删除的个数

127.0.0.1:6379> zrem zset:1 lyh300
(integer) 1
127.0.0.1:6379> zrem zset:1 lyh300
(integer) 0

增加成员的分数

zincrby key increment member

127.0.0.1:6379> zincrby zset:1 88 lyh
"188"

返回指定排名范围的成员

zrange key start end [withscores]

zrevrange key start end [withscores]

排名按照分值高低进行，zrange是从低到高返回，zrevrange反之。加上withscores选项，会同时返回成员的分数。

127.0.0.1:6379> zrange zset:1 0 100
1) "art"
2) "math"
3) "english"
4) "lyh100"
5) "lyh"
6) "lyh200"
127.0.0.1:6379> zrange zset:1 0 100 withscores
1) "art"
2) "98"
3) "math"
4) "99"
5) "english"
6) "100"
7) "lyh100"
8) "100"
9) "lyh"
10) "188"
11) "lyh200"
12) "200"
127.0.0.1:6379> zrevrange zset:1 0 100 withscores
1) "lyh200"
2) "200"
3) "lyh"
4) "188"
5) "lyh100"
6) "100"
7) "english"
8) "100"
9) "math"
10) "99"
11) "art"
12) "98"

　　返回指定分数范围的成员

　　zrangebyscore key min max [withscores] [limit offset count]

　　zrevrangebyscore key min max [withscores] [limit offset count]

　　zrangebyscore 按照分数从低到高返回，zrevrangebyscore反之。withscores选项会同时返回每个成员的个数。[limit offset count]选项可以限制输出的起始位置和个数。

127.0.0.1:6379> zrangebyscore zset:1 0 100 withscores
1) "art"
2) "98"
3) "math"
4) "99"
5) "english"
6) "100"
7) "lyh100"
8) "100"
127.0.0.1:6379> zrangebyscore zset:1 0 100 withscores limit 1 1
1) "math"
2) "99"
127.0.0.1:6379> zrangebyscore zset:1 0 100 withscores limit 0 1
1) "art"
2) "98"
127.0.0.1:6379> zrangebyscore zset:1 0 100 withscores limit 0 2
1) "art"
2) "98"
3) "math"
4) "99"

min和max还支持开区间(小括号)和闭区间(中括号)，-inf 和 +inf分别代表无限小和无限大。

127.0.0.1:6379> zrangebyscore zset:1 (88 +inf withscores
1) "art"
2) "98"
3) "math"
4) "99"
5) "english"
6) "100"
7) "lyh100"
8) "100"
9) "lyh"
10) "188"
11) "lyh200"
12) "200"
127.0.0.1:6379> zrangebyscore zset:1 [88 +inf withscores
(error) ERR min or max is not a float

返回指定分数范围成员个数

zcount key min max

127.0.0.1:6379> zcount zset:1 100 200
(integer) 4

删除指定排名内的升序元素

zremrangebyrank key start end

127.0.0.1:6379> zrangebyscore zset:1 -inf +inf
1) "art"
2) "math"
3) "english"
4) "lyh100"
5) "lyh"
6) "lyh200"
127.0.0.1:6379> zremrangebyrank zset:1 0 1
(integer) 2
127.0.0.1:6379> zrangebyscore zset:1 -inf +inf
1) "english"
2) "lyh100"
3) "lyh"
4) "lyh200"

删除指定分数范围的成员

zremrangebyscores key min max

127.0.0.1:6379> zrangebyscore zset:1 -inf +inf withscores
1) "english"
2) "100"
3) "lyh100"
4) "100"
5) "lyh"
6) "188"
7) "lyh200"
8) "200"
127.0.0.1:6379> zremrangebyscore zset:1 100 199
(integer) 3
127.0.0.1:6379> zrangebyscore zset:1 -inf +inf withscores
1) "lyh200"
2) "200"

集合间的操作

首先准备两个有序集合

127.0.0.1:6379> zadd zset:subject:1 8 english 12 chinese 11 c 20 python 30 redis
(integer) 5
127.0.0.1:6379> zadd zset:subject:2 88 english 120 chinese 119 c 200 python 300 redis
(integer) 5

127.0.0.1:6379> zrangebyscore zset:subject:1 -inf +inf withscores
1) "english"
2) "8"
3) "c"
4) "11"
5) "chinese"
6) "12"
7) "python"
8) "20"
9) "redis"
10) "30"
127.0.0.1:6379> zrangebyscore zset:subject:2 -inf +inf withscores
1) "english"
2) "88"
3) "c"
4) "119"
5) "chinese"
6) "120"
7) "python"
8) "200"
9) "redis"
10) "300"

　　交集

　　zinterstore destination numkeys key [key ...] [weights weight [weight ...]] [aggregate sum|min|max]

　　destination: 交集计算结果保存到这个键

　　numkes: 需要做交集计算键的个数

　　key [key ...] : 需要做交集计算的键

　　weights weight [weight ...] : 每个键的权重，在做交集运算的时候，每个键中的每个member会将自己分数乘以这个权重，每个键的权重默认是1。

　　aggergate sum|min|max : 计算成员交集后，分值可以按照sum(和)，min(最小值)，max(最大值)做汇总，默认值是sum。

127.0.0.1:6379> ZINTERSTORE result:1 2 zset:subject:1 zset:subject:2
(integer) 5
127.0.0.1:6379> zrange result:1 0 -1 withscores
1) "english"
2) "96"
3) "c"
4) "130"
5) "chinese"
6) "132"
7) "python"
8) "220"
9) "redis"
10) "330"

将第二个有序集合权重变为2，并且聚合效果采用max

127.0.0.1:6379> ZINTERSTORE result:2 2 zset:subject:1 zset:subject:2 weights 1 2 aggregate max
(integer) 5
127.0.0.1:6379> zrange result:2 0 -1 withscores
1) "english"
2) "176"
3) "c"
4) "238"
5) "chinese"
6) "240"
7) "python"
8) "400"
9) "redis"
10) "600"

并集

zunionstore destination numkeys key [key ...] [weights weight [weight ...]] [aggregate sum|min|max]

该命令参数和交集效果是一样的。

键管理

单个键管理

　　键重命名

　　rename key newkey

　　注意：如果newkey已存在，newkey原来的值会被覆盖

127.0.0.1:6379> exists rename:test
(integer) 0
127.0.0.1:6379> set rename:test test
OK
127.0.0.1:6379> get rename:test
"test"
127.0.0.1:6379> rename rename:test rename:ok
OK
127.0.0.1:6379> get rename:test
(nil)
127.0.0.1:6379> get rename:ok
"test"

newkey不存在时，允许重命名键

renamenx key newkey

返回结果为0时代表没有完成重命名。

127.0.0.1:6379> set rename:ok ok
OK
127.0.0.1:6379> set rename:notok notok
OK
127.0.0.1:6379> renamenx rename:notok rename:ok
(integer) 0

特别注意：如果重命名涉及到的键值比较大，而rename机制会执行del命令删除旧键，导致阻塞Redis

随机返回一个键

randomkey

127.0.0.1:6379> randomkey
"result:2"
127.0.0.1:6379> randomkey
"not:exists"
127.0.0.1:6379> randomkey
"fuck2"

键过期

设置键过期

expire key seconds #键在seconds秒后过期删除

expireat key timestamp #键在秒级时间戳后过期如 >expireat hello 1469980800

pexpire key millseconds #Redis 2.6之后，键在millseconds毫秒后过期

pexpireat key millseconds-timestamp #Redis之后，键在毫秒级时间戳timestamp后过期

有两点需要注意：

1 如果expire key的键不存在，返回结果为0

2 如果过期时间为负值，键会立即被删除，效果如同del命令一样

查看键过期剩余时间
ttl #精度为秒

pttl #精度为毫秒

ttl和pttl都可以查看键过期时间，返回值有以下三种情况

1 返回大于等于0的整数，表示键剩余的过期时间(ttl是秒，pttl是毫秒)

2 返回-1，表示键没有设置过期时间

3 返回-2，表示键不存在

清除键过期时间

persist key

另外，对于字符串类型键，执行set命令会去掉过期时间。

127.0.0.1:6379> setex mykey 60 ok
OK
127.0.0.1:6379> get mykey
"ok"
127.0.0.1:6379> ttl mykey
(integer) 50
127.0.0.1:6379> ttl mykey
(integer) 48
127.0.0.1:6379> set mykey notok
OK
127.0.0.1:6379> ttl mykey
(integer) -1

Redis不支持二级数据结构(哈希，列表等)内部元素的过期功能，例如不能对列表类型的一个元素做过期时间设置。

技巧，setex 可作为set + expire组合的替代，能以原子执行，并且减少一次网络通信的事件。

SETEX key seconds value
summary: Set the value and expiration of a key
since: 2.0.0
group: string

迁移键

迁移键功能实现将部分数据从一个Redis迁移到另一个Redis，Redis提供了move，dump+restore，migrate三组迁移键的方法。

1 move key db

Redis内部允许有多个数据库，彼此在数据上是相互隔离的，move key db就是把指定的键从源数据库移动到目标数据库中。仅支持同一个Redis实例内不同数据库的键进行迁移

2 dump+restore

该方式分为两步：

dump key # 源Redis 上，dump命令会将键值序列化，格式采用的是RDB格式

restore key ttl value #在目标Redis上，restore命令会将上面序列化的值进行复原，其中ttl参数代表过期时间，如果ttl=0代表没有过期时间

127.0.0.1:6379> get mykey
"notok"
127.0.0.1:6379> dump mykey
"\x00\x05notok\x06\x00\"\xc5dC\xc7m\xb5`"
127.0.0.1:6379> select 1 # 切换到Redis数据库1
OK
127.0.0.1:6379[1]> restore key 0 "\x00\x05notok\x06\x00\"\xc5dC\xc7m\xb5`"
OK
127.0.0.1:6379[1]> get key
"notok"

3 migrate

migrate host port key|"" destination-db timeout [copy] [replace] [keys key [key ...]]

host: 目标Redis的IP地址

port: 目标Redis的端口

key|""：在Redis 3.0.6版本之前，migrate只允许迁移一个键，key就代表了要迁移的键。在Redis3.0.6版本之后，允许迁移多个键，这里就为空字符串""

destination-db:目标Redis的数据库索引，例如要迁移到0号数据库，这里就写0

timeout：迁移的超时时间

[copy]：表示迁移后并不删除源键

[replace]：如果添加此选项，migrate不管目标Redis是否存在该键都会正常迁移进行数据覆盖

[keys key [key ...] ]:迁移多个键，例如要迁移key1，key2，key3，此处应填写为"keys key1 key2 key3"

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> migrate 127.0.0.1 8000 "" 00 5000 keys k1 k2 k3
OK
127.0.0.1:6379>

$ redis-cli -p 8000
127.0.0.1:8000> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:8000>

注意，migrate是原子操作的，不需要在多个Redis实例上开启客户端，只需要在源Redis上执行migrate命令即可。

遍历键

　　Redis提供了两个命令遍历所有的键，分别是keys和scan

　　全量遍历键

　　keys patterns

　　keys支持pattern匹配

127.0.0.1:8000> keys k*
1) "k1"
2) "k2"
3) "k3"

pattern使用glob风格的通配符：

* 代表匹配任意字符

? 代表匹配一个字符

[] 代表匹配部分字符，例如[1,3]代表匹配1,3，

\x 用来转义，如转义星号\* ,转义问号\?

注意，key命令容易造成Redis阻塞，尤其在Redis包含了大量的键时。

渐进式遍历

scan cursor [match pattern] [count number]

cursor:cursor是一个游标，第一次遍历从0开始，每次scan遍历完都会返回当前游标的值，直到游标的值为0，表示遍历结束。

match pattern 是可选参数，作模式匹配，使用glob风格的通配符。

count number是可选参数，表明每次要遍历的键的个数，默认值是10，此参数可以适当增大。

127.0.0.1:8000> keys *
1) "k1"
2) "k2"
3) "k3"
127.0.0.1:8000> mset n1 v1 n2 v2 n3 v3
OK
127.0.0.1:8000> keys *
1) "n3"
2) "k1"
3) "n2"
4) "k3"
5) "n1"
6) "k2"
127.0.0.1:8000> scan 0
1) "0"
2) 1) "n2"
2) "k2"
3) "n3"
4) "k1"
5) "n1"
6) "k3"
127.0.0.1:8000> scan 0 match n*
1) "0"
2) 1) "n2"
2) "n3"
3) "n1"
127.0.0.1:8000> scan 0 match n* count 1
1) "6"
2) 1) "n2"