Redis常用命令汇总

「爱情、让人受尽委屈。」 2022-03-20 16:08 230阅读 0赞

### Redis常用命令汇总 ###

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

### 通用命令 ###

**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"