Redis常用命令汇总

Redis常用命令汇总

原创文章，学习Redis期间自己总结的常用命令，以及一些简单的实例；文章内容如有错误请及时联系我，谢谢。
QQ：594187062
邮箱：[email protected]

通用命令

select [dbNum] ：切换到某库（默认0-15）。
keys * ：返回当前库所有Key。
exists [key] ：当前库是否存在键是Key的元素。
expire [key] [time] ：为键是key的元素设置过期时间(单位：s)。
ttl [key] ：查看键是key的元素还有多少秒过期。-1表示永不过期，-2表示已过期。
type [key] ：查看键是key的元素的类型。

String

get [key] ：返回key的值。
set [key, value] ：保存key=value。
del [key] ：删除键是key的元素。
strlen [key] ：返回key的值的长度。

append [key][content] ：将content追加到key原来的值的末尾，并返回拼接后字符串的长度。

set key1 abc
append key1 def => 6
get key1 => "abcdef"

incr [key] ：将key中存储的数字+1。
decr [key] ：将key中存储的数字-1。
incrby [key][int] ：将key中存储的数字+int。
decrby [key][int] ：将key中存储的数字-int。

getrange [key] [beginIndex] [endIndex] ：获得key的值中指定范围的字符串。

set key1 v123456
getrange key1 0 2 => "v12"

setrange [key] [beginIndex] [content] ：将key中的值从指定索引位置将content内容进行覆写。

set key1 123456
setrange key1 3 abc => "123abc"

setex [key] [time] [content] ：保存key=value，并设定过期时间是time秒。（set with expire）
setnx [key] [content] ：尝试保存key=value，若key不存在则进行保存，并返回1；若key存在则保存失败，返回0。(set if not exist)

mset [key1] [value1] [key2] [value2]… ：批量执行set命令。
mget [key1] [key2]… ：批量执行get命令。
msetnx [key1] [value1] [key2] [value2]… ：批量执行setnx命令，全部成功返回1，否则返回0。

getset [key] [content] ：先获得key的值，再将key的值覆盖为content。（整个过程具有原子性）

List列表

lpush [key] [value1] [value2]… ：向列表key左边增加若干个元素，返回元素增加后的List长度。
rpush [key] [value1] [value2]… ：向列表key右边增加若干个元素，返回元素增加后的List长度。

lpop [key] ：将列表key左边第一个元素弹出，返回弹出元素的值。（先移除元素，再返回移除的元素，整个过程具有原子性）
rpop [key] ：将列表key右边第一个元素弹出，返回弹出元素的值。

llen [key] ：返回列表key的元素个数，不存在时返回0。

lrange [key] [startIndex] [endIndex] ：获取列表key指定索引的元素。（index包括负数索引，-1表示右边第一个元素，-2表示右边第二个元素，以此类推）

lrem [key] [count] [value] ：删除列表key中合计count个值等于value的元素。
count > 0时，lrem会从List的左边开始删除。
count < 0时，lrem会从List的右边开始删除。
count = 0时，会删除全部值为value的元素。

lindex [key] [index] ：返回列表key指定索引的值。(index>0从列表的左边开始计算，index<0时从列表的右边开始计算)

lset [key] [index] [value] ：将列表key指定索引位的值替换成value。（index>0从列表的左边开始计算，index<0时从列表的右边开始计算）

linsert [key] [before|after] [pivot] [value] ：将列表key由左向右的顺序查找值为pivot的元素，根据"before"或"after"决定插入的value在pivot的左边或者右边，返回所有列表key的长度。若没有找到pivot元素则返回-1，列表key不存在或为空时返回0。

rpush list1 hello
rpush list1 world
lrange list1 0 -1 => "hello" "world"

linsert list1 BEFORE "world " "beautiful" => 3
lrange list 0 -1 => "hello" "beautiful" "world"

rpoplpush [source] [destination] ：将列表source最右边的元素弹出，再将弹出的元素放在列表destination的最左边，返回弹出元素的值。（整个过程具有原子性）

lrange list1 0 -1 => "a" "b"
lrange list2 0 -1 => "c" "d"
rpoplpush list1 list2 => "b"

lrange list1 0 -1 => "a"
lrange list2 0 -1 => "b" "c" "d"

ltrim [key] [startIndex] [endIndex] ：只保留指定区间的元素。（index可以是负数，负数即从列表的右边算起，-1是右边第一个元素，-2是右边第二个元素，以此类推）

