你都用过哪些redis命令？

2019-04-23 本文已影响0人爪哇部落格

Redis支持数据结构丰富，同时又提供了丰富的工具用于管理集群，管理实例等，本文对常用命令做一个大概介绍，大家做到心中有数即可，具体使用可以参考官网Redis命令API

$\color{red}{码字不易，欢迎大家转载，烦请注明出处；谢谢配合}$

字符串命令

字符串底层由三种数据结构组成，可以通过 OBJECT ENCODING <KEY> 来查看底层数据结构：
int：8字节长整型
embstr：小于等于39个字节的字符串
raw：大于39个字节的字符串

SET

# set key value [expiration EX seconds|PX milliseconds] [NX|XX]
# 设置值
# expiration EX：过期秒数[选填]
# milliseconds PX：过期毫秒数[选填]
# NX：原值不存在，则设置成功[选填]
# XX：原值存在，则设置成功[选填]
# 时间复杂度 O(1)
127.0.0.1:6379> set test sun
OK
127.0.0.1:6379> set test sun nx
(nil)
127.0.0.1:6379> set test ce XX
OK
127.0.0.1:6379> set sun ce EX 10
OK
127.0.0.1:6379> ttl sun
(integer) 9
127.0.0.1:6379> set sun ce PX 10000
OK
127.0.0.1:6379> ttl sun
(integer) 7

SETEX

# setex key second value
# 设置值带过期时间（秒）
# 时间复杂度 O(1)
127.0.0.1:6379> setex sun 10 ce 
OK
127.0.0.1:6379> ttl sun
(integer) 6

PSETEX

# psetex key millisecond key
# 设置值带过期时间（毫秒）
# 时间复杂度 O(1)
127.0.0.1:6379> psetex sun 10000 ce
OK
127.0.0.1:6379> ttl sun
(integer) 8

SETNX

# setnx key value
# 值不存在时设置，设置成功返回1，失败返回0。
# 时间复杂度 O(1)
127.0.0.1:6379> set sun ce
OK
127.0.0.1:6379> setnx sun ce
(integer) 0
127.0.0.1:6379> del sun 
(integer) 1
127.0.0.1:6379> setnx sun ce
(integer) 1

GETSET

# getset key value
# 设置时返回旧值 
# 时间复杂度 O(1) 
127.0.0.1:6379> set sun ce
OK
127.0.0.1:6379> getset sun hello
"ce"
127.0.0.1:6379>

GETRANGE

# getrange key start end
# 获取子字符串 getrange
# 时间复杂度 O(n)，n为字符串长度，如果字符串不长可以视为o(1). 
127.0.0.1:6379> set sun hello
OK
127.0.0.1:6379> getrange sun 0 2
"hel"

SETRANGE

# setrange key offset value
# 覆盖某部分的值
# 时间复杂度 O(1) 
127.0.0.1:6379> set sun hello
OK
127.0.0.1:6379> setrange sun 0 leh
(integer) 5
127.0.0.1:6379> get sun
"lehlo"

STRLEN

# strlen key
# 获取字符串长度
# 时间复杂度 O(1) 
127.0.0.1:6379> set sun hello
OK
127.0.0.1:6379> strlen sun
(integer) 5

INCR

# incr key
# 自增一，非数字返回错误，不存在从0开始自增，数字则加1
# 时间复杂度 O(1) 
127.0.0.1:6379> set sun ce
OK
127.0.0.1:6379> incr sun
(error) ERR value is not an integer or out of range
127.0.0.1:6379> del sun
(integer) 1
127.0.0.1:6379> incr sun
(integer) 1
127.0.0.1:6379> incr sun
(integer) 2

INCRBY

# incrby key decrement
# 自增N，非数字返回错误，不存在从0开始自增，数字则加N
# 时间复杂度 O(1) 
127.0.0.1:6379> set sun ce
OK
127.0.0.1:6379> incrby sun 3
(error) ERR value is not an integer or out of range
127.0.0.1:6379> del sun
(integer) 1
127.0.0.1:6379> incrby sun 3
(integer) 3
127.0.0.1:6379> incrby sun 2
(integer) 5

