redis的list、set、hash的常用语法

list：：数据结构为quicklist，首先列表中数据比较少时会使用一块连续的内存存储，这个结构是ziplist，也即是压缩链表，他将所有的元素紧挨着一起存储，分配的是一块的内存，当数据量比较多时才改成quiclist，

即双向链表，将很多个ziplist双向链接。

虽然lists有这样的优势，但同样有其弊端，那就是，链表型lists的元素定位会比较慢，而数组型lists的元素定位就会快得多。

lpush/rpush key values //从左或从右插入一个或者多个值

lpop/rpop key //从左边或者右边吐出值，键也消失

rpoplpush//右吐出的左加入

llen key//长度

lrange key <start><end>//取值 <0><-1>取所有的值

lindix key index //按照索引下标获得元素

linsert key before value newvalue //在value后面加newvalue

lrem key n value //从左边删除n个value

lset key index value //将列表key下标为index的值替换value

set：

字典，哈希结构

sadd key v1 v2 ...//将一个或者多个member元素加入集合key中，重复的将被忽略

srem key v1 v2....//删除元素

smembers key//取出该集合所有的值

scard key//返回集合个数（长度)

sismember key value //判断集合key是否有该value值，有1，无0

spop key//随机吐出一个值

srandmember key n//随机从集合中取出n个值，不会从集合中删除

smove k1 k2 value//将set k1中的值移动到k2中

sinter k1 k2//交集

sunion k1 k2//并集

sunionstore key key1 key2//得到key1,key2并集结果放在key中

sdiff k1 k2//差集

sdiffstore k k1 k2//求k1，k2的差集放在k中(k1中有，且不在k2中的值)

redis hash ：键值对集合，是一个string类型的field和value的映射表，hash特别适用于存储对象

key	value
user	（field） （value）
	id 1
	name 张三
	age 20

hset key:field value//给key集合中的field键赋值value ,hset k5:f1 id 1
												:hset k5:f1 name zhang
field=f1 id

hsetnx  key:field value//当field不存在时才能存

hget key:field //得到一个，hget k5:f1 id

hmset ket:field id 1 name zhang age 23//设置多个值

hkeys key:field//输出所有field

hvals key：field //所有的值

hicrby key:field [n]//加n

hexist key:field//是否存在

有序列表zset:

1，hash

2，跳跃表

zadd key s1 name1 s2 name2...//将一个或多个member元素及其score值加入到有序集key当中，根据score默认从小到大排序

zrange key start end//0 -1输出全部的，按score排序

zrangebyscore key min max//score从min到max的name

zrangebyscore key min max withscore//带值

zrevrangebyscore key max min (withscore)//从大到小排序

zincrby key n name//增加score的n的值

zrem key name//删除

zcount key min max//统计该区间的个数

zrank key name//返回排名

Redis中有一个经典的问题，在巨大的数据量的情况下，做类似于查找符合某种规则的Key的信息，这里就有两种方式：

一、keys * 、keys codehole* 分别是查询全部的key以及查询前缀为codehole的key。特点太暴力，性能不好，搜索的是整个redis；

缺点：

1、没有 offset、limit 参数，一次性吐出所有满足条件的 key，万一实例中有几百 w 个 key 满足条件，当你看到满屏的字符串刷的没有尽头时，你就知道难受了。

2、keys 算法是遍历算法，复杂度是 O(n)，如果实例中有千万级以上的 key，这个指令就会导致 Redis 服务卡顿，所有读写 Redis 的其它的指令都会被延后甚至会超时报错，因为 Redis 是单线程程序，顺序执行所有指令，其它指令必须等到当前的 keys 指令执行完了才可以继续。

二、由于keys命令存在以上的缺点，所以redis引入以下scan命令，scan命令的特点：

1、复杂度虽然也是 O(n)，但是它是通过游标分步进行的，不会阻塞线程;

2、提供 limit 参数，可以控制每次返回结果的最大条数，limit 只是一个 hint，返回的结果可多可少;

3、同 keys 一样，它也提供模式匹配功能;

4、服务器不需要为游标保存状态，游标的唯一状态就是 scan 返回给客户端的游标整数;

5、返回的结果可能会有重复，需要客户端去重复，这点非常重要;

6、遍历的过程中如果有数据修改，改动后的数据能不能遍历到是不确定的;

7、单次返回的结果是空的并不意味着遍历结束，而要看返回的游标值是否为零三、

scan命令具体用法：

1、scan提供3个参数：第一个是 cursor 整数值，第二个是 key 的正则模式，第三个是遍历的 limit hint，

例如：scan 0 match key99* count 1000 解释：

扫描是一个光标基于迭代器。这意味着在每次调用命令时，服务器都会返回一个更新的游标，用户需要在下次调用中将其用作游标参数。

当游标设置为 0 时，迭代开始，当服务器返回的游标为 0 时，迭代终止。

redis 127.0.0.1:6379> scan 0
1) "17"
2)  1) "key:12"
    2) "key:8"
    3) "key:4"
    4) "key:14"
    5) "key:16"
    6) "key:17"
    7) "key:15"
    8) "key:10"
    9) "key:3"
   10) "key:7"
   11) "key:1"
redis 127.0.0.1:6379> scan 17
1) "0"
2) 1) "key:5"
   2) "key:18"
   3) "key:0"
   4) "key:2"
   5) "key:19"
   6) "key:13"
   7) "key:6"
   8) "key:9"
   9) "key:11"

redis 127.0.0.1:6379> sadd myset 1 2 3 foo foobar feelsgood
(integer) 6
redis 127.0.0.1:6379> sscan myset 0 match f*
1) "0"
2) 1) "foo"
   2) "feelsgood"
   3) "foobar"
redis 127.0.0.1:6379>

请务必注意，MATCH 筛选器是在从集合中检索元素后，即在将数据返回给客户端之前应用的。这意味着，如果模式与集合中的元素匹配非常少，则在大多数迭代中可能不会返回任何元素。示例如下所示：

redis 127.0.0.1:6379> scan 0 MATCH *11*
1) "288"
2) 1) "key:911"
redis 127.0.0.1:6379> scan 288 MATCH *11*
1) "224"
2) (empty list or set)
redis 127.0.0.1:6379> scan 224 MATCH *11*
1) "80"
2) (empty list or set)
redis 127.0.0.1:6379> scan 80 MATCH *11*
1) "176"
2) (empty list or set)
redis 127.0.0.1:6379> scan 176 MATCH *11* COUNT 1000
1) "0"
2)  1) "key:611"
    2) "key:711"
    3) "key:118"
    4) "key:117"
    5) "key:311"
    6) "key:112"
    7) "key:111"
    8) "key:110"
    9) "key:113"
   10) "key:211"
   11) "key:411"
   12) "key:115"
   13) "key:116"
   14) "key:114"
   15) "key:119"
   16) "key:811"
   17) "key:511"
   18) "key:11"
redis 127.0.0.1:6379>

如您所见，大多数调用返回了零个元素，但最后一个调用使用 COUNT 为 1000，以强制命令对该迭代执行更多扫描。

3、redis的扩容：

旧的数据移动到新的新组下，redis采用渐进式 rehash,同时保留旧数组和新数组
ey:114"
15) “key:119”
16) “key:811”
17) “key:511”
18) “key:11”
redis 127.0.0.1:6379>

如您所见，大多数调用返回了零个元素，但最后一个调用使用 COUNT 为 1000，以强制命令对该迭代执行更多扫描。



3、redis的扩容：

旧的数据移动到新的新组下，redis采用渐进式 **rehash**,同时保留旧数组和新数组