Redis命令参考简体中文版

转自：Redis命令参考简体中文版

本文是《Redis Command Reference》的简体中文翻译版，原文共十个部分的所有命令均已翻译完毕。

键(Key)

DEL

DEL key [key …]
  移除给定的一个或多个key。
  如果key不存在，则忽略该命令。

时间复杂度：
  O(N)，N为要移除的key的数量。
  移除单个字符串类型的key，时间复杂度为O(1)。
  移除单个列表、集合、有序集合或哈希表类型的key，时间复杂度为O(M)，M为以上数据结构内的元素数量。

返回值：
  被移除key的数量。

 # 情况1： 删除单个key 
redis> SET name huangz # 设置一个值
OK
redis> DEL name  # 将其删除
(integer) 1

# 情况2： 删除一个不存在的key
redis> EXISTS phone  # 检查一个不存在的key
(integer) 0
redis> DEL phone # 试图删除一个不存在的key，失败
(integer) 0

# 情况3： 同时删除多个key
redis> MSET name huangz age 20 blog huangz.iteye.com # 同时设置多个key-value对
OK
redis> DEL name age blog # 同时删除三个key
(integer) 3

KEYS

KEYS pattern
  查找符合给定模式的key。

  KEYS *   命中数据库中所有key。
  KEYS h?llo   命中hello， hallo and hxllo等。
  KEYS h*llo   命中hllo和heeeeello等。
  KEYS h[ae]llo   命中hello和hallo，但不命中hillo。
  特殊符号用"\"隔开

时间复杂度：
  O(N)，N为数据库中key的数量。

返回值：
  符合给定模式的key列表。

Warning: KEYS的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合(Set)。

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"

RANDOMKEY

RANDOMKEY
  从当前数据库中随机返回(不删除)一个key。

时间复杂度：
  O(1)

返回值：
  当数据库不为空时，返回一个key。
  当数据库为空时，返回nil。

# 情况1：数据库不为空
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"

# 情况2：数据库为空
redis> flushdb  # 删除当前数据库所有key
OK

redis> randomkey
(nil)

TTL

TTL key
  返回给定key的剩余生存时间(time to live)(以秒为单位)。

时间复杂度：
  O(1)

返回值：
  key的剩余生存时间(以秒为单位)。
  当key不存在或没有设置生存时间时，返回-1 。

# 情况1：带TTL的key
redis> set name "huangz"    # 设置一个key
OK

redis> expire name 30  # 设置生存时间为30秒
(integer) 1

redis> get name
"huangz"

redis> ttl name
(integer) 25

redis> ttl name # 30秒过去，name过期
(integer) -1

redis> get name # 过期的key将被删除
(nil)

# 情况2：不带TTL的key
redis> SET site wikipedia.org
OK

redis> TTL wikipedia.org
(integer) -1

# 情况3：不存在的key
redis> EXISTS not_exists_key
(integer) 0

redis> TTL not_exists_key
(integer) -1

EXISTS

EXISTS key
  检查给定key是否存在。

时间复杂度：
  O(1)

返回值：
  若key存在，返回1，否则返回0。

redis> set db "redis"
OK

redis> exists db  # key存在
(integer) 1

redis> del db   # 删除key
(integer) 1

redis> exists db  # key不存在
(integer) 0

MOVE

MOVE key db
  将当前数据库(默认为0)的key移动到给定的数据库db当中。
  如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
  因此，也可以利用这一特性，将MOVE当作锁(locking)原语。

时间复杂度：
  O(1)

返回值：
  移动成功返回1，失败则返回0。

# 情况1： 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

# 情况2：当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

# 情况3：当源数据库和目标数据库有相同的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"

RENAME

RENAME key newkey
  将key改名为newkey。
  当key和newkey相同或者key不存在时，返回一个错误。
  当newkey已经存在时，RENAME命令将覆盖旧值。

时间复杂度：
  O(1)

返回值：
  改名成功时提示OK，失败时候返回一个错误。

# 情况1：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

# 情况2：当key不存在时，返回错误
redis> RENAME fake_key never_exists
(error) ERR no such key