DECR

# decr key
# 自减一，非数字返回错误，不存在从0开始自减，数字则减一
# 时间复杂度 O(1) 
127.0.0.1:6379> decr sun
(integer) -1

DECRBY

# decrby key decrement
# 自减N，非数字返回错误，不存在从0开始自减，数字则减N
# 时间复杂度 O(1) 
127.0.0.1:6379> decrby sun 10
(integer) -11

APPEND

# append key value
# 在原有值后拼接,原值不存在则类似与set操作，存在则拼接
# 时间复杂度 O(1) 
127.0.0.1:6379> append sun hello
(integer) 5
127.0.0.1:6379> append sun ce
(integer) 7
127.0.0.1:6379> 
127.0.0.1:6379> get sun
"helloce"

MSET

# mset key value ..key value
# 同时设置一对或多对 key-value
# 时间复杂度 O(k) k为key的个数
127.0.0.1:6379> mset sun ce ce sun
OK

MSETNX

# msetnx key value ..key value
# 同时设置一对或多对 key-value，不存在时设置成功,成功返回1，不成功返回0
# 有一个已存在，其他的也不会插入成功
# 时间复杂度 O(k) k为key的个数
127.0.0.1:6379> msetnx hello1 su hello2 c
(integer) 1
127.0.0.1:6379> msetnx sun ce ce sun
(integer) 0

MGET

# mget key .. key 
# 同时获取一对或多对 key-value
# 时间复杂度 O(k) k为key的个数
127.0.0.1:6379> mget sun ce
1) "ce"
2) "sun"

SCAN

# scan cursor [MATCH pattern] [COUNT count]
# cursor 游标位置
# 可以使用SCAN渐进的遍历，会返回下一个的游标
127.0.0.1:6379> scan 0
1) "22"
2)  1) "yourlist"
    2) "sun"
    3) "sun:friend"
    4) "union:class"
    5) "hello2"
    6) "myset"
    7) "sun:can:union"
    8) "class:2"
    9) "can:friend"
   10) "sun:can:diff"

哈希命令

哈希的底层数据结构由如下两种：

ziplist：元素个数小于hash-max-ziplist-entries配置（默认512），并且同时所有值都小于hash-max-ziplist-value配置（默认64）
hashtable：以上条件不成立则使用hashtable

HSET

# hset key field value 
# 设置值
# 时间复杂度 O(1) 
127.0.0.1:6379> hset user:1 name sunce
(integer) 1

HGET

# hget key field  
# 获取值，不存在返回nil
# 时间复杂度 O(1) 
127.0.0.1:6379> hget user:1 name
"sunce"
127.0.0.1:6379> hget user:1 age
(nil)

HDEL

# hdel key field  
# 删除一个或多个field，返回成功个数
# 时间复杂度 O(k) k为fileds个数 
127.0.0.1:6379> hdel user:1 age
(integer) 0
127.0.0.1:6379> hdel user:1 name
(integer) 1

HLEN

# hlen key
# 计算field个数
# 时间复杂度 O(1) 
127.0.0.1:6379> hset user:1 name sun
(integer) 1
127.0.0.1:6379> hset user:1 age 18
(integer) 1
127.0.0.1:6379> hlen user:1
(integer) 2

HMSET

# hmset key filed value ... filed value
# 批量设置
# 时间复杂度 O(k) k为fileds个数 
127.0.0.1:6379> hmset user:1 name ce age 18 sex boy
OK

HMGET

# hmget key filed ... filed
# 批量获取
# 时间复杂度 O(k) k为fileds个数 
127.0.0.1:6379> hmget user:1 name age sex
1) "ce"
2) "18"
3) "boy"

HEXISTS

# hexists key filed
# 判断field是否存在，存在返回1，不存在返回0
# 时间复杂度 O(k) k为fileds个数 
127.0.0.1:6379> hexists user:1 sex
(integer) 1

HKEYS

