Redis篇 - 2. redis 数据结构与命令

1、redis 支持如下5种数据结构

数据结构	说明	简介
String	字符串	key-val
Hash	哈希	filed-val 映射表
List	列表	双向链表
Set	集合	element(元素无重复)
Sorted Set	有序集合	element+score(元素无重复+分值)

2、通用命令

命令	作用	时间复杂度
keys pattern	查找所有符合匹配的key	O(n)
dbsize	返回当前数据库的数量	O(1)
flushdb	清空当前数据库所有key	O(n)
flushall	清空所有数据库所有key	O(n)
type key	返回key的数据类型	O(1)
rename key new_key	修改key名称	O(1)
exists key	检查给定key是否存在	O(1)
del key	删除key	O(1)
expire key seconds	给key设定过期时间	O(1)
ttl key	查看key剩余过期时间	O(1)
persist key	移除key剩余过期时间	O(1)

3、String

命令	作用	时间复杂度
set key val	设置key val	O(1)
get key	获取key	O(1)
del key	删除key	O(1)
set key val xx	更新key(不存在key时更新失败)	O(1)
setnx key val	key不存在时设置key	O(1)
setex key val seconnds	设置key并设置过期时间	O(1)
mset key1 val1 key2 val2 ...	批量设置key	O(n)
mget key1 key2 ...	批量获取key	O(n)
incr key val	key自增1;key不存在,set key val后自增1	O(1)
decr key val	key自减1;key不存在,set key val后自减1	O(1)
incrby key n	key自增k;key不存在,set key val后自增k	O(1)
decrby key n	key自减k;key不存在,set key val后自减k	O(1)
getset key val	set key val并返回旧的值	O(1)
append key val	给key追加值val	O(1)
strlen key	获取key长度	O(1)
incrbyfloat key f	给key增加小数	O(1)
setrange key offset val	用val从offset开始覆盖	O(1)
getrange key start end	获取指定区间的val	O(1)

4、Hash

命令	作用	时间复杂度
hset key filed val	设置key filed val	O(1)
hget key filed	获取key filed	O(1)
hdel key filed	删除key filed	O(1)
hexists key filed	检测key filed是否存在	O(1)
hlen key	获取key属性值个数	O(1)
hsetnx key filed	key filed不存在时设置key filed	O(1)
hincrby key filed n	key filed自增/自减(n可以为负数)	O(1)
hincrbyfloat key filed f	key filed自增/自减(f可以为负数)	O(1)
hmset key filed1 val1 filed2 val2 ...	批量设置key filed	O(n)
hmget key filed1 filed2 ...	批量获取key filed	O(n)
hgetall key	获取key所有filed值	O(n)
hgetkeys key	获取key所有filed key	O(n)
hgetvals key	获取key所有filed val	O(n)

5、List

命令	作用	时间复杂度
lpush key val1 val2 ...	从头部插入一个/多个val	O(1~n)
lpop key	移除并返回头部第一个元素	O(1)
rpush key val1 val2 ...	从尾部插入一个/多个val	O(1~n)
rpop key	移除并返回尾部第一个元素	O(1)
lrang key start end	返回指定区间元素	O(s+n) s为偏移量, n=e-s
ltrim key start stop	对列表进行修剪, 保留指定区间的元素	O(n)
llen key	获取key长度	O(1)
lset key index val	设置指定索引index val	O(1~n)
linsert key before/after existing_val new_val	在指定存在值之前/之后插入元素	O(n)
lindex key position	获取指定position元素	O(1~n)
lrem key count val	移除与count相等的val	O(n)
lpushx key val1 val2 ...	从头部插入一个/多个已存在列表的val	O(1~n)
rpushx key val1 val2 ...	从尾部插入一个/多个已存在列表的val	O(1~n)
blpop key seconds	阻塞式lpop	O(1)
brpop key seconds	阻塞式rpop	O(1)

• 常见场景

场景	命令方法
栈(Stack)	lpush + lpop
队列(Queue)	lpush + rpop
固定列表(Capped Collection)	lpush + ltrim
消息列表(Message Queue)	lpush + brpop

6、集合

命令	作用	时间复杂度
sadd key val1 val2 ...	向集合添加一个/多个元素(已存在元素则忽略)	O(n)
smembers key	获取所有集合元素	O(n)
sismember key val1	检测集合元素是否存在	O(1)
srandmember key {count}	随机获取指定个数集合元素(不会删除)	O(1~n)
spop key	随机移除一个集合元素并返回(会删除)	O(1)
srem key val val1 ...	删除集合元素	O(1~n)
smove key key1 val	将key集合中val移到key1集合	O(1)
scard key	获取集合数量	O(1)
sinter key key1 ...	获取集合交集	O(n)
sunion key key1 ...	获取集合并集	O(n)
sdiff key key1 ...	获取集合差集	O(n)
sinterstore new_key key key1 ...	获取集合交集并存储到新集合	O(n)
sunionstore new_key key key1 ...	获取集合并集并存储到新集合	O(n)
sdiffstore new_key key key1 ...	获取集合差集并存储到新集合	O(n)

7、有序集合

命令	作用	时间复杂度
zadd key score val ...	向集合添加一个/多个元素	O(log(N) * M) M 元素个数
zcard key	获取集合数量	O(1)
zscore key val	获取元素分数值	O(1)
zcount key mix max	获取分数区间[mix, max]集合元素数量	O(log(N) + M)
zlexcount key mix max	获取元素字典区间[mix, max]集合元素数量	O(log(N) + M)
zincrby key score val	集合元素val自增/自减分数score	O(log(N))
zrank key val	获取集合元素val的排名(从小到大)	O(log(N))
zrevrank key val	获取集合元素val的排名(从大到小)	O(log(N))
zrange key start end [withscores]	获取指定区间分数排名(从小到大)元素	O(log(N) + M)
zrevrange key start end [withscores]	获取指定区间分数排名(从大到小)元素	O(log(N) + M)
zrangebyscore key min max [withscores]	获取指定区间分数排名(从小到大)元素	O(log(N) + M)
zrevrangebyscore key max min [withscores]	获取指定区间分数排名(从大到小)元素	O(log(N) + M)
zrangebylex key min max	获取字典区间内集合元素	O(log(N) + M)
zrem key val val1 ...	删除集合元素	O(log(N) * M)
zremrangebyscore key min max	删除指定区间分数区间元素	O(log(N) + M)
zremrangebyrank key start stop	删除指定排名rank内元素	O(log(N) + M)
zremrangebylex key min max	删除字典区间内集合元素	O(log(N) * M)
zinterstore new_key n key key1 ...	获取集合交集存储到new_key(n 集合个数)	O(N K)+O(M log(M))
zunionstore new_key n key key1 ...	获取集合并集存储到new_key(n 集合个数)	O(N)+O(M log(M))

PS: 更多文章请关注微信公众号：浮话