redis-key相关命令

　　本篇主要介绍和redis的key进行操作的相关命令。

命令	描述	复杂度	返回值
DEL key [key ...]	删除给定的一个或多个 key 。不存在的 key 会被忽略。删除单个列表、集合、有序集合或哈希表类型的 key ,时间复杂度为O(M)， M 为以上数据结构内的元素数量。	O(N),N为被删除的key的数量。删除单个字符串类型的 key ，时间复杂度为O(1)。	被删除 key 的数量。
DUMP key	序列化给定key ，并返回被序列化的值，使用 RESTORE命令可以将这个值反序列化为Redis键。序列化生成的值有以下几个特点： l  它带有 64 位的校验和，用于检测错误， RESTORE 在进行反序列化之前会先检查校验和。 l  值的编码格式和RDB文件保持一致。 l  RDB版本会被编码在序列化值当中，如果因为 Redis的版本不同造成RDB格式不兼容，那么 Redis会拒绝对这个值进行反序列化操作。 l  序列化的值不包括任何生存时间信息。	查找给定键的复杂度为 O(1)，对键进行序列化的复杂度为O(N*M)，其中 N 是构成 key的 Redis 对象的数量，而M则是这些对象的平均大小。如果序列化的对象是比较小的字符串，那么复杂度为 O(1)	如果key不存在，那么返回nil。否则，返回序列化之后的值。
EXISTS key	检查给定 key 是否存在。	O(1)	存在1 ;否则0 。
EXPIRE key seconds	为给定key设置生存时间，当key过期时,它会被自动删除 使用 PERSIST 命令可以在不删除key的情况下，移除key的生存时间，让key重新成为一个持久的key 。可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。	O(1)	设置成功返回1.当key不存在或者不能为 key设置生存时间时,返回 0 。
EXPIREAT key timestamp	EXPIREAT的作用和EXPIRE类似，都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。	O(1)	设置成功，返回1。key不存在或没办法设置生存时间，返回 0 。
KEYS pattern	查找所有符合给定模式pattern的key。 l  KEYS * 匹配数据库中所有key 。 l  KEYS h?llo 匹配hello、hallo和hxllo等。 l  KEYS h*llo 匹配 hllo和heeeeello等。 l  KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。 l  特殊符号用 \ 隔开	O(N),N为数据库中 key的数量。	符合给定模式的 key列表。
MOVE key db	将当前数据库的 key 移动到给定的数据库db当中。如果源数据库和目标数据库有相同名字的给定 key ，或者key存在于当前数据库，那么 MOVE 没有任何效果。	O(1)	移动成功返回1，失败则返回0。
PERSIST key	移除给定key的生存时间，将这个key从易失的(带生存时间key转换成持久的。	O(1)	当生存时间移除成功时,返回1 .如果 key不存在或key 没有设置生存时间，返回0
PEXPIREAT key timestamp	以毫秒为单位设置key的过期unix时间戳，而不是像EXPIREAT那样，以秒为单位。	O(1)	不存在：2；key存在但没设置生存时间时：-1;否则返回剩余生存时间。
PTTL/TTL key	以毫秒/秒为单位返回key的剩余生存时间	O(1)
RANDOMKEY	从当前数据库中随机返回(不删除)一个 key	O(1)	当数据库不为空时，返回一个 key 。当数据库为空时，返回 nil 。
RENAME key newkey	将key改名为newkey.当key和newkey相同，或者 key不存在时，返回一个错误。当newkey已经存在时，RENAME命令将覆盖旧值。	O(1)	改名成功时提示 OK ，失败时候返回一个错误。
RENAMENX key newkey	当且仅当newkey不存在时，将key改名为newkey 当key不存在时，返回一个错误		成功时:1。如果 newkey已经存在,返回 0 。
TYPE key	返回key所储存的值的类型	O(1)

SORT命令

SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

　　返回或保存给定列表、集合、有序集合key中经过排序的元素。排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。最简单的SORT使用方法是 SORT key和SORT key DESC ：

• SORT key 返回键值从小到大排序的结果。
• SORT key DESC返回键值从大到小排序的结果。

　　假设today_cost列表保存了今日的开销金额， 那么可以用SORT命令对它进行排序：

# 开销金额列表
redis> LPUSH today_cost 30 1.5 10 8
(integer) 4

# 排序
redis> SORT today_cost
1) "1.5"
2) "8"
3) "10"
4) "30"