# hkeys key
# 返回某个key 全部的 fileds，这个命令感觉交hfileds 更合适
# 时间复杂度 O(n) n为全部filed个数
127.0.0.1:6379> hkeys user:1
1) "name"
2) "age"
3) "sex"

HVALS

# hvals key
# 获取某个key全部fields的val
# 时间复杂度 O(n) n为全部filed个数
127.0.0.1:6379> hvals user:1
1) "ce"
2) "18"
3) "boy"

HGETALL

# hgetall key
# 获取某个key全部的fields和values
# 时间复杂度 O(n) n为全部filed个数
127.0.0.1:6379> hgetall user:1
1) "name"
2) "ce"
3) "age"
4) "18"
5) "sex"
6) "boy"

HSETNX

# hsetnx key filed value
# 当filed对应value不存在时设置，设置成功返回1，不成功返回0
# 时间复杂度 O(1) 
127.0.0.1:6379> hsetnx user:1 name wang
(integer) 0
127.0.0.1:6379> hsetnx user:1 url www.sunce.wang
(integer) 1

HINCRBY

# hincrby key filed increment
# 给某个field增加n
# 时间复杂度 O(1) 
127.0.0.1:6379> hset user:1 age 18
(integer) 0
127.0.0.1:6379> hincrby user:1 age 3
(integer) 21

HSTRLEN

# hstrlen key field
# 获取某个filed value的长度
# 时间复杂度 O(1) 
127.0.0.1:6379> hset user:1 name ce
(integer) 0
127.0.0.1:6379> hstrlen user:1 name
(integer) 2

HSCAN

# hscan key cursor [MATCH pattern] [COUNT count]
# 渐进遍历hash
127.0.0.1:6379> hscan user:1 0
1) "0"
2) 1) "name"
   2) "ce"
   3) "age"
   4) "18"
   5) "sex"
   6) "boy"
   7) "url"
   8) "www.sunce.wang"

列表命令

list的底层数据结构由如下两种构成：

ziplist：当元素个数小于于list-max-ziplist-entries配置（默认512个），同时列表中每个元素的值都小于list-max-ziplist-value配置时（默认64字节）

linkedlist：当以上条件不成立时使用linkedlist

Redis在3.2版本，结合了ziplist跟linkedlist优势，将list数据结构升级为quicklist

RPUSH/LPUSH/LINSERT

# rpush key value .. value
# 右边插入一个或多个value
# 时间复杂度o(k)，k为元素个数
127.0.0.1:6379> rpush mylist a b b c d
(integer) 5

# lpush key value .. value
# 左边插入一个或多个value
# 时间复杂度o(k)，k为元素
127.0.0.1:6379> lpush mylist 1 2 3 4 5
(integer) 5

# linsert key BEFORE|AFTER pivot value
# 向某个元素前面或者后面插入元素,返回插入后的长度 
# 时间复杂度o(n)，n是pivot到队首或队尾的位置
127.0.0.1:6379> linsert mylist BEFORE 1 a
(integer) 11
127.0.0.1:6379> linsert mylist before a m
(integer) 12

LRANGE/LINDEX/LLEN

# lrange key start end
# 返回key，start 到 end 的value值；0，-1 表示全部
# 时间复杂度o(s+n)，s：为偏移量，n：为start至end距离
127.0.0.1:6379> lrange mylist 0 -1
 1) "5"
 2) "4"
 3) "3"
 4) "2"
 5) "m"
 6) "a"
 7) "1"
 8) "a"
 9) "b"
10) "b"
11) "c"
12) "d"

# lindex key index
# 返回某个key，某个下标的值；0是第一个，-1是最后一个
# 时间复杂度o(n)，n为偏移量
127.0.0.1:6379> lindex mylist 0
"5"
127.0.0.1:6379> lindex mylist -1
"d"

# llen key
# 返回当前key长度
# 时间复杂度o(1)
127.0.0.1:6379> llen mylist
(integer) 12

LPOP/RPOP/LREM/LTRIM