Set集合

sadd [key] [member1] [member2]… ：向集合key添加member1、member2等若干个元素，如果集合key不存在则自动创建。一个集合中不能有重复元素，插入重复的元素会被忽略。返回成功插入的元素数量。
srem [key] [member1] [member2]…：删除集合key中指定的元素，返回成功删除的元素数量。
smembers [key] ：返回集合key中所有的元素。
sismember [key] [member] ：判断元素member是否在集合set中存在，成功返回1，失败返回0。

sinter [key1] [key2] … ：返回若干集合间的交集元素。

sadd set01 b
sadd set02 a b c
sinter set01 set02 => "b"

sunion [key1] [key2]… ：返回若干集合间的并集元素。

sadd set01 b
sadd set02 a b c
sunion set01 set02 => "a" "b" "c"

sdiff [key1] [key2]… ：返回若干集合间的差集元素。（自左向右比较）

sadd set01 b
sadd set02 a b c

sdiff set01 set02 => null
sdiff set02 set01 => "a" "c"

scard [key] ：返回集合中元素的数量。

sinterstore [destination] [key1] [key2]… ：将若干集合间的交集元素存储到集合destination中。

sadd set01 b
sadd set02 a b c
sinterstore iset01 set01 set02 => 1
smembers iset01 => "b"

sunionstore [destination] [key1] [key2]… ：将若干集合间的并集元素存储到集合destination中。

sadd set01 b
sadd set02 a b c
sunionstore uset01 set01 set02 => 3
smembers uset01 => "a" "b" "c"

sdiffstore [destination] [key1] [key2]… ：将若干集合间的差集集元素存储到集合destination中。（差集自左向右比较）

sadd set01 b
sadd set02 a b c

sdiffstore dset01 set01 set02 => 0
sdiffstore dset01 set02 set01 => 2
smembers dset01 => "a" "c"

srandmember [key] [count] ：从集合key中随机返回count个元素。count>0时，随机返回不重复的元素；count<0时，随机返回的元素可能会重复；count大于set长度时返回全部元素。

spop [key] [count] ：从集合key中随机弹出count个元素。（将移除弹出的元素）

sadd set01 a b c
spop set01 2 => "c" "b"
smembers set01 => "a"

sorted set有序集合

zadd [key] [score1] [member1] [score2] [member2]… ：向有序集合key添加一个元素member和该元素的分数score。若元素已存在，则会覆盖新的分数。返回成功添加的元素个数。
zscore [key] [member] ：返回有序集合key中member的分数。
zrange [key] [startIndex] [endIndex] [withscores] ：返回有序集合key指定范围的元素（支持负数索引）。设置可选参数withscores，返回结果增加对应元素的分数，分数升序展示。

zadd zset01 2 b 1 a 3 c => 3
zrange zset01 0 -1 => "a" "b" "c"
zrange zset01 0 -1 withscores => "a" "1" "b" "2" "c" "3"

zrevrange [key] [startIndex] [endIndex] [withscores] ：同zrange，返回元素按分数进行降序进行排列。

zrangebyscore [key] [minScore] [maxScore] [ withscores ] [ limit offset count ] ：按照有序集合key中元素分数由小到大的顺序返回分数在minScore和maxScore之间的元素，并且包含minScore和maxScore。

zadd zset01 1 a 10 b 100 c 1000 d
zrangebyscore zset01 1 100 => "a" "b" "c"

如果指定分数范围不包含端点值，可增加"("