# 情况3：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"

TYPE

TYPE key
  返回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

EXPIRE

EXPIRE key seconds
  为给定key设置生存时间。
  当key过期时，它会被自动删除。
  在Redis中，带有生存时间的key被称作“易失的”(volatile)。
  在低于2.1.3版本的Redis中，已存在的生存时间不可覆盖。
  从2.1.3版本开始，key的生存时间可以被更新，也可以被PERSIST命令移除。(详情参见 http://redis.io/topics/expire)。

时间复杂度：
  O(1)

返回值：
  设置成功返回1。
  当key不存在或者不能为key设置生存时间时(比如在低于2.1.3中你尝试更新key的生存时间)，返回0。

redis> SET cache_page "www.twitter.com/huangz1990"
OK

redis> EXPIRE cache_page 30  # 设置30秒后过期
(integer) 1

redis> TTL cache_page   # 查看给定key的剩余生存时间
(integer) 24

redis> EXPIRE cache_page 30000  # 更新生存时间，30000秒
(integer) 1

redis> TTL cache_page
(integer) 29996

OBJECT

  
OBJECT subcommand [arguments [arguments]]
  OBJECT命令允许从内部察看给定key的Redis对象。

  它通常用在除错(debugging)或者了解为了节省空间而对key使用特殊编码的情况。
  当将Redis用作缓存程序时，你也可以通过OBJECT命令中的信息，决定key的驱逐策略(eviction policies)。
  OBJECT命令有多个子命令：

• OBJECT REFCOUNT 返回给定key引用所储存的值的次数。此命令主要用于除错。
• OBJECT ENCODING 返回给定key锁储存的值所使用的内部表示(representation)。
• OBJECT IDLETIME 返回给定key自储存以来的空转时间(idle， 没有被读取也没有被写入)，以秒为单位。

  对象可以以多种方式编码：

• 字符串可以被编码为raw(一般字符串)或int(用字符串表示64位数字是为了节约空间)。
• 列表可以被编码为ziplist或linkedlist。ziplist是为节约大小较小的列表空间而作的特殊表示。
• 集合可以被编码为intset或者hashtable。intset是只储存数字的小集合的特殊表示。
• 哈希表可以编码为zipmap或者hashtable。zipmap是小哈希表的特殊表示。
• 有序集合可以被编码为ziplist或者skiplist格式。ziplist用于表示小的有序集合，而skiplist则用于表示任何大小的有序集合。

  假如你做了什么让Redis没办法再使用节省空间的编码时(比如将一个只有1个元素的集合扩展为一个有100万个元素的集合)，特殊编码类型(specially encoded types)会自动转换成通用类型(general type)。

时间复杂度：
  O(1)

返回值：
  REFCOUNT和IDLETIME返回数字。
  ENCODING返回相应的编码类型。

RENAMENX

RENAMENX key newkey
  当且仅当newkey不存在时，将key改为newkey。
  出错的情况和RENAME一样(key不存在时报错)。

时间复杂度：
  O(1)

返回值：
  修改成功时，返回1。
  如果newkey已经存在，返回0。

# 情况1：newkey不存在，成功
redis> SET player "MPlyaer"
OK

redis> EXISTS best_player
(integer) 0

redis> RENAMENX player best_player
(integer) 1

# 情况2：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"

EXPIREAT

EXPIREAT key timestamp
  EXPIREAT的作用和EXPIRE一样，都用于为key设置生存时间。
  不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。

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

PERSIST

PERSIST key
  移除给定key的生存时间。

时间复杂度：
  O(1)

返回值：
  当生存时间移除成功时，返回1.
  如果key不存在或key没有设置生存时间，返回0。

redis> SET time_to_say_goodbye "886..."
OK

redis> EXPIRE time_to_say_goodbye 300
(integer) 1

redis> TTL time_to_say_goodbye
(integer) 293

redis> PERSIST time_to_say_goodbye  # 移除生存时间
(integer) 1

redis> TTL time_to_say_goodbye  # 移除成功
(integer) -1

SORT

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"

具体可参考：https://redis.readthedocs.io/en/2.4/key.html

哈希表(Hash)

HSET

HSET key field value
  将哈希表key中的域field的值设为value。
  如果key不存在，一个新的哈希表被创建并进行HSET操作。
  如果域field已经存在于哈希表中，旧值将被覆盖。

时间复杂度：
  O(1)

返回值：
  如果field是哈希表中的一个新建域，并且值设置成功，返回1。
  如果哈希表中域field已经存在且旧值已被新值覆盖，返回0。

redis> HSET website google "www.g.cn"   # 一个新域
(integer) 1

redis> HSET website google "www.google.com" # 覆盖一个旧域
(integer) 0

HSETNX

HSETNX key field value
  将哈希表key中的域field的值设置为value，当且仅当域field不存在。

  若域field已经存在，该操作无效。

  如果key不存在，一个新哈希表被创建并执行HSETNX命令。

时间复杂度：
  O(1)

返回值：
  设置成功，返回1。
  如果给定域已经存在且没有操作被执行，返回0。

redis> HSETNX nosql key-value-store redis
(integer) 1

redis> HSETNX nosql key-value-store redis  # 操作无效，域key-value-store已存在
(integer) 0

HMSET

HMSET key field value [field value …]
  同时将多个field - value(域-值)对设置到哈希表key中。

  此命令会覆盖哈希表中已存在的域。

  如果key不存在，一个空哈希表被创建并执行HMSET操作。

时间复杂度：
  O(N)，N为field - value对的数量。

返回值：
  如果命令执行成功，返回OK。
  当key不是哈希表(hash)类型时，返回一个错误。

# 情况1： 哈希表
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HGET website google
"www.google.com"

redis> HGET website yahoo
"www.yahoo.com"

# 情况2：类型错误时
redis> SET G 10  # 出错情况
OK

redis> HMSET G name huangz age 20
(error) ERR Operation against a key holding the wrong kind of value

HGET

HGET key field
  返回哈希表key中给定域field的值。

时间复杂度：
  O(1)

返回值：
  给定域的值。
  当给定域不存在或是给定key不存在时，返回nil。

redis> HSET huangz blog huangz.iteye.com
(integer) 1

redis> HGET huangz blog
"huangz.iteye.com"

HMGET

HMGET key field [field …]
  返回哈希表key中，一个或多个给定域的值。

  如果给定的域不存在于哈希表，那么返回一个nil值。

  因为不存在的key被当作一个空哈希表来处理，所以对一个不存在的key进行HMGET操作将返回一个只带有nil值的表。

时间复杂度：
  O(N)，N为给定域的数量。

返回值：
  一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

redis> HMSET pet dog "doudou" cat "nounou"  # 一次保存多个值
OK

redis> HMGET pet dog cat fake_pet  # 返回值的顺序和传入参数的顺序一样。
1) "doudou"
2) "nounou"
3) (nil)  # 不存在的域返回nil值