# lpop key
# 左侧弹出，返回弹出值
# 时间复杂度o(1)
127.0.0.1:6379> lpop mylist
"5"

# rpop key
# 右侧弹出，返回弹出值
# 时间复杂度o(1)
127.0.0.1:6379> rpop mylist
"d"

# lrem key count value
# count>0 从左到右删除，最多删除count个值为value元素,
# count<0 从右到左删除，最多删除count绝对值个为value元素
# count=0 ,删除所有值为value元素
# 时间复杂度o(n)，n为列表长度
127.0.0.1:6379> rpush mylist a a a a b c d
(integer) 7
127.0.0.1:6379> lrem mylist 1 a
(integer) 1
127.0.0.1:6379> lrange mylist 0 -1
1) "a"
2) "a"
3) "a"
4) "b"
5) "c"
6) "d"
127.0.0.1:6379> lrem mylist -1 a
(integer) 1
127.0.0.1:6379> lrange mylist 0 -1
1) "a"
2) "a"
3) "b"
4) "c"
5) "d"

# ltrim key start stop
# 保留key从start至stop的元素，其余全部删除
# 时间复杂度o(n)，n为要裁剪的元素个数
127.0.0.1:6379> ltrim mylist -2 -1
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "c"
2) "d"

LSET

# lset key index value
# 修改某个index的value值
# 时间复杂度o(n)，n为偏移量
127.0.0.1:6379> lrange mylist 0 -1
1) "c"
2) "d"
127.0.0.1:6379> lset mylist 0 a
OK

BLPOP/BRPOP

# blpop key [key ...] timeout
# 阻塞式左弹出，如果值为不为空，则直接弹出；若为空则阻塞，直到timeout；如果timeout=0则一直阻塞
# 时间复杂度o(1)
127.0.0.1:6379> blpop list 3
(nil)
(3.00s)
127.0.0.1:6379> blpop list 0
1) "list"
2) "hello"
(37.07s)

# brpop key [key ...] timeout
# 阻塞式右弹出，如果值为不为空，则直接弹出；若为空则阻塞，直到timeout；如果timeout=0则一直阻塞
# 时间复杂度o(1)
127.0.0.1:6379> brpop list 0
1) "list"
2) "world"
(9.93s)

集合命令

集合的底层数据结构有如下两种实现：

intset：元素全部为整数，并且元素个数小于set-maxintset-entries配置（默认512个）
hashtable：以上条件不成立是使用hashtable

SADD

# sadd key member [member ...]
# 添加元素,返回成功添加元素个数
# 时间复杂度o(k) k为元素个数
127.0.0.1:6379> sadd myset a b
(integer) 2

SREM

# srem key member [member ...]
# 删除元素
# 时间复杂度o(k) k为元素个数
127.0.0.1:6379> srem myset a b
(integer) 2

SCARD

# scard key 
# 返回元素个数
# 时间复杂度o(1)
127.0.0.1:6379> sadd myset a b c
(integer) 3
127.0.0.1:6379> scard myset
(integer) 3

SISMEMBER

# sismember key member
# 是否包含元素，包含返回1，否则返回0
# 时间复杂度o(1)
127.0.0.1:6379> sismember myset a
(integer) 1
127.0.0.1:6379> sismember myset d
(integer) 0

SRANDMEMBER

# srandmember key [count]
# 随机从集合返回指定个数的元素
# 时间复杂度o(k) k为count个数
127.0.0.1:6379> srandmember myset 2
1) "b"
2) "a"

SPOP

# spop key [count]
# 随机从集合弹出元素
# 时间复杂度o(k) k为count个数
127.0.0.1:6379> spop myset 
"b"
127.0.0.1:6379> SPOP myset 1
1) "a"

SMEMBERS

# smembers key
# 获取集合全部元素
# 时间复杂度o(n) n为集合大小
127.0.0.1:6379> sadd myset a b c d
(integer) 4
127.0.0.1:6379> smembers myset
1) "b"
2) "c"
3) "d"
4) "a"

SINTER