　　逆序排序

redis 127.0.0.1:6379> SORT today_cost DESC
1) "30"
2) "10"
3) "8"
4) "1.5"

　　因为 SORT 命令默认排序对象为数字， 当需要对字符串进行排序时， 需要显式地在 SORT 命令之后添加 ALPHA 修饰符：

# 网址
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 ALPHA
1) "www.infoq.com"
2) "www.reddit.com"
3) "www.slashdot.com"

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

• offset 指定要跳过的元素数量。
• count 指定跳过offset个指定的元素之后，要返回多少个对象。

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

# 添加测试数据，列表值为 1 指 10
redis 127.0.0.1:6379> RPUSH rank 1 3 5 7 9
(integer) 5
redis 127.0.0.1:6379> RPUSH rank 2 4 6 8 10
(integer) 10
# 返回列表中最小的 5 个值

redis 127.0.0.1:6379> SORT rank LIMIT 0 5
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"

　　可以使用外部 key 的数据作为权重，代替默认的直接对比键值的方式来进行排序。假设现在有用户数据如下：

uid     user_name_{uid}     user_level_{uid}
1     admin     9999
2     jack     10
3     peter     25
4     mary     70

　　将以下代码将数据输入到 Redis 中：

# admin
redis 127.0.0.1:6379> LPUSH uid 1
(integer) 1
redis 127.0.0.1:6379> SET user_name_1 admin
OK
redis 127.0.0.1:6379> SET user_level_1 9999
OK

# jack
redis 127.0.0.1:6379> LPUSH uid 2
(integer) 2
redis 127.0.0.1:6379> SET user_name_2 jack
OK
redis 127.0.0.1:6379> SET user_level_2 10
OK

# peter
redis 127.0.0.1:6379> LPUSH uid 3
(integer) 3
redis 127.0.0.1:6379> SET user_name_3 peter
OK
redis 127.0.0.1:6379> SET user_level_3 25
OK

# mary
redis 127.0.0.1:6379> LPUSH uid 4
(integer) 4
redis 127.0.0.1:6379> SET user_name_4 mary
OK
redis 127.0.0.1:6379> SET user_level_4 70
OK

　　默认情况下， SORT uid 直接按 uid 中的值排序：

redis 127.0.0.1:6379> SORT uid
1) "1"      # admin
2) "2"      # jack
3) "3"      # peter
4) "4"      # mary

　　通过使用 BY 选项，可以让uid按其他键的元素来排序。比如说， 以下代码让 uid 键按照 user_level_{uid} 的大小来排序：

redis 127.0.0.1:6379> SORT uid BY user_level_*
1) "2"      # jack , level = 10
2) "3"      # peter, level = 25
3) "4"      # mary, level = 70
4) "1"      # admin, level = 9999

　　user_level_* 是一个占位符， 它先取出 uid 中的值， 然后再用这个值来查找相应的键。比如在对uid列表进行排序时， 程序就会先取出uid的值 1 、2 、3 、4 ， 然后使用 user_level_1 、user_level_2 、user_level_3 和 user_level_4 的值作为排序 uid 的权重。
　　使用 GET 选项， 可以根据排序的结果来取出相应的键值。比如说， 以下代码先排序 uid ， 再取出键 user_name_{uid} 的值：

redis 127.0.0.1:6379> SORT uid GET user_name_*
1) "admin"
2) "jack"
3) "peter"
4) "mary"

　　通过组合使用 BY 和 GET ， 可以让排序结果以更直观的方式显示出来。比如说， 以下代码先按 user_level_{uid} 来排序 uid 列表， 再取出相应的 user_name_{uid} 的值：

redis 127.0.0.1:6379> SORT uid BY user_level_* GET user_name_*
1) "jack"       # level = 10
2) "peter"      # level = 25
3) "mary"       # level = 70
4) "admin"      # level = 9999

　　现在的排序结果要比只使用 SORT uid BY user_level_* 要直观得多。可以同时使用多个 GET 选项， 获取多个外部键的值。以下代码就按 uid 分别获取 user_level_{uid} 和 user_name_{uid} ：