zrangebyscore zset01 1 (100 => "a" "b"

可以使用-inf和+inf（分别表示无穷小和无穷大）

zrangebyscore zset01 -inf +inf => "a" "b" "c" "d"

limit offset count用法同mysql，表示截取结果的片段。

zrangebyscore zset01 -inf +inf limit 0 2 => "a" "b"

zrevrangebyscore [key] [minScore] [maxScore] [ withscores ] [ limit offset count ] ：同zrangebyscore命令，返回元素按分数进行降序进行排列。
zincrby [key] [increment] [member] ：增加有序集合key中元素是member的分数，返回更改后的分数。若指定元素不存在，会创建元素，并将分数初始赋值为0，再进行更改。

zadd zset01 1 a 10 b 100 c
zincrby zset01 1 a => "2"
 zscore zset01 a => "2"

zcard [key] ：返回有序集合key中元素的数量。
zcount [key] [minScore] [maxScore] ：返回有序集合key指定分数范围内元素的个数。
zrem [key] [member1] [member2]… ：删除有序集合key中指定的元素，返回成功删除的元素数量。
zremrangebyrank [key] [beginIndex] [endIndex] ：有序集合key按照元素分数升序的顺序，删除指定范围的元素，返回成功删除的元素数量。

zrange zset01 0 -1 withscore => "a" "1" "b" "10" "c" "100" "d" "1000"
zremrangebyrank zset01 0 1 => "2"
zrange zset01 0 -1 withscore => "c" "100" "d" "1000"

zremrangebyscore [key] [minScore] [maxScore] ：删除有序集合key在指定范围内的元素，返回成功删除的元素数量。（分数可使用"("，排除边缘值）

zrange zset01 0 -1 withscores => "a" "100" b "1000"

zremrangebyscore zset01 90 (100 => "0"
zremrangebyscore zset01 90 100 => "1"
zrange zset01 0 -1 withscores => b "1000"

zrank [key] [member] ：返回按照元素分数升序顺序获得指定元素的排名（由0开始计算）。
zrevrank [key] [member] ：同zrank，排序改为降序。
zinterstore [destination] [numberKeys] [key1] [key2]… [weights weight[weight1 weight2…]]
[aggregate SUM|MIN|MAX] ：将若干个有序集合进行交集计算，并将对应元素的分数按照集合对应的weight权重值进行相乘，将分数结果按照aggregate类型进行相加、最小值和最大值进行计算，并将结果存储到有序集合destination中，返回成功添加的元素数量。

destination ：目标集合。
numberKeys ：计算集合数量。
key [key1 key2 ...] ：需要计算的集合。
weights weight [weight1 weight2 ...] ：对应集合的权重值，计算分数时会与分数进行相乘。
aggregate ：SUM(默认)将权重值与分数乘积的结果进行相加得到新分数。MIN取最小值，MAX取最大值。

zrange zset01 0 -1 withscores => "a" "1" "b" "2" "c" "3"
zrange zset02 0 -1 withscores => "b" "20" "c" "30" "d" "40"

zinterstore izset01 2 zset01 zset02 weights 5 1 aggregate SUM => "2"
zrange izset01 0 -1 withscores => "b" "30" "c" "45"

计算步骤：
①将有序集合zset01和zset02的元素进行交集计算得到"b" "c"
②根据有序集合zset01中元素"b"和"c"对应的分数分别是"2"和"3"，与有序集合zset01对应权重值5进行相乘，得到"b=10" "c=15"；同理zset02经过计算得到"b=20" "c=30"
③根据aggregate设置的SUM，将zset01和zset02交集的元素的分数进行相加，得到最终结果"b" "30" "c" "45"。
④将结果保存到有序集合izset01中。

zunionstore [destination] [numberKeys] [key1] [key2]… [weights weight[weight1 weight2…]]
[aggregate SUM|MIN|MAX] ：同zinterstore，进行并集计算。

Hash表

hset [key] [field] [value] ：向Hash表key中的域field的值设为value。
hget [key] [field] ：返回Hash表key中域field的值。
hmset [key] [field1] [value1] [field2] [value2]… ：向Hash表key中批量添加元素。
hmget [key] [field1] [field2]… ：返回Hash表key中若干个域的值。
hgetall [key] ：返回Hash表key中所有域和域的值。
hdel [key] [field1] [field2]… ：删除Hash表key中指定域，返回成功删除域的数量。
hlen [key] ：返回Hash表key中域的数量。
hexists [key] [field] ：查找域field在Hash表key中是否存在，存在返回1，不存在返回0。
hsetnx [key] [field] [value] ：尝试向Hash表key中的域field的值设为value，若field和value都匹配，则添加失败返回0，若没有该域则添加成功，返回1。
hkeys [key] ：返回Hash表key中所有的域名。
hvals [key] ：返回Hash表key中所有域的值。
hincrby [key] [field] [increment] ：将Hash表中field域中的值（必须是Integer）增加increment（必须是Integer），返回更改后的值。
hincrbyfloat [key] [field] [increment] ：将Hash表中field域中的值（可以是Integer或float）增加increment（可以是Integer或float），返回更改后值。

sort命令

sort [key] [BY pattern] [LIMIT offect count] [GET pattern] [DESC\ASC] [ALPHA] [STORE[destination]]
[key] ：需要排序的列表(List)

lrange list01 => "10" "1" "3" "2"
sort list01 => "1" "2" "3" "10"

[LIMIT offect count] ：将结果截取，跳过offect个元素后，截取count个元素。

lrange list01 => "10" "1" "3" "2"
sort list01 limit 1 2 => "2" "3"

[DESC\ASC] ：返回结果以降序或升序的方式进行排序。

lrange list01 => "10" "1" "3" "2"
sort list01 DESC => "10" "3" "2" "1"
sort list ASC => "1" "2" "3" "10"

[ALPHA] : 是否对字符串进行排序

lrange list02 0 -1 => "d" "c" "a" "e"
sort list02 => (Error)  ERR One or more scores can't be converted into double
sort list02 ALPHA => "a" "c" "d" "e"

[STORE[destination]] ：将返回结果保存到目标列表destination

lrange list02 0 -1 => "d" "c" "a" "e"
sort list02 ALPHA STORE newList02 => "4"
lrange newList02 0 -1 => "a" "c" "d" "e"

[BY pattern] ：以外部key的值为权重进行排序

lrange list01 0 -1 => "4" "7" "3" "1"
set str1 10000
set str3 1
set str4 100
set str7 120

sort list01 BY str* => "3" "4" "7" "1"
①这里*是通配符，用来匹配list01中的元素，即以list01元素的顺序匹配出"str4" "str7" "str3" "st1"。
②再以"str4" "str7" "str3" "st1"分别对应的值进行排序，即100，120，1，10000进行升序排列，排序结果1 100 120 10000，与值对应的键分别是"str3" "str4" "str7" "str1"。
③将"str3" "str4" "str7" "str1"的通配符字段取出并返回，即"3" "4" "7" "1"。

pattern也可以对Hash表进行匹配

lrange list01 0 -1 => "4" "7" "3" "1"
hset hash1 num 10000
hset hash3 num 1
hset hash4 num 100
hset hash7 num 120

srot list01 BY hash*->num => "3" "4" "7" "1"
①根据list01中的元素匹配出hash1,hash3,hash4和hash7。
②"hash*->num"其中->num表示以Hash表中num域的值进行比较。
③排序得到结果与str类型相同。

也可以对Hash表中的域进行匹配

lrange list01 0 -1 => "4" "7" "3" "1"
hmset hash02 num1 10000 num3 1 num4 100 num7 120

sort list01 by hash->num* => "3" "4" "7" "1"

[GET pattern] ：将列表key排序后的值进行匹配，返回对应pattern的值。

lrange list01 0 -1 => "4" "7" "3" "1"
set str1 10000
set str3 1
set str4 100
set str7 120

sort list01 GET str* => "10000" "1" "100" "120"
①将列表list01中的元素进行升序，得到结1，3，4，7。
②根据1，3，4，7匹配得到结果str1，str3，str4，str7。
③根据str1，str3，str4，str7的顺序返回其对应的值"10000" "1" "100" "120"。

GET后可以接特殊字符"#"，表示排序列表自身的值（即上面例子中的list01的值）

sort list01 GET # => "1" "3" "4" "7"

GET可以同时获得多个对象

lrange list01 0 -1 => "4" "7" "3" "1"
set str1 10000
set str3 1
set str4 100
set str7 120

sort list01 GET # GET str* => "1" "10000" "3" "1" "4" "100" "7" "120"
sort list01 GET str* GET # => "10000" "1" "1" "3" "100" "4" "120" "7"
①返回结果时会根据GET对象的顺序进行排序。即sort list01 GET #返回"1" "3" "4" "7"；sort list01 GET str* => "10000" "1" "100" "120"。
②sort list01 GET # GET str*返回结果时，先从GET #中获得一个值"1"，再从GETstr*获得一个值"10000"，第二组就是"3"和"1"，以此类推。

**[BY pattern]和[GET pattern]**组合使用。即先从BY中得到的值，再跟GET进行匹配。

lrange list01 => "1" "3" "2" "5"
set str1 11
set str3 13
set str2 22
set str5 1

set getStr1 rose
set getStr2 jack
set getStr3 john
set getStr5 tim

sort list01 BY str* => "5" "1" "3" "2"
sort list01 BY str* GET getStr* => "tim" "rose" "john" "jack"
①根据sort list01 BY str*得到结果，根据顺序分别得到"getStr5" "getStr1" "getStr3" "getStr2"。
②根据顺序返回"getStr5" "getStr1" "getStr3" "getStr2"分别对应地值"tim" "rose" "john" "jack"