# sinter key [key ...]
# 取多个集合的交集
# 时间复杂度o(m*k) m为key个数，k为最少的集合的元素个数
127.0.0.1:6379> sadd sun:friend lee wang zhou
(integer) 3
127.0.0.1:6379> sadd can:friend zhou cao han
(integer) 3
127.0.0.1:6379> sinter sun:friend can:friend
1) "zhou"

SINTERSTORE

# sinterstore destination key [key ...]
# 取多个集合的交集并保存
127.0.0.1:6379> sinterstore sun:can:inter sun:friend can:friend 
(integer) 1
127.0.0.1:6379> smembers sun:can:inter
1) "zhou"

SUNION

# sunion key [key ...]
# 取两个集合的并集
# 时间复杂度o(k) k为多个元素总个数
127.0.0.1:6379> sunion sun:friend can:friend
1) "zhou"
2) "cao"
3) "lee"
4) "wang"
5) "han"

SUNIONSTORE

# sunionstore destination key [key ...]
# 取多个集合的并集并保存
127.0.0.1:6379> sunionstore sun:can:union sun:friend can:friend
(integer) 5
127.0.0.1:6379> smembers sun:can:union
1) "zhou"
2) "cao"
3) "lee"
4) "wang"
5) "han"

SDIFF

# sdiff key [key ...]
# 取两个集合的差集
# 时间复杂度o(k) k为多个元素总个数
127.0.0.1:6379> sdiff sun:friend can:friend
1) "lee"
2) "wang"
127.0.0.1:6379> sdiff can:friend sun:friend
1) "cao"
2) "han"

SDIFFSTORE

# sdiffstore destination key [key ...]
# 取多个集合的差集并保存
127.0.0.1:6379> sdiffstore sun:can:diff sun:friend can:friend
(integer) 2
127.0.0.1:6379> smembers sun:can:diff
1) "lee"
2) "wang"

SSCAN

# sscan key cursor [MATCH pattern] [COUNT count]
127.0.0.1:6379> sscan myset 0
1) "0"
2) 1) "b"
   2) "d"
   3) "c"
   4) "a"

有序集合命令

有序集合底层数据结构由如下几种组成：

ziplist：当有序集合元素个数小于：zset-max-ziplistentries配置（默认128个），同时每个元素的值都小于zset-max-ziplist-value配置（默认64字节）时，使用ziplist结构
skiplist：以上条件不成立是使用skiplist

ZADD

# zadd key [NX|XX] [CH] [INCR] score member [score member ...]
# 添加元素
# [NX|XX] 选填 不存在|存在
# CH 选填 返回有序集合分数变化的个数
# INCR 对score增加

127.0.0.1:6379> zadd score:math 100 sun
(integer) 1
127.0.0.1:6379> zadd score:math ch 101 sun 99 can 98 wang 100 zhou
(integer) 4

ZCARD

# zcard key
# 统计有序集合元素个数
127.0.0.1:6379> zcard score:math
(integer) 4

ZSCORE

# zscore key member
# 获取某个成员的分数
127.0.0.1:6379> zscore score:math sun
"101"

ZRANK/ZREVRANK

# zrank/zrevrank key member
# zrank 分数从低到高 zrevrank 分数从高到低；都是从0开始，不存在返回nil
127.0.0.1:6379> zrank score:math sun
(integer) 3
127.0.0.1:6379> zrevrank score:math sun
(integer) 0
127.0.0.1:6379> zrank score:math li
(nil)

ZREM

# zrem key member [member ..]
# 删除成员，返回成功删除个数
127.0.0.1:6379> zrem score:math li wang
(integer) 1

ZINCRBY

# zincrby key increment member
# 给指定成员增加指定分数，返回修改后分数
127.0.0.1:6379> zincrby score:math 100 sun
"201"

ZRANGE/ZREVRANGE

# zrange/zrevrange start stop [withscores]
# 返回最低/最高 start至stop的成员，withscores 则带分数
127.0.0.1:6379> zrange score:math 0 2
1) "can"
2) "zhou"
3) "sun"
127.0.0.1:6379> zrevrange score:math 0 2 withscores
1) "sun"
2) "201"
3) "zhou"
4) "100"
5) "can"
6) "99"