HGETALL

HGETALL key
  返回哈希表key中，所有的域和值。
  在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

时间复杂度：
  O(N)，N为哈希表的大小。

返回值：
  以列表形式返回哈希表的域和域的值。 若key不存在，返回空列表。

redis> HSET hash_name jack "Jack Sparrow"
(integer) 1

redis> HSET hash_name gump "Forrest Gump"
(integer) 1

redis> HGETALL hash_name
1) "jack"          # 域
2) "Jack Sparrow"  # 值
3) "gump"
4) "Forrest Gump"

HDEL

HDEL key field [field …]
  删除哈希表key中的一个或多个指定域，不存在的域将被忽略。

时间复杂度:
  O(N)，N为要删除的域的数量。

返回值:
  被成功移除的域的数量，不包括被忽略的域。

Note: 在Redis2.4以下的版本里，HDEL每次只能删除单个域，如果你需要在一个原子时间内删除多个域，请将命令包含在MULTI/ EXEC块内。

# 测试数据
redis> HGETALL abbr
1) "a"
2) "apple"
3) "b"
4) "banana"
5) "c"
6) "cat"
7) "d"
8) "dog"

# 删除单个域
redis> HDEL abbr a
(integer) 1

# 删除不存在的域
redis> HDEL abbr not-exists-field
(integer) 0

