目录
▪️ 递增(减)指定浮点数 INCRBYFLOAT、DECRBYFLOAT
▪️（单个、批量、全部）获取散列中的键值对 HGET、HGETALL
▪️ 当字段不存在时赋值 HSETNX（NX代表not exists）
▪️ 增加(减少)整数、浮点数 HINCRBY、HINCRBYFLOAT
▪️ 获取列表中的元素个数，获取列表片段 LLEN 、LRANGE
▪️ 获得、设置指定index处的值 LINDEX、LSET
▪️ 增加、删除元素 、获取集合中所有元素 SADD、SREM 、SMEMBERS
▪️ 集合间的运算(差集、交集、并集) SDIFF、SINTER、SUNION
▪️ 进行集合间的运算(差集、交集、并集)并将返回结果存储在新集合中 SDIFFSTORE、SINTERSTORE、SUNIONSTORE
▪️ 获取分数在某个范围的元素列表 ZRANGEBYSCORE
注意事项：
1、命令的大小写可以不区分，但是后面的参数和值是需要区分大小写的
Redis基础命令
▪️查看所有键 KEYS ：
1）语法：KEYS pattern
2）语意：查找当前数据库中符合pattern通配符的所有键
3）要点：pattern可以为：
1、? 匹配一个字符
2、* 匹配任意个字符(包括0个)
3、[] 匹配括号间的任一字符，可以用"-"符号表示一个范围，如a[b-d]可以匹配"ab","ac","ad"
4、\x 匹配字符x，用于转义符号。如要匹配? 就需要用\?
一、字符串类型
1、存储形式：key:value
2、一个字符串类型的键允许存储的数据最大容量为512MB
3、它可存储的value可为任何形式的字符串类型包括二进制的数据。
4、可以把json格式的字符串序列化后，存入字符串类型的，这样一定程度上解决了redis无法存储复杂结构的数据
▪️ 赋值 SET ：
1）语法：SET key vaue
2）语意：设置一个键为key，值为value的字符串类型键值对
//设置一个key为name，value为lyh的字符串类型键值对，成功则返回OK 127.0.0.1:6379> SET name lyh OK
▪️ 获取 GET:
1）语法：GET key
2）语意：获取指定字符串类型key的value
//分别获取key为name和key为Name的value，若key存在则返回对应value，反则返回空(命令是不区分大小写的，但是后面的key，value是区分的) 127.0.0.1:6379> GET name "lyh" 127.0.0.1:6379> GET Name (nil)
▪️ 递增(减) 1 INC、DECR：
1）语法：INCR key 、DECR key
2）语意：使指定字符串类型key的value增加(减少)1
3）要点：
1、若key不存在时，则会先创建这个key，然后初始值为0，再加(减)1。
2、当key存在时，但是value为非整数类型时，会报错
3、该操作是原子性的
//以INCR为例： //当key不存在时使用INCR命令 127.0.0.1:6379> GET age //此时没有设置age键，所以获取到是空 (nil) 127.0.0.1:6379> INCR age //使用INCR命令使age键的值自增1，返回值是自增后的值 (integer) 1 //当key存在时，且值为整数类型时，使用INCR命令 127.0.0.1:6379> INCR age //执行之前，age的值为1，执行后age的值自增1，变成2 (integer) 2 //当key存在时，且值为字符类型时，使用INCR命令 127.0.0.1:6379> GET name //键name是存在的，值为value，值是字符串类型 "lyh" 127.0.0.1:6379> INCR name //使用INCR命令使name键的值自增1，报错了 (error) ERR value is not an integer or out of range //当key存在时，且值为浮点类型时，使用INCR命令 127.0.0.1:6379> SET height 180.1 //设置一个height的key，value为浮点数的值 OK 127.0.0.1:6379> INCR height //使用INCR命令也报错了 (error) ERR value is not an integer or out of range
▪️ 递增(减)指定整数 INCRBY 、DECRBY：
1）语法：INCRBY key 整数、DECRBY key 整数
2）语意：使指定字符串类型key的value增加(减少)指定整数
3）要点：同INCR、DECR
//以INCRBY为例 127.0.0.1:6379> SET age 1 //先设置一个字符串类型，key为age，value为1 OK 127.0.0.1:6379> GET age "1" 127.0.0.1:6379> INCRBY age 2 //用INCRBY命令使字符串类型的key age增加整数2，成功返回递增后的数值3 (integer) 3 127.0.0.1:6379> INCRBY age 2.5 //使用INCRBY命令使age递增浮点数2.5，报错 (error) ERR value is not an integer or out of range 127.0.0.1:6379> GET weight //key为weight不存在 (nil) 127.0.0.1:6379> INCRBY weight 140 //为不存在的key weight递增整数140，先创建了weight，初始值为0后再增加140 (integer) 140
▪️ 递增(减)指定浮点数 INCRBYFLOAT、DECRBYFLOAT：
1）语法：INCRBYFLOAT key 浮点数、DECRBYFLOAT key 浮点数
2）语意：使指定字符串类型的key的value增加(减少)指定浮点数
3）要点：指定增加的数值可以为双精度浮点数，且执行之前value为整型，递增一个浮点数后，value的类型变为浮点数
//以INCRBYFLOAT为例： 127.0.0.1:6379> GET age //此时age为整型数值 "2" 127.0.0.1:6379> INCRBYFLOAT age 1.1 //用INCRBYFLOAT执行后，value变为浮点数 "3.1" 127.0.0.1:6379> INCRBYFLOAT age 1 //用INCRBYFLOAT为value递增的数值也可以是整数 "4.1" 127.0.0.1:6379> SET age 2 OK 127.0.0.1:6379> INCRBYFLOAT age 1 "3"
▪️ 向尾部增加值 APPEN：
1）语法：APPEND key value
2）语意：向指定字符串类型key的value追加值
3） 要点：若key不存在时，会先创建key，再赋值value，相当于执行了一次SET key value操作
127.0.0.1:6379> SET name l //设置字符串类型键值对，key为name，value为l OK 127.0.0.1:6379> GET name "l" 127.0.0.1:6379> APPEND name yh //为字符串类型key为name的value追加yh (integer) 3 127.0.0.1:6379> GET name //name:l+yh "lyh" 127.0.0.1:6379> GET girlFriend //当key不存在时 (nil) 127.0.0.1:6379> APPEND girlFriend cxg //执行APPEND命令，使不存在的key追加value为cxg (integer) 3 127.0.0.1:6379> GET girlFriend //执行成功，girlFriend:cxg "cxg"
▪️ 获取字符串长度 STRLEN：
1）语法：STRLEN key
2）语意：获取指定字符串类型的value的长度
3）要点：中文是按UTF-8编码后获取的长度，所以获取value长度为"你好"的结果不是2
127.0.0.1:6379> GET test //获取key=test的value，redis接收到的中文为UTD-8编码, "\xe4\xbd\xa0\xe5\xa5\xbd" 127.0.0.1:6379> STRLEN test //获取UTF-8编码的字符长度为6 (integer) 6 127.0.0.1:6379> GET name //获取key=name的value "lyh" 127.0.0.1:6379> STRLEN name //结果正是我们肉眼看到的3 (integer) 3
▪️ 同时获得/设置多个键值 MSET、MGET：
1）语法：MSET key1 value1 key2 value2 ...... 、 MGET key1 key2 key3 ..........
2）语意：批量设置字符串类型键值对:key1:value1 ，key2:value2 、 批量获取指定key：key1,key2,key3
127.0.0.1:6379> MSET name lyh height 180 weight 150 //批量设置name:lyh，height:180，weight:150 OK 127.0.0.1:6379> MGET name height weight //批量获取字符串类型key分别为name、height、weight的值 1) "lyh" 2) "180" 3) "150"
二、散列类型
1、散列类型在数据库中存储的形式：key ：{field1:value1,field2:value2}，value只能为字符串类型，不能是更复杂的结构(例如列表)
2、一个散列表类型的键可以包含最多2的32次方-1个字符串的值
▪️ 赋值 HSET、HMSET ：
1）语法：HSET key field value、HMSET key field1 value1 field2 value2 ..........
2）语意：(批量)设置散列表对应的key，和其中包含的字段和值
3）要点：
1.如果给定的散列表并不存在， 那么一个新的散列表将被创建并执行 HSET（HMSET） 操作。
2.如果域 field 已经存在于散列表中， 那么它的旧值将被新值 value 覆盖。
3.HSET命令如果理解为表的话，那么key就相当于主键，field就相当于字段，一次命令只能创建
127.0.0.1:6379> HSET myInf name lyh age 20 //设置散列的key=myInf，散列表中的键值对有name = lyh、age = 20，返回值为2,表示成功插入2个field:value,更新field:value 0个 (integer) 2 127.0.0.1:6379> HSET myInf name lyh2 age 21 //返回值为0，表示这些field都存在，插入了0个，操作的两个field（name，age）都是对其进行了更新 (integer) 0 127.0.0.1:6379> HSET myInf weight 150 height 180 girlFriend cxg //这两个key是没有的，所以返回值是2 (integer) 2 127.0.0.1:6379> HMSET myInf weight 150 height 180 //同HSET，一般来说HSET一次命令只能设置一对field:value，而HMSET可以一次性设置多个field:value(.....不知道为啥我下的版本HSET可以一次性设置多个field:value) OK
▪️（单个、批量、全部）获取散列中的键值对 HGET、HGETALL：
1）语法：HGET key field 、HMGET key field1 field2 field3 ..... 、HGETALL key
2）语意：获取指定散列类型key的field字段的值，获取指定散列类型key的field1、field2、field3..的值、获取指定key中所有的field:value
3）要点：若获取的field不存在，则对应field的value返回为空
127.0.0.1:6379> HGET myInf name //获取key为myInf的name字段的值 "lyh" 127.0.0.1:6379> HMGET myInf name weight height //获取key为myInf的name、weight、height的值 1) "lyh" 2) "150" 3) "180" 127.0.0.1:6379> HMGET myInf name weight height a //由于a不存在myInf的field域中，所以返回空 1) "lyh" 2) "150" 3) "180" 4) (nil) 127.0.0.1:6379> HGETALL myInf //获取key为myInf的所有field:value，name:lyh,age:20... 1) "name" 2) "lyh" 3) "age" 4) "20" 5) "weight" 6) "150" 7) "height" 8) "180" 127.0.0.1:6379> HGETALL myInf2 //由于key为myInf2的散列表不存在，所以返回空array (empty array)
▪️ 判断散列类型的字段是否存在 HEXISTS：
1）语法：HEXISTS key field
2）语意：判断指定key的散列表中field是否存在
3）要点：不存在key或者是不存在field都是返回0
127.0.0.1:6379> HEXISTS myInf name //判断key=myInf的散列表的name这个字段是否存在，存在返回1 (integer) 1 127.0.0.1:6379> HEXISTS myInf aaa //不存在aaa字段返回0 (integer) 0 127.0.0.1:6379> HEXISTS myInf1 name //不存在myInf1这个key也是返回0 (integer) 0
▪️ 当字段不存在时赋值 HSETNX（NX代表not exists）：
1）语法：HSETNX key field value
2）语意：判断指定key的散列表是否存在field字段，不存在则创建这个字段并赋值为value
3）要点：操作是原子性的，不用考虑竞态条件
127.0.0.1:6379> HGET myInf name //name这个字段是存在的，value为lyh "lyh" 127.0.0.1:6379> HSETNX myInf name lyh2 //用HSETNX设置name = lyh2，因为name字段已经存在，所以修改失败，返回0 (integer) 0 127.0.0.1:6379> HGET myInf city //city这个字段不存在 (nil) 127.0.0.1:6379> HSETNX myInf city GuiYang //用HSETNX设置city = GuiYang，成功了，返回1 (integer) 1 127.0.0.1:6379> HGET myInf city //这个字段和其对应值已经被加入到该散列表中 "GuiYang"
▪️ 增加(减少)整数、浮点数 HINCRBY、HINCRBYFLOAT：
1）语法：HINCRBY key field (正负)整数、HINCRBYFLOAT key field (正负)浮点数
2）语意：给指定散列表的指定field的value增加/减少 (正、负)整数、浮点数
3）要点：
1、HINCRBY、HINCRBYFLOAT就可以执行整数、浮点数递增递减的操作，和字符串类型不同。
2、不仅操作的field不存在的情况下他会先创建这个field，就连key不存在的情况，他也会先创建指定key的散列表，然后再创建对应field，在进行递增递减的操作
127.0.0.1:6379> HGET myInf weight //获取key=myInf的散列表field=weight的值，存在这个field，value = 150 "150" 127.0.0.1:6379> HINCRBY myInf weight 1 //用HINCRBY命令使这个field + 1，返回值为增加后的数字 (integer) 151 127.0.0.1:6379> HINCRBY myInf weight -1 //用HINCRBY命令使其-1，返回值是减少后的数字 (integer) 150 127.0.0.1:6379> HINCRBY myInf weight2 1 //用HINCRBY命令操作一个不存在的field，先创建了这个field，然后使其初始值为0后再递增1 (integer) 1 127.0.0.1:6379> HINCRBYFLOAT myInf weight 1.1 //用HINCRBYFLOAT命令使weight这个字段+1.1 "151.10000000000000001" 127.0.0.1:6379> HINCRBYFLOAT myInf weight -1.1 //用HINCRBYFLOAT命令使其-1.1 "150"
▪️ 删除字段 HDEL：
1）语法：HDEL key field field2 field3 ...
2）语意：删除指定散列表的field和其对应value
3）要点：返回值是删除成功的个数，并不可以单纯理解为删除成功就返回1，删除失败就返回0，因为当一次性删除多个字段时，返回值就不止1和0了
127.0.0.1:6379> HDEL myInf weight2 //删除weight2这个field和其对应value，删除成功返回删除成功的个数 (integer) 1 127.0.0.1:6379> HDEL myInf weight2 //因为该field不存在，所以删除的个数为0 (integer) 0
三、列表类型
1、存储形式：key:[value1, value2, value3.......]
2、内部是用双向链表实现的，所以在向列表两端添加删除元素会很快时间复杂的为O(1)，获取前10条数据和后10条数据时也是很快的
3、当列表中元素过多时，通过索引访问中间元素会比较慢
4、一个key最多能存储2的32次方-1个字符串
5、使用场景：只关心最新的几条数据
▪️ 向列表两端增加元素 LPUSH 、RPUSH：
1）语法：LPUSH key value 、RPUSH key value
2）语意：向指定列表的两端添加元素
3）要点：返回值是添加成功后列表中的元素个数，列表中的元素是可以重复的
127.0.0.1:6379> LPUSH myList 1 //向myList列表的左边添加元素1,此时列表 = [1] (integer) 1 127.0.0.1:6379> LPUSH myList 2 //向myList列表的左边添加元素2,此时列表 = [2,1] (integer) 2 127.0.0.1:6379> LPUSH myList 3 4 //向myList列表的左边添加元素3,4,此时列表 = [4,3,2,1] (integer) 4 127.0.0.1:6379> RPUSH myList 5 6 //向myList列表的左边添加元素5,6,此时列表 = [4,3,2,1,5,6] (integer) 6 127.0.0.1:6379> RPUSH myList 1 //向myList列表的左边添加元素3,4,此时列表 = [4,3,2,1,5,6,1] (integer) 7
▪️ 向列表两端弹出元素 LPOP 、RPOP：
1）语法：LPOP key value 、RPOP key value
2）语意：向指定列表的两端弹出元素
127.0.0.1:6379> LPOP myList //向列表左边弹出一个元素，弹出的元素是4 "4" 127.0.0.1:6379> RPOP myList //向列表右边弹出一个元素，弹出的元素是1 "1" 127.0.0.1:6379> RPOP myList1 //向未定义的列表的右边弹出一个元素，返回空 (nil) //原来的列表 = [4,3,2,1,5,6,1] 现在的列表=[3,2,1,5,6]
▪️ 获取列表中的元素个数，获取列表片段 LLEN 、LRANGE：
1）语法：LLEN key、LRANGE key startIndex endIndex
2）语意：获取指定数组的元素个数、获取指定的数组指定索引段直接的元素
3）要点：
1、和我们常见的方法不一样，redis的这个方法定义的索引段，endIndex是包含的 => [startInde,endIndex]，python中的索引段=>[startInde,endIndex)
2、当endIndex超过列表的元素索引范围时，会直接返回开始索引到结束的所有元素
127.0.0.1:6379> LLEN myList //获取指定列表的元素个数 (integer) 5 127.0.0.1:6379> LRANGE myList 0 2 //获取指定列表[0,2]之间的元素 1) "3" 2) "2" 3) "1" 127.0.0.1:6379> LRANGE myList 0 7 //获取指定列表[0,7]之间的元素，但是没有那么多元素，所以干脆直接全部返回 1) "3" 2) "2" 3) "1" 4) "5" 5) "6" 127.0.0.1:6379> LRANGE myList 0 -1 //负号表示从右往左的第一个元素的索引，也就是最右端的最后一个元素 1) "3" 2) "2" 3) "1" 4) "5" 5) "6"
▪️ 删除列表中指定的值 LREM：
1）语法：LREM key count value
2）语意：删除指定列表前count个等于value的值
3）要点：
1、 当count > 0时：
[ 从左往右删除count个等于value的值——> ]
当count < 0时：
[ <——从右往左删count个等于value的值 ]
当count == 0时:
[ 删除所有等于value的值 ]
127.0.0.1:6379> LRANGE myList 0 -1 //现在的列表元素 = [3,3,3,1,2,3,2,1,5,6,1,1] 1) "3" 2) "3" 3) "3" 4) "1" 5) "2" 6) "3" 7) "2" 8) "1" 9) "5" 10) "6" 11) "1" 12) "1" 127.0.0.1:6379> LREM myList 2 3 //由于count = 2 > 0，所以从左往右删除2个value = 3的元素，返回删除成功的个数2,此时元素 = [3,1,2,3,2,1,5,6,1,1] (integer) 2 127.0.0.1:6379> LREM myList -3 1 //由于count = -3 < 0，所以从右往左删除3个value = 1的元素,返回删除成功的个数3，此时元素 = [3,1,2,3,2,5,6] (integer) 3 127.0.0.1:6379> LRANGE myList 0 -1 //验证一下，结果确实如此 1) "3" 2) "1" 3) "2" 4) "3" 5) "2" 6) "5" 7) "6"
▪️ 获得、设置指定index处的值 LINDEX、LSET：
1）语法：LINDEX key index 、LSET key index value
2）语意：获取、设置指定列表中指定index的值
3）要点：数组索引是从0开始的，获取的值若不在索引范围，则返回空，设置的索引不在索引范围，则会报错
127.0.0.1:6379> LRANGE myList 0 -1 //获取当前指定列表的元素 1) "3" 2) "1" 3) "2" 4) "3" 5) "2" 6) "5" 7) "6" 127.0.0.1:6379> LINDEX myList 2 //获取index = 4的元素，返回值为2 "2" 127.0.0.1:6379> LINDEX myList 9 //获取超过数组索引范围的值，返回空 (nil) 127.0.0.1:6379> LSET myList 0 1 //设置index = 0的值为1，设置成功，返回ok OK 127.0.0.1:6379> LSET myList 50 1 //设置超过index范围的值为1，返回报错 (error) ERR index out of range 127.0.0.1:6379> LRANGE myList 0 -1 //检查发现，index = 0的值确实被设置为1 1) "1" 2) "1" 3) "2" 4) "3" 5) "2" 6) "5" 7) "6"
▪️ 只保留列表指定片段 LTRIM：
1）语法：LTRIM key startIndex endIndex
2）语意：只保留[startIndex,endIndex]之间的索引，包含两端，其他的都删除掉
3）要点：当endIndex超过索引范围时，则默认为此时的endIndex = -1，也就是最后一个元素
127.0.0.1:6379> LRANGE myList 0 -1 //获取当前列表的元素 = [1,1,2,3,2,5,6] 1) "1" 2) "1" 3) "2" 4) "3" 5) "2" 6) "5" 7) "6" 127.0.0.1:6379> LTRIM myList 2 6 //截取索引范围为[2,6]之间的元素 OK 127.0.0.1:6379> LRANGE myList 0 -1 //确实索引范围在[2,6]之外的元素都被删除了 1) "2" 2) "3" 3) "2" 4) "5" 5) "6" 127.0.0.1:6379> LTRIM myList 2 50 //当结束索引超过索引范围时，则默认为此时的endIndex = -1，也就是最后一个元素 OK 127.0.0.1:6379> LRANGE myList 0 10 1) "2" 2) "5" 3) "6"
▪️ 向列表中插入元素 LINSERT：
1）语法：LINSERT key BEFORE|AFTER pivot value
2）语意：在指定列表中，从左往右，找到等于pivot的值，如果第三个参数等于BEFORE则插入到pivot的前面，若第三个参数等于AFTER，则插入到pivot的后面
127.0.0.1:6379> LRANGE myList 0 -1 //myList = [5, 6] 1) "5" 2) "6" 127.0.0.1:6379> LINSERT myList BEFORE 5 1 //在myList中从左往右找到value = 5的元素，把1插入到他的前面，返回值是插入成功后元素的个数 (integer) 3 127.0.0.1:6379> LRANGE myList 0 -1 //myList = [1, 5, 6] 1) "1" 2) "5" 3) "6" 127.0.0.1:6379> LINSERT myList AFTER 6 2 //在myList中从左往右找到value = 6的元素，把1插入到他的后面 (integer) 4 127.0.0.1:6379> LRANGE myList 0 -1 //myList = [1, 5, 6, 2] 1) "1" 2) "5" 3) "6" 4) "2" 127.0.0.1:6379> LINSERT myList AFTER a 2 //由于myList中不存在a这个元素，所以插入失败，返回-1，执行完后查看数组元素，确实没有插入成功 (integer) -1 127.0.0.1:6379> LRANGE myList 0 -1 1) "1" 2) "5" 3) "6" 4) "2"
▪️ 将一个列表转移到另一个列表RPOPLPUSH ：
1）语法：RPOPLPUSH key1 key2
2）语意：从key = key1的列表中的右边弹出一个元素，然后将其加入到key = key2的列表的左边
3) 要点：若key1的列表不存在或为空，则会返回空，key2的列表不会有任何改变
127.0.0.1:6379> LRANGE myList 0 -1 //myList = [1, 5, 6, 2] 1) "1" 2) "5" 3) "6" 4) "2" 127.0.0.1:6379> LRANGE myList2 0 -1 //myList2 = [] (empty array) 127.0.0.1:6379> RPOPLPUSH myList myList2 //从myList右边弹出一个元素，加入到mylist2左边,返回值是弹出的元素=2 "2" 127.0.0.1:6379> LRANGE myList 0 -1 //myList = [1, 5, 6] 1) "1" 2) "5" 3) "6" 127.0.0.1:6379> LRANGE myList2 0 -1 //myList2 = [2] 1) "2"
四、集合类型
1、存储形式：key:(1, 2, 3, 4, 5.....)
2、集合中元素是无序的，且元素是不重复的
3、最多存储2的32次方-1个字符串
▪️ 增加、删除元素 、获取集合中所有元素 SADD、SREM 、SMEMBERS：
1）语法：SADD key value1 value2 value3 ......、SREM key value1 value2 value3 ........、SMEMBERS key
2）语意：将value加入到指定集合中、将指定集合中的指定value删除、获取指定集合中的所有元素
3) 要点：集合中的元素是不重复的，添加的时候redis会自动排除掉
127.0.0.1:6379> SADD mySet 1 2 3 4 1 2 //向key = mySet的集合中加入元素，此时mySet = (1, 2, 3, 4),返回值是添加成功的元素个数，因为集合中的元素是不可重复的，所以返回值是4 (integer) 4 127.0.0.1:6379> SMEMBERS mySet //获取mySet = (1, 2, 3, 4) 1) "1" 2) "2" 3) "3" 4) "4" 127.0.0.1:6379> SREM mySet 1 2 5 6 //删除mySet中的1，2，5，6元素，返回值是删除成功的个数，由于5，6不存在于集合中，所以删除成功2个 (integer) 2 127.0.0.1:6379> SMEMBERS mySet //mySet = (3 ,4) 1) "3" 2) "4"
▪️ 判断元素是否在集合中 SISMEMBER：
1）语法：SISMEMBER key value
2）语意：判断value是否存在于指定集合中
127.0.0.1:6379> SMEMBERS mySet //mySet = (3, 4) 1) "3" 2) "4" 127.0.0.1:6379> SISMEMBER mySet 3 //判断3是否在mySet中，存在返回1 (integer) 1 127.0.0.1:6379> SISMEMBER mySet 5 //判断5是否在mySet中，不存在返回0 (integer) 0
▪️ 集合间的运算(差集、交集、并集) SDIFF、SINTER、SUNION：
1）语法：SDIFF key1 key2 key3 ..... 、SINTER key1 key2 key3 ....... 、SUNION key1 key2 key3
2）语意：判断value是否存在于指定集合中
3）要点：
1、SDIFF 表示在前面一个集合中，后一个集合不存在的元素组成的集合，然后将这个结果继续与剩下的集合一一比对
127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 2, 3, 4, 5) 1) "1" 2) "2" 3) "3" 4) "4" 5) "5" 127.0.0.1:6379> SMEMBERS mySet2 //mySet2 = (3 ,4) 1) "3" 2) "4" 127.0.0.1:6379> SMEMBERS mySet3 //mySet3 = (3, 7) 1) "3" 2) "7" 127.0.0.1:6379> SDIFF mySet mySet2 //此命令表示mySet中，mySet2没有的元素，返回(1 , 2, 5) 1) "1" 2) "2" 3) "5" 127.0.0.1:6379> SDIFF mySet mySet2 mySet3 //此命令表示上一步的结果中，mySet3不存在的元素的集合 1) "1" 2) "2" 3) "5" 127.0.0.1:6379> SINTER mySet mySet2 //此命令表示求mySet与mySet2共同拥有的部分(3 ,4) 1) "3" 2) "4" 127.0.0.1:6379> SINTER mySet mySet2 mySet3 //表示mySet、mySet2、mySet3共同拥有的部分(3) 1) "3" 127.0.0.1:6379> SUNION mySet mySet2 //此命令表示将mySet与mySet2的元素相加 1) "1" 2) "2" 3) "3" 4) "4" 5) "5" 127.0.0.1:6379> SUNION mySet mySet2 mySet3 //此命令表示将mySet、mySet2、mySet3的元素相加 1) "1" 2) "2" 3) "3" 4) "4" 5) "5" 6) "7"
▪️ 获得集合中元素的个数 SCARD：
1）语法：SCARD key
2）语意：获取指定集合中元素的个数
127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 2, 3, 4, 5) 1) "1" 2) "2" 3) "3" 4) "4" 5) "5" 127.0.0.1:6379> SCARD mySet //mySet元素的个数为5个 (integer) 5
▪️ 进行集合间的运算(差集、交集、并集)并将返回结果存储在新集合中 SDIFFSTORE、SINTERSTORE、SUNIONSTORE：
1）语法：SDIFFSTORE newSetKey key1 key2 key3 ..... 、SINTERSTORE newSetKey key1 key2 key3 ....... 、SUNIONSTORE newSetKey key1 key2 key3
2）语意：将指定的集合进行差集、交集、并集运算，然后把结果存在key = newSetKey的集合中
3）要点：在使用这三个命令时，若选定的newSetKey已经存在，则得到的结果会将其覆盖
127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 2) 1) "1" 2) "2" 127.0.0.1:6379> SMEMBERS mySet2 //mySet = (2, 3) 1) "2" 2) "3" 127.0.0.1:6379> SDIFFSTORE newMySet mySet mySet2 //mySet mySet2差集为(1),赋值到newMySet中，返回的是元素的个数 (integer) 1 127.0.0.1:6379> SMEMBERS newMySet //newMySet = (1) 1) "1" 127.0.0.1:6379> SINTERSTORE newMySet mySet mySet2 //mySet mySet2的交集等于 = (2),赋值到newMySet中，返回的是元素的个数 (integer) 1 127.0.0.1:6379> SMEMBERS newMySet //newMySet = (2) 1) "2" 127.0.0.1:6379> SUNIONSTORE newMySet mySet mySet2 //mySet mySet2的并集等于 = (1, 2, 3),赋值到newMySet中，返回的是元素的个数 (integer) 3 127.0.0.1:6379> SMEMBERS newMySet //newMySet = (1, 2, 3) 1) "1" 2) "2" 3) "3"
▪️ 随机获取集合中的元素 SRANDMEMBER：
1）语法：SRANDMEMBER key count
2）语意：从指定集合中随机获取｜count｜个元素
3）要点：
1、若count>1，则返回不重复的count个元素，若count大于集合中元素的个数，则会返回全部元素
2、若count<0，则返回包含重复的count个元素，若｜count｜大于集合中元素的个数，是可以返回｜count｜个元素的
3、为什么当count<0时会返回有些占比比较大的重复元素呢，因为在redis中，集合对元素的存储方式是由hash实现的，为了避免hash冲突，相同hash值的元素会放在同一个hash值下，然后用链表延伸，该命令在选择元素时，是先随机选择一个链表中元素个数不为0的hash值，然后再随机选择这个hash值下链表中的元素，由于hash值被选中的概率是相同的，那决定因素就在于每个hash值后面的链表中元素的个数大小了，链表中元素个数越少，同一个元素被选中的几率就越大。(桶就可以看作是hash值)
127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 2, 3, 4, 5, 6, 7) 1) "1" 2) "2" 3) "4" 4) "5" 5) "6" 6) "7" 127.0.0.1:6379> SRANDMEMBER mySet 2 //count>2 ，随机获取两个不重复的元素 1) "4" 2) "2" 127.0.0.1:6379> SRANDMEMBER mySet 10 //count>集合元素个数 ，全部返回 1) "1" 2) "2" 3) "4" 4) "5" 5) "6" 6) "7" 127.0.0.1:6379> SRANDMEMBER mySet -2 //count<0,随机返回2个可以包含重复的元素 1) "1" 2) "1" 127.0.0.1:6379> SRANDMEMBER mySet -10 //count<0 ，随机获取10个可以包含重复的元素 1) "6" 2) "4" 3) "6" 4) "2" 5) "2" 6) "2" 7) "4" 8) "7" 9) "4" 10) "6"
▪️ 从集合中弹出一个元素 SPOP：
1）语法：SPOP
2）语意：从指定集合中随机弹出1个元素
3）要点：由于集合是无序的，所以弹出的元素是随机选中的
127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 2, 4, 5, 6, 7) 1) "1" 2) "2" 3) "4" 4) "5" 5) "6" 6) "7" 127.0.0.1:6379> SPOP mySet 1 //mySet弹出一个元素7 1) "7" 127.0.0.1:6379> SPOP mySet 2 //mySet弹出两个元素2、4 1) "4" 2) "2" 127.0.0.1:6379> SMEMBERS mySet //mySet = (1, 5, 6) 1) "1" 2) "5" 3) "6" 127.0.0.1:6379> SPOP mySet 10 //当元素个数大于集合元素个数时，将会全部弹出 1) "1" 2) "5" 3) "6" 127.0.0.1:6379> SMEMBERS mySet //mySet为空 (empty array)
五、有序集合类型
1、存储形式：key：(value1:score, value2:score........) （直观描述，数据结构不准确）
2、在集合的基础上，给每个元素多加了一个分数。
3、有序集合是有序的，和列表相似，两者都可以获取某一个返回内的元素。
4、列表是链表实现的，向列表两端添加元素、删除元素会比较快，操作中间的元素就会比较慢，有序集合是用散列表和跳跃表实现的，所以读取中间的数据也很快。
5、列表不能简单地调整某个元素的位置，比如将第5个元素和第三个元素替换，直接操作是比较麻烦的，但是有序列表可以通过改变元素的分数来改变排序。
6、有序集合要比列表更耗费内存。
▪️ 增加元素 ZADD：
1）语法：ZADD key score value
2）语意：在指定有序集合中添加元素及其对应分数
3）要点：如果value已经存在，若再次设置该value，那么他的score将会被新的覆盖
127.0.0.1:6379> ZADD orderSet 90 lyh 100 cxg //添加元素和其对应分数到有序集合orderSet, lyh-90、cxg-100，返回值为插入成功2 (integer) 2 127.0.0.1:6379> ZADD orderSet 80.1 lz //此外分数还可以为浮点数 (integer) 1
▪️ 获取元素分数 ZSCORE：
1）语法：ZSCORE key value
2）语意：在指定有序集合中获取指定元素的对应分数
127.0.0.1:6379> ZSCORE orderSet lyh //获取指定有序集合中lyh元素的分数 = 90 "90" 127.0.0.1:6379> ZSCORE orderSet lyh11 //若value不存在则返回空 (nil)
▪️ 获取排名在某个范围的元素列表ZSCORE：
1）语法：ZSCORE key start end [WITHSCORES]
2）语意：在指定有序集合中获取指定排名范围的元素，若想获取对应分数，可以在WITHSCORES参数
127.0.0.1:6379> ZRANGE orderSet 0 -1 //获取指定有序集合排名在第一位到最后一位的元素 1) "cxg" 2) "lz" 3) "lyh" 127.0.0.1:6379> ZRANGE orderSet 0 1 //获取指定有序集合排名在第一位到最后二位的元素 1) "cxg" 2) "lz" 127.0.0.1:6379> ZRANGE orderSet 0 1 WITHSCORES //获取指定有序集合排名在第一位到最后一位的元素及其对应分数 1) "cxg" 2) "70.099999999999994" 3) "lz" 4) "80.099999999999994"
▪️ 获取分数在某个范围的元素列表 ZRANGEBYSCORE ：
1）语法：ZRANGEBYSCORE key [(] min [(]max [WITHSCORES] [LIMIT offset count]
2）语意：在指定有序集合中，选取氛围在[min,max]之间的元素，并且，min和max之前可以通过添加'('来表示是否包含该边界，此外，min和max还可以由 -inf或+inf替换，分别表示负无穷和正无穷，最后一个参数LIMIT offset count表示在最后得到结果中，从第offset个索引开始，选取count个元素进行展示
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //全部元素及其对应分数(ltx, lkh, lmg, zyg, jjx, cxg, lz, lyh) 1) "ltx" 2) "25" 3) "lkh" 4) "41" 5) "lmg" 6) "51" 7) "zyg" 8) "51" 9) "jjx" 10) "52" 11) "cxg" 12) "71" 13) "lz" 14) "81" 15) "lyh" 16) "90" 127.0.0.1:6379> ZRANGEBYSCORE orderSet 40 60 //获取分数在[40,60]之间的元素(lkh, lmg, zyg, jjx) 1) "lkh" 2) "lmg" 3) "zyg" 4) "jjx" 127.0.0.1:6379> ZRANGEBYSCORE orderSet 40 60 WITHSCORES //获取分数在[40,60]之间的元素，并显示对应分数(lkh=>41, lmg=>51, zyg=>51, jjx=>52) 1) "lkh" 2) "41" 3) "lmg" 4) "51" 5) "zyg" 6) "51" 7) "jjx" 8) "52" 127.0.0.1:6379> ZRANGEBYSCORE orderSet (41 60 WITHSCORES //获取分数在(40,60]之间的元素，并显示对应分数(lmg=>51, zyg=>51, jjx=>52) 1) "lmg" 2) "51" 3) "zyg" 4) "51" 5) "jjx" 6) "52" 127.0.0.1:6379> ZRANGEBYSCORE orderSet (41 +inf WITHSCORES //获取分数在(40,+∞]之间的元素，并显示对应分数(lmg=>51, zyg=>51, jjx=>52, cxg=>71, lz=>81, lyh=>90) 1) "lmg" 2) "51" 3) "zyg" 4) "51" 5) "jjx" 6) "52" 7) "cxg" 8) "71" 9) "lz" 10) "81" 11) "lyh" 12) "90" 127.0.0.1:6379> ZRANGEBYSCORE orderSet -inf +inf WITHSCORES //获取分数在[-∞,+∞]之间的元素，并显示对应分数(ltx=>25, lkh=>41, lmg=>51, zyg=>51, jjx=>52, cxg=>71, lz=>81, lyh=>90) 1) "ltx" 2) "25" 3) "lkh" 4) "41" 5) "lmg" 6) "51" 7) "zyg" 8) "51" 9) "jjx" 10) "52" 11) "cxg" 12) "71" 13) "lz" 14) "81" 15) "lyh" 16) "90" 127.0.0.1:6379> ZRANGEBYSCORE orderSet -inf +inf WITHSCORES LIMIT 2 3 获取分数在[-∞,+∞]之间的元素，但是只取index=2开始的3个元素，并显示对应分数 (lmg=>51, zyg=>51, jjx=>52) 1) "lmg" 2) "51" 3) "zyg" 4) "51" 5) "jjx" 6) "52"
▪️ 增加某个元素的分数 ZINCRBY ：
1）语法：ZINCRBY key number value
2）语意：给指定集合中的指定元素的分数增加number
3）要点：若value不存在，则该命令会先创建value，然后socre初始化为0，在此基础上在进行后面的增加操作
127.0.0.1:6379> ZRANGE orderSet -1 -1 WITHSCORES //显示指定有序集合的最后一个元素及其分数 1) "lyh" 2) "90" 127.0.0.1:6379> ZINCRBY orderSet 5 lyh //给指定元素lyh增加5分，返回值是增加后的分数 "95" 127.0.0.1:6379> ZINCRBY orderSet -5 lyh //给指定元素lyh增加-5分，返回值是增加后的分数 "90" 127.0.0.1:6379> ZINCRBY orderSet 0.5 lyh //给指定元素lyh增加0.5分，说明也是支持浮点数的，返回值是增加后的分数 "90.5"
▪️ 获取有序集合元素的个数 ZCARD：
1）语法：ZCARD key
2）语意：在指定有序集合中元素的个数
127.0.0.1:6379> ZRANGE orderSet 0 -1 //获取指定有序集合中的所有元素 1) "ltx" 2) "lkh" 3) "lmg" 4) "zyg" 5) "jjx" 6) "cxg" 7) "lz" 8) "lyh" 127.0.0.1:6379> ZCARD orderSet //获取指定有序集合元素的个数 (integer) 8
▪️ 获取有序集合指定分数范围内元素的个数 ZCOUNT：
1）语法：ZCOUNT key min max
2）语意：在指定有序集合中指定分数返回内元素的个数
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //获取指定集合所有的元素及其对应分数 1) "ltx" 2) "25" 3) "lkh" 4) "41" 5) "lmg" 6) "51" 7) "zyg" 8) "51" 9) "jjx" 10) "52" 11) "cxg" 12) "71" 13) "lz" 14) "81" 15) "lyh" 16) "90.5" 127.0.0.1:6379> ZCOUNT orderSet 50 100 //获取指定集合中分数在50-100之间的元素个数 (integer) 6
▪️ 删除指定集合中的一个或多个元素 ZREM：
1）语法：ZREM key value1 value2 .....
2）语意：删除指定集合中等于value1，value2.....的元素
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //获取指定集合中所有元素及其分数 1) "ltx" 2) "25" 3) "lkh" 4) "41" 5) "lmg" 6) "51" 7) "zyg" 8) "51" 9) "jjx" 10) "52" 11) "cxg" 12) "70.099999999999994" 13) "lz" 14) "80.099999999999994" 15) "lyh" 16) "90.5" 127.0.0.1:6379> ZREM orderSet ltx lz //删除元素值=ltx lz的元素，返回值为删除成功的个数 (integer) 2 127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //检查发现ltx，lz及其对应分数已被删除 1) "lkh" 2) "41" 3) "lmg" 4) "51" 5) "zyg" 6) "51" 7) "jjx" 8) "52" 9) "cxg" 10) "70.099999999999994" 11) "lyh" 12) "90.5"
▪️ 按照排名范围删除元素 ZREMRANGEBYRANK：
1）语法：ZREMRANGEBYRANK key start stop
2）语意：按照排名，将索引在[start,stop]中的元素删除
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //获取指定有序集合的所有元素及其分数 1) "lkh" 2) "41" 3) "lmg" 4) "51" 5) "zyg" 6) "51" 7) "jjx" 8) "52" 9) "cxg" 10) "70.099999999999994" 11) "lyh" 12) "90.5" 127.0.0.1:6379> ZREMRANGEBYRANK orderSet 0 3 //按正序排序后删除索引在[0,3]之间的元素及其对应分数，返回值为4，表示删除成功的个数 (integer) 4 127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //获取当前的有序集合元素及其分数 1) "cxg" 2) "70.099999999999994" 3) "lyh" 4) "90.5"
▪️ 获取元素的排名 ZRANK、ZREVRANK：
1）语法：ZRANK key value、ZREVRANK key value
2）语意：获取指定元素的排名，ZRANK表示按正序排序后的排名，ZREVRANK表示按倒叙排序后的排名
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //获取指定集合的所有元素及其对应分数 1) "cxg" 2) "70.099999999999994" 3) "lyh" 4) "90.5" 127.0.0.1:6379> ZRANK orderSet lyh //获取正序排序后，元素lyh的索引，分数从索引0开始递增，此时排第二个，索引值为1 (integer) 1 127.0.0.1:6379> ZREVRANK orderSet lyh //获取倒序排序后，元素lyh的索引，分数从索引0开始递减，此时排第一个，索引值为0 (integer) 0 127.0.0.1:6379> ZREVRANK orderSet lyh1 //若元素不存在，则返回空 (nil)
▪️ 计算有序集合的交集 ZINTERSTORE ：
1）语法：ZINTERSTORE newKey keyNum key1 key2 .... [WEIGHT weight1 weight2 ....] [AGGREGATE SUM、MIN、MAX]
2）语意：将key = key1、key2.... 等keyNum个有序集合的交集放入key=newKey的新有序集合中，并且在组合之前每个集合都可以通过WEIGHT参数进行权重设置，将每个集合分别对应权重，然后将其元素与权重进行相乘，最后通过AGGREGATE参数中的SUM、MIN、MAX来决定newKey集合中的元素的分数的生成形式，SUM表示为所有参与计算的集合中的该元素对应分数的和，MIN表示取参与该次计算的集合中该元素的分数最小值，MAX则表示取最大值。
127.0.0.1:6379> ZRANGE orderSet 0 -1 WITHSCORES //有序集合orderSet = (cxg=>71, lyh=>90.5) 1) "cxg" 2) "71" 3) "lyh" 4) "90.5" 127.0.0.1:6379> ZRANGE orderSet2 0 -1 WITHSCORES //有序集合orderSet2 = (cxg=>40, lyh=>50) 1) "cxg" 2) "40" 3) "lyh" 4) "50" 127.0.0.1:6379> ZRANGE orderSet3 0 -1 WITHSCORES //有序集合orderSet3 = (cxg=>50, lyh=>60) 1) "cxg" 2) "50" 3) "lyh" 4) "60" 127.0.0.1:6379> ZINTERSTORE orderSet4 3 orderSet orderSet2 orderSet3 //求orderSet orderSet2 orderSet3的交集，把结果赋给orderSet4，返回值是交集的元素个数2 (integer) 2 127.0.0.1:6379> ZRANGE orderSet4 0 -1 WITHSCORES //有序集合orderSet4 = (cxg=>161, lyh=>200.5)，默认为元素值相加 1) "cxg" 2) "161" 3) "lyh" 4) "200.5" 127.0.0.1:6379> ZINTERSTORE orderSet5 3 orderSet orderSet2 orderSet3 WEIGHTS 1 0.1 0.1 //求orderSet(权重=1) orderSet2(权重=0.1) orderSet3(权重=0.1)的交集，把结果赋给orderSet5，返回值是交集的元素个数2 (integer) 2 127.0.0.1:6379> ZRANGE orderSet5 0 -1 WITHSCORES //有序集合orderSet5 = (cxg=>80.0, lyh=>101.5)，默认为元素值相加 1) "cxg" 2) "80.0" 3) "lyh" 4) "101.5" 127.0.0.1:6379> ZINTERSTORE orderSet6 3 orderSet orderSet2 orderSet3 WEIGHTS 1 0.1 0.1 AGGREGATE SUM //求orderSet(权重=1) orderSet2(权重=0.1) orderSet3(权重=0.1)的交集,并且交集元素的分数生成方式为SUM相加，把结果赋给orderSet6,返回值是交集的元素个数2 (integer) 2 127.0.0.1:6379> ZRANGE orderSet6 0 -1 WITHSCORES //有序集合orderSet6 = (cxg=>80.0, lyh=>101.5)，交集相同元素的值相加 1) "cxg" 2) "80.0" 3) "lyh" 4) "101.5" 127.0.0.1:6379> ZINTERSTORE orderSet7 3 orderSet orderSet2 orderSet3 WEIGHTS 1 0.1 0.1 AGGREGATE MIN //求orderSet(权重=1) orderSet2(权重=0.1) orderSet3(权重=0.1)的交集,并且交集元素的分数生成方式为MIN取最小值，把结果赋给orderSet7,返回值是交集的元素个数2 (integer) 2 127.0.0.1:6379> ZRANGE orderSet7 0 -1 WITHSCORES //有序集合orderSet7 = (cxg=>4, lyh=>5)，交集相同元素的值取最小值 1) "cxg" 2) "4" 3) "lyh" 4) "5" 127.0.0.1:6379> ZINTERSTORE orderSet8 3 orderSet orderSet2 orderSet3 WEIGHTS 1 0.1 0.1 AGGREGATE MAX //求orderSet(权重=1) orderSet2(权重=0.1) orderSet3(权重=0.1)的交集,并且交集元素的分数生成方式为MAX取最大值，把结果赋给orderSet8,返回值是交集的元素个数2 (integer) 2 127.0.0.1:6379> ZRANGE orderSet8 0 -1 WITHSCORES //有序集合orderSet8 = (cxg=>71, lyh=>90.5)，交集相同元素的值取最大值 1) "cxg" 2) "71" 3) "lyh" 4) "90.5"
终于总结完了，下一篇同步更新进阶的知识点，若有不对欢迎指正。