ZRANGEBYSCORE/ZREVRANGEBYSCORE

# zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
# zrevrangebyscore key max min [WITHSCORES] [LIMIT offset count]
# 同时min，max支持开区间 (0 +inf (100 -inf ;+inf,-inf 表示正无穷，负无穷
# offset表示起始范围，count 表示个数
# 返回指定分数范围指定个数成员

127.0.0.1:6379> zrevrangebyscore score:math 300 100
1) "sun"
2) "zhou"
127.0.0.1:6379> zrevrangebyscore score:math 300 100 LIMIT 1 1
1) "zhou"

ZCOUNT

# zcount key min max
# 返回指定分数范围个数
127.0.0.1:6379> zcount score:math 100 300
(integer) 2

ZREMRANGEBYRANK

# zremrangebyrank key start stop 
# 删除指定排名的升序元素
127.0.0.1:6379> zremrangebyrank score:math 0 1
(integer) 2

ZREMRANGEBYSCORE

# zremrangebyscore key min max
# 删除指定分数范围的成员
127.0.0.1:6379> zremrangebyscore score:math 0 100
(integer) 0

ZINTERSTORE

# zinterstore destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
# numkeys 需要做交集键的个数
# WEIGHTS 权重
# AGGREGATE SUM求和，MIN最小值，MAX最大值
# 多个有序集合的交集,权重默认为1,默认求和

127.0.0.1:6379> zadd class:1 99 sun 100 can 80 han
(integer) 3
127.0.0.1:6379> 
127.0.0.1:6379> zadd class:2 60 sun 100 wang 60 liu
(integer) 3
127.0.0.1:6379> zinterstore both:sun 2  class:1 class:2 
(integer) 1

ZUNIONSTORE

# zunionstore destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
# 多个有序集合取并集
127.0.0.1:6379> zunionstore union:class 2 class:1 class:2
(integer) 5
127.0.0.1:6379> zrange union:class 0 4 WITHSCORES
 1) "liu"
 2) "60"
 3) "han"
 4) "80"
 5) "can"
 6) "100"
 7) "wang"
 8) "100"
 9) "sun"
10) "159"

ZSCAN

# zscan key cursor [MATCH pattern] [COUNT count]
127.0.0.1:6379> zscan union:class 0
1) "0"
2)  1) "liu"
    2) "60"
    3) "han"
    4) "80"
    5) "can"
    6) "100"
    7) "wang"
    8) "100"
    9) "sun"
   10) "159"

数据结构总结

API数据结构	底层实现数据结构
string	int/embstr/raw
hash	ziplist/hashtable
list	ziplist/linkedlist -> quicklist
set	intset/hashtable
zset	ziplist/skiplist

集群命令Cluster

CLUSTER NODES

# cluster nodes
# 查看当前集群节点信息
127.0.0.1:6380> cluster nodes
221a3a8274207c6b5f411a93226128f7576862a9 127.0.0.1:6381@16381 master - 0 1555940019000 3 connected 10923-16383
61aae14d19268dfd7377f8c84cdb0d8c78cf0f1a 127.0.0.1:6379@16379 slave 5bb8e82e961410b3376349a0a8ee99b9a6d957d4 0 1555940017741 8 connected
5bb8e82e961410b3376349a0a8ee99b9a6d957d4 127.0.0.1:6382@16382 master - 0 1555940019745 8 connected 0-5460
cdd58697e7c9da0866e1f259e437a5b3d1a01ea1 127.0.0.1:6383@16383 master - 0 1555940020748 9 connected 5461-10922
2083a3428b1ab293ec62ff83f4e45a1c5d7b63a5 127.0.0.1:6380@16380 myself,slave cdd58697e7c9da0866e1f259e437a5b3d1a01ea1 0 1555940020000 0 connected
99ac3746742730dfe82942d72ceb6e455f5d5545 127.0.0.1:6384@16384 slave 221a3a8274207c6b5f411a93226128f7576862a9 0 1555940018000 3 connected

