EXISTS key
可用版本: >= 1.0.0
时间复杂度: O(1)
检查给定 key
是否存在。
返回值
若key 存在,返回1 ,否则返回 0
TYPE key
可用版本: >= 1.0.0
时间复杂度: O(1)
返回key
所储存的值的类型。
返回值
-
none
(key不存在) -
string
(字符串) -
list
(列表) -
set
(集合) -
zset
(有序集) -
hash
(哈希表) -
stream
(流)
代码示例
# 字符串
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
RENAME key newkey
可用版本: >= 1.0.0
时间复杂度: O(1)
将 key
改名为 newkey
。
当 key
和 newkey
相同,或者 key
不存在时,返回一个错误。
当 newkey
已经存在时, RENAME
命令将覆盖旧值。
返回值
改名成功时提示 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
redis> GET pc
(nil)
redis:1> GET personal_computer # 原来的值 dell 被覆盖了
"lenovo"
RENAMENX key newkey
可用版本: >= 1.0.0
时间复杂度: O(1)
当且仅当 newkey
不存在时,将 key
改名为 newkey
。
当 key
不存在时,返回一个错误。
返回值
修改成功时,返回 1
; 如果 newkey
已经存在,返回 0
。
RANDOMKEY
可用版本: >= 1.0.0
时间复杂度: O(1)
从当前数据库中随机返回(不删除)一个 key
。
返回值
当数据库不为空时,返回一个 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)
DBSIZE
可用版本: >= 1.0.0
时间复杂度: O(1)
返回当前数据库的 key 的数量。
返回值
当前数据库的 key 的数量。
代码示例
redis> DBSIZE
(integer) 5
redis> SET new_key "hello_moto" # 增加一个 key 试试
OK
redis> DBSIZE
(integer) 6
KEYS pattern
可用版本: >= 1.0.0
时间复杂度: O(N),
N
为数据库中key
的数量。
查找所有符合给定模式 pattern
的 key
, 比如说:
-
KEYS *
匹配数据库中所有key
。 -
KEYS h?llo
匹配hello
,hallo
和hxllo
等。 -
KEYS h*llo
匹配hllo
和heeeeello
等。 -
KEYS h[ae]llo
匹配hello
和hallo
,但不匹配hillo
。
特殊符号用 \
隔开。
Warning
KEYS 的速度非常快,但在一个大的数据库中使用它仍然可能造成性能问题,如果你需要从一个数据集中查找特定的 key
,你最好还是用 Redis 的集合结构(set)来代替。
返回值
符合给定模式的 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"
SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern …]] [ASC | DESC] [ALPHA] [STORE destination]
可用版本: >= 1.0.0
时间复杂度: O(N+M*log(M)),N
为要排序的列表或集合内的元素数量,M
为要返回的元素数量。如果只是使用 SORT 命令的GET
选项获取数据而没有进行排序,时间复杂度 O(N)。
返回或保存给定列表、集合、有序集合 key
中经过排序的元素。
排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较。
一般 SORT 用法
最简单的 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"
使用 ALPHA 修饰符对字符串进行排序
因为 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
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
表示没有元素被跳过)。
# 添加测试数据,列表值为 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"
可以组合使用多个修饰符。以下例子返回从大到小排序的前 5 个对象。
redis 127.0.0.1:6379> SORT rank LIMIT 0 5 DESC
1) "10"
2) "9"
3) "8"
4) "7"
5) "6"
使用外部 key 进行排序
可以使用外部 key
的数据作为权重,代替默认的直接对比键值的方式来进行排序。
假设现在有用户数据如下:
以下代码将数据输入到 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
BY 选项
默认情况下, 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 选项
使用 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
通过组合使用 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 的参数
除了可以将字符串键之外, 哈希表也可以作为 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 key seconds 为结果设置生存时间,以此来产生一个 SORT 操作的结果缓存。
这样就可以避免对 SORT 操作的频繁调用:只有当结果集过期时,才需要再调用一次 SORT 操作。
另外,为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行 SORT 操作,并保存为结果集),具体参见 SETNX key value 命令。
返回值
没有使用 STORE
参数,返回列表形式的排序结果。 使用 STORE
参数,返回排序结果的元素数量。
FLUSHDB 清空数据库
可用版本: >= 1.0.0
时间复杂度: O(1)
清空当前数据库中的所有 key。
此命令从不失败。
返回值
总是返回 OK
。
代码示例
redis> DBSIZE # 清空前的 key 数量
(integer) 4
redis> FLUSHDB
OK
redis> DBSIZE # 清空后的 key 数量
(integer) 0
FLUSHALL
可用版本: >= 1.0.0
时间复杂度: O(N)
清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。
此命令从不失败。
返回值
总是返回 OK
。
redis> DBSIZE # 0 号数据库的 key 数量
(integer) 9
redis> SELECT 1 # 切换到 1 号数据库
OK
redis[1]> DBSIZE # 1 号数据库的 key 数量
(integer) 6
redis[1]> flushall # 清空所有数据库的所有 key
OK
redis[1]> DBSIZE # 不但 1 号数据库被清空了
(integer) 0
redis[1]> SELECT 0 # 0 号数据库(以及其他所有数据库)也一样
OK
redis> DBSIZE
(integer) 0
SELECT index
可用版本: >= 1.0.0
时间复杂度: O(1)
切换到指定的数据库,数据库索引号 index
用数字值指定,以 0
作为起始索引值。
默认使用 0
号数据库。
返回值
OK
代码示例
redis> SET db_number 0 # 默认使用 0 号数据库
OK
redis> SELECT 1 # 使用 1 号数据库
OK
redis[1]> GET db_number # 已经切换到 1 号数据库,注意 Redis 现在的命令提示符多了个 [1]
(nil)
redis[1]> SET db_number 1
OK
redis[1]> GET db_number
"1"
redis[1]> SELECT 3 # 再切换到 3 号数据库
OK
redis[3]> # 提示符从 [1] 改变成了 [3]
SWAPDB db1 db2
版本要求: >= 4.0.0
时间复杂度: O(1)
对换指定的两个数据库, 使得两个数据库的数据立即互换。
返回值
OK
代码示例
# 对换数据库 0 和数据库 1
redis> SWAPDB 0 1
OK
过期设置
EXPIRE key seconds 设置过期时间
可用版本: >= 1.0.0
时间复杂度: O(1)
为给定 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)层的限制而作出的,现在这一限制已经被修复。
返回值
设置成功返回 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 秒,那么它的导航会话就会被清空,当用户重新开始阅览的时候,系统又会重新记录导航会话,继续进行物品推荐。
EXPIREAT key timestamp 按时间戳设置到期时间
可用版本: >= 1.2.0
时间复杂度: O(1)
EXPIREAT
的作用和 EXPIRE
类似,都用于为 key
设置生存时间。
不同在于 EXPIREAT
命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
返回值
如果生存时间设置成功,返回 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
TTL key 查看KEY的生存时间,单位秒
可用版本: >= 1.0.0
时间复杂度: O(1)
以秒为单位,返回给定 key
的剩余生存时间(TTL, time to live)。
返回值
当 key
不存在时,返回 -2
。 当 key
存在但没有设置剩余生存时间时,返回 -1
。 否则,以秒为单位,返回 key
的剩余生存时间。
Note
在 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
PERSIST key 移除生存时间
可用版本: >= 2.2.0
时间复杂度: O(1)
移除给定 key
的生存时间,将这个 key
从“易失的”(带生存时间 key
)转换成“持久的”(一个不带生存时间、永不过期的 key
)。
返回值
当生存时间移除成功时,返回 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
PEXPIRE key milliseconds 以毫秒为单位设置过期时间
可用版本: >= 2.6.0
时间复杂度: O(1)
这个命令和 EXPIRE
命令的作用类似,但是它以毫秒为单位设置 key
的生存时间,而不像 EXPIRE
命令那样,以秒为单位。
返回值
设置成功,返回 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
PTTL key 获取以毫秒为单位的生存时间
可用版本: >= 2.6.0
复杂度: O(1)
这个命令类似于 TTL
命令,但它以毫秒为单位返回 key
的剩余生存时间,而不是像 TTL
命令那样,以秒为单位。
返回值
- 当
key
不存在时,返回-2
。 - 当
key
存在但没有设置剩余生存时间时,返回-1
。 - 否则,以毫秒为单位,返回
key
的剩余生存时间。
Note
在 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