# 删除多个域
redis> HDEL abbr b c
(integer) 2

redis> HGETALL abbr
1) "d"
2) "dog"

HLEN

HLEN key
  返回哈希表key中域的数量。

时间复杂度：
  O(1)

返回值：
  哈希表中域的数量。
  当key不存在时，返回0。

redis> HSET hash_name jack "Jack Sparrow"
(integer) 1

redis> HSET hash_name gump "Forrest Gump"
(integer) 1

redis> HLEN hash_name
(integer) 2

HEXISTS

HEXISTS key field
  查看哈希表key中，给定域field是否存在。

时间复杂度：
  O(1)

返回值：
  如果哈希表含有给定域，返回1。
  如果哈希表不含有给定域，或key不存在，返回0。

redis> HEXISTS phone myphone
(integer) 0

redis> HSET phone myphone nokia-1110
(integer) 1

redis> HEXISTS phone myphone
(integer) 1

HINCRBY

HINCRBY key field increment
  为哈希表key中的域field的值加上增量increment。

  增量也可以为负数，相当于对给定域进行减法操作。

  如果key不存在，一个新的哈希表被创建并执行HINCRBY命令。

  如果域field不存在，那么在执行命令前，域的值被初始化为0。

  对一个储存字符串值的域field执行HINCRBY命令将造成一个错误。

  本操作的值限制在64位(bit)有符号数字表示之内。

时间复杂度：
  O(1)

返回值：
  执行HINCRBY命令之后，哈希表key中域field的值。

# 情况1：increment为正数
redis> HEXISTS counter page_view # 对空域进行设置
(integer) 0

redis> HINCRBY counter page_view 200
(integer) 200

redis> HGET counter page_view
"200"

# 情况2：increment为负数
redis> HGET counter page_view
"200"

redis> HINCRBY counter page_view -50
(integer) 150

redis> HGET counter page_view
"150"

# 情况3：尝试对字符串值的域执行HINCRBY命令
redis> HSET myhash string hello,world    # 设定一个字符串值
(integer) 1

redis> HGET myhash string
"hello,world"

redis> HINCRBY myhash string 1   # 命令执行失败，错误。
(error) ERR hash value is not an integer

redis> HGET myhash string    # 原值不变
"hello,world"

HKEYS

HKEYS key
  返回哈希表key中的所有域。

时间复杂度：
  O(N)，N为哈希表的大小。

返回值：
  一个包含哈希表中所有域的表。
  当key不存在时，返回一个空表。

# 情况1：哈希表非空
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HKEYS website
1) "google"
2) "yahoo"

# 情况2：空哈希表/key不存在
redis> EXISTS fake_key
(integer) 0

redis> HKEYS fake_key
(empty list or set)

HVALS

HVALS key
  返回哈希表key中的所有值。

时间复杂度：
  O(N)，N为哈希表的大小。

返回值：
  一个包含哈希表中所有值的表。
  当key不存在时，返回一个空表。

# 情况1：非空哈希表
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HVALS website
1) "www.google.com"
2) "www.yahoo.com"

# 情况2：空哈希表/不存在的key
redis> EXISTS not_exists
(integer) 0

redis> HVALS not_exists
(empty list or set)

字符串(String)

参考：https://redis.readthedocs.io/en/2.4/string.html

表(List)

参考：https://redis.readthedocs.io/en/2.4/list.html

集合(Set)

参考：https://redis.readthedocs.io/en/2.4/set.html

有序集(Sorted Set)

参考：https://redis.readthedocs.io/en/2.4/sorted_set.html

发布/订阅(Pub/Sub)

参考：https://redis.readthedocs.io/en/2.4/pub_sub.html

事务(Transaction)

参考：https://redis.readthedocs.io/en/2.4/transaction.html

连接(Connection)

参考：https://redis.readthedocs.io/en/2.4/connection.html

服务器(Server)

参考：https://redis.readthedocs.io/en/2.4/server.html