CLUSTER INFO

# cluster info
# 查看集群状态，slots状态
127.0.0.1:6380> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:9
cluster_my_epoch:9
cluster_stats_messages_ping_sent:205
cluster_stats_messages_pong_sent:227
cluster_stats_messages_meet_sent:4
cluster_stats_messages_sent:436
cluster_stats_messages_ping_received:225
cluster_stats_messages_pong_received:209
cluster_stats_messages_meet_received:2
cluster_stats_messages_received:436

CLUSTER ADDSLOTS

# cluster addslots {0...5461}
# 给当前节点分配槽位 时间复杂度O(n) n为槽位数

CLUSTER DELSLOTS

# cluster delslots {0...5461}
# 给当前节点删除部分槽位 时间复杂度O(n) n为槽位数

CLUSTER SLOTS

# cluster slots 
# 槽位信息 时间复杂度O(n) n为cluster nodes

CLUSTER KEYSLOT

# cluster keyslot <key>
# 用于校验指定key 位于哪个槽位，返回一个int值
127.0.0.1:6383> cluster keyslot sunce
(integer) 12148

CLUSTER COUNTKEYSINSLOT

# cluster countkeysinslot <slot>
# 统计某个槽位的keys数量
127.0.0.1:6383> cluster countkeysinslot 5460
(integer) 0

CLUSTER GETKEYSINSLOT

# cluster getkeysinslot <slot> <count>
# 统计某个槽位的全部keys
127.0.0.1:6383> cluster GETKEYSINSLOT 6918 100
1) "test"

CLUSTER SETSLOT

# 利用此命令重新分片，参考官方文档，假设操作节点为源节点
# 1.使用命令CLUSTER SETSLOT <slot> IMPORTING <source-node-id> 将目的节点槽置为importing状态。

# 2.使用命令CLUSTER SETSLOT <slot> MIGRATING <destination-node-id> 将源节点槽置为migrating状态。

# 3.使用命令CLUSTER GETKEYSINSLOT 从源节点获取所有keys，并使用命令MIGRATE 将它们导入到目的节点。

# 4.在源节点活目的节点执行命令CLUSTER SETSLOT <slot> NODE <destination-node-id>

CLUSTER MEET

# cluster meet 127.0.0.1 6380
# 让其他节点加入集群 时间复杂度 O(1)

CLUSTER REPLICATE

# cluster replicate <node-id>
# 用于指定当前节点成为 node-id 节点的slave

CLUSTER FORGET

# cluster forget <node-id>
# 用于集群伸缩时，某个主节点槽位已移除完毕，当集群中还包含该节点信息，可以通过此命令移除
# node-id 以下情况不会执行成功：node为slave，在自身节点删除，删除节点不存在

CLUSTER FAILOVER

# 时间复杂度O(1)
# cluster failover 此命令只能在slave节点执行，
# cluster failover master未宕机，与当前主节点确认的故障转移
# cluster failover force ,master宕机，强制执行，会与其他master进行一致性校验
# cluster failover takeover ,master宕机，强制执行，忽略一致性校验

基础命令&全局命令

PING

# 发送PING
127.0.0.1:6379> ping
PONG

MOVE

# move <key> <db>
# 将key移动到指定db

MIGRATE

# migrate host port key| destination-db timeout [COPY] [REPLACE] [KEYS key]
# 用于key在实例间迁移,timeout表示数据拷贝时间，copy 保留原key,replace 目标实例key存在则替换
# migrate 127.0.0.1 6380 100000 copy hello test
# migrate 127.0.0.1 6380 100000 copy hello test

QUIT

# 客户端断开
127.0.0.1:6379> quit
[root@VM_0_16_centos ~]#

FLUSHDB 生产禁用

# 清空当前库

FLUSHALL 生产禁用

# 清空全部库

DBSIZE

# 查看键大小，返回数据库中键的数量，时间复杂度O(1)
127.0.0.1:6379> dbsize
(integer) 2