redis 127.0.0.1:6379> SORT uid GET user_level_* GET user_name_*
1) "9999"       # level
2) "admin"      # name
3) "10"
4) "jack"
5) "25"
6) "peter"
7) "70"
8) "mary"

　　GET 有一个额外的参数规则，那就是 —— 可以用 # 获取被排序键的值。以下代码就将 uid 的值、及其相应的 user_level_* 和 user_name_* 都返回为结果：

redis 127.0.0.1:6379> SORT uid GET # GET user_level_* GET user_name_*
1) "1"          # uid
2) "9999"       # level
3) "admin"      # name
4) "2"
5) "10"
6) "jack"
7) "3"
8) "25"
9) "peter"
10) "4"
11) "70"
12) "mary"

　　通过将一个不存在的键作为参数传给 BY 选项， 可以让 SORT 跳过排序操作， 直接返回结果：

redis 127.0.0.1:6379> SORT uid BY not-exists-key
1) "4"
2) "3"
3) "2"
4) "1"

　　这种用法在单独使用时，没什么实际用处。不过，通过将这种用法和 GET 选项配合， 就可以在不排序的情况下， 获取多个外部键， 相当于执行一个整合的获取操作（类似于 SQL 数据库的 join 关键字）。以下代码演示了，如何在不引起排序的情况下，使用 SORT 、 BY 和 GET 获取多个外部键：

redis 127.0.0.1:6379> SORT uid BY not-exists-key GET # GET user_level_* GET user_name_*
1) "4"      # id
2) "70"     # level
3) "mary"   # name
4) "3"
5) "25"
6) "peter"
7) "2"
8) "10"
9) "jack"
10) "1"
11) "9999"
12) "admin"

　　除了可以将字符串键之外， 哈希表也可以作为 GET 或 BY 选项的参数来使用。比如说，对于前面给出的用户信息表。我们可以不将用户的名字和级别保存在 user_name_{uid} 和 user_level_{uid} 两个字符串键中， 而是用一个带有 name 域和 level 域的哈希表 user_info_{uid} 来保存用户的名字和级别信息：

redis 127.0.0.1:6379> HMSET user_info_1 name admin level 9999
OK
redis 127.0.0.1:6379> HMSET user_info_2 name jack level 10
OK
redis 127.0.0.1:6379> HMSET user_info_3 name peter level 25
OK
redis 127.0.0.1:6379> HMSET user_info_4 name mary level 70
OK

　　之后， BY和GET选项都可以用 key->field 的格式来获取哈希表中的域的值， 其中 key 表示哈希表键， 而 field 则表示哈希表的域：

redis 127.0.0.1:6379> SORT uid BY user_info_*->level
1) "2"
2) "3"
3) "4"
4) "1"

redis 127.0.0.1:6379> SORT uid BY user_info_*->level GET user_info_*->name
1) "jack"
2) "peter"
3) "mary"
4) "admin"

　　默认情况下， SORT 操作只是简单地返回排序结果，并不进行任何保存操作。通过给 STORE 选项指定一个 key 参数，可以将排序结果保存到给定的键上。如果被指定的 key 已存在，那么原有的值将被排序结果覆盖。

# 测试数据
redis 127.0.0.1:6379> RPUSH numbers 1 3 5 7 9
(integer) 5
redis 127.0.0.1:6379> RPUSH numbers 2 4 6 8 10
(integer) 10
redis 127.0.0.1:6379> LRANGE numbers 0 -1
1) "1"
2) "3"
3) "5"
4) "7"
5) "9"
6) "2"
7) "4"
8) "6"
9) "8"
10) "10"
redis 127.0.0.1:6379> SORT numbers STORE sorted-numbers
(integer) 10

# 排序后的结果
redis 127.0.0.1:6379> LRANGE sorted-numbers 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"
10) "10"

　　可以通过将 SORT 命令的执行结果保存，并用 EXPIRE 为结果设置生存时间，以此来产生一个 SORT 操作的结果缓存。这样就可以避免对 SORT 操作的频繁调用：只有当结果集过期时，才需要再调用一次 SORT 操作。另外，为了正确实现这一用法，你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端，同一时间进行 SORT 操作，并保存为结果集)，具体参见 SETNX 命令。时间复杂度：O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。