SELECT

# select dbindex
# 选择库
127.0.0.1:6379> select 0
OK

AUTH

# auth <password>
# 设置密码时用于认证
127.0.0.1:6379> auth 1234qwer

SAVE/BGAVE 不建议使用

# 主动保存内存快照RDB文件
# SAVE 主进程中保存，数据量大会阻塞
# BGSAVE fork子进程，在子进程中保存

BGREWRITEAOF 不建议使用

# 后台重写AOF文件
# bgrewriteaof

SHUTDOWN

# 停止当前实例
# shutdown save | bgsave

SLAVEOF

# 当前节点成为host+port的slave节点
# slaveof <host> <port>
# slaveof no one 不作为slave节点

OBJECT

# object refcount <key> 返回key对应value引用的次数
# object encoding <key> 返回key对应value的内部实现
# object ideltime <key> 返回key被存储之后的空闲时间

DEBUG

# debug object <key> 用于调试，返回key的具体信息

DEBUG SEGFAULT 生产禁用

# DEBUG SEGFAULT
# 用于模拟服务不可用

INFO

# 返回Redis服务的信息以及计数
# info server 返回服务端信息
# info clients 返回客户端信息
# info memory 返回内存消耗信息
# info persistence 返回RDB，AOF持久化信息
# info stats 一般统计
# info replication 主从复制信息
# info cpu 返回CPU信息
# info commandstats 命令统计
# info keyspace 数据库相关信息
# info cluster 集群信息

KEYS

# 查看所有键（生产禁用），返回数据库中所有的键，时间复杂度O(n)
127.0.0.1:6379> set test sun
OK
127.0.0.1:6379> set hello ce
OK
127.0.0.1:6379> keys *
1) "test"
2) "hello"

EXISTS

# exists key..
# 检查键是否存在，支持批量，单个存在返回1，不存在返回0
# 时间复杂度 O(k) k为key的个数
127.0.0.1:6379> exists test hello
(integer) 2
127.0.0.1:6379> exists test 
(integer) 1
127.0.0.1:6379> exists who
(integer) 0

DEL

# del key..
# 删除键,支持批量，单个存在返回1，不存在返回0
# 时间复杂度 O(k) k为key的个数
127.0.0.1:6379> del test hello
(integer) 2
127.0.0.1:6379> del who
(integer) 0

EXPIRE

# expire key second
# 支持键设置过期 second 小于0 ，作用类似于del
# ttl key
# 返回剩余过期时间，大于0表示剩余时间，-1表示不过期，-2表示已过期或不存在
127.0.0.1:6379> set test sun 
OK
127.0.0.1:6379> expire test 10
(integer) 1
127.0.0.1:6379> ttl test
(integer) 6

TYPE

# type key
# 键的数据结构类型，返回数据结构类型,不存在返回none 

127.0.0.1:6379> set hello ce
OK
127.0.0.1:6379> type hello
string
127.0.0.1:6379> type test
none

CONFIG

# config get params
# 获取某个redis配置或者全部配置，设置某些配置
127.0.0.1:6379> CONFIG SET loglevel debug
OK
127.0.0.1:6379> CONFIG GET loglevel 
1) "loglevel"
2) "debug"
127.0.0.1:6379> CONFIG GET *
  1) "dbfilename"
  2) "dump.rdb"
  3) "requirepass"
  4) ""
  5) "masterauth"
  6) ""
  7) "cluster-announce-ip"
  8) ""
  9) "unixsocket"
 10) ""
 11) "logfile"
 12) "redis.log"
 ...

RENAME

# rename key newkey
# 重命名,rename之前newkey已存在也将被覆盖
127.0.0.1:6379> set xingshi sun
OK
127.0.0.1:6379> rename xingshi xing
OK
127.0.0.1:6379> get xingshi
(nil)

RANDOMKEY

# randomkey
# 随机返回一个键
127.0.0.1:6379> randomkey
"hello"

注意以上并非全部Redis命令，而是我们常用的命令，想了解全部相关命令，可以移步Redis命令API