Redis命令详解（持续更新）

Redis

string命令组

APPEND key value

想对应的key的value的末尾增加值。如果没有该key，value则会先创健

127.0.0.1:6379> EXISTS mykey
(integer) 0
127.0.0.1:6379> APPEND mykey "123"
(integer) 3
127.0.0.1:6379> get mykey
"123"
127.0.0.1:6379> APPEND mykey "456"
(integer) 6
127.0.0.1:6379> get mykey
"123456"

应用：官网的例子是使用固定大小的字符串采样传感器温度的示例（在实际实现中使用二进制格式更好）。

redis> APPEND ts "0043"
(integer) 4
redis> APPEND ts "0035"
(integer) 8
redis> GETRANGE ts 0 3
"0043"
redis> GETRANGE ts 4 7
"0035"
redis> 

我觉得为什么不用List的呢？官网解释实在空间占用效率上极好

BITCOUNT key [start end]

统计字符串被设置为1的bit。start和end表示可选范围。可以写负数，负数表示才能后往前，-1就是最后一位。

127.0.0.1:6379> set bitkey "abc"
OK
127.0.0.1:6379> BITCOUNT bitkey
(integer) 10
127.0.0.1:6379> BITCOUNT bitkey 0 0
(integer) 3
127.0.0.1:6379> BITCOUNT bitkey 0 1
(integer) 6
127.0.0.1:6379> BITCOUNT bitkey 2 2
(integer) 4

至于结果大家查一下ASCII码对应看一下就知道了。

应用：可以使用bitmap实现用户上线次数统计

举个例子，如果今天是网站上线的第 100 天，而用户 peter 在今天阅览过网站，那么执行命令 SETBIT peter 100 1 ；如果明天 peter 也继续阅览网站，那么执行命令 SETBIT peter 101 1 ，以此类推。

127.0.0.1:6379> setbit peter 100 1
(integer) 0
127.0.0.1:6379> setbit peter 101 1
(integer) 0
127.0.0.1:6379> BITCOUNT peter
(integer) 2
127.0.0.1:6379>

BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]

这个就有点长了哈。。。。。

先看例子：

127.0.0.1:6379> set bfkey 1
OK
127.0.0.1:6379> BITFIELD bfkey GET i8 0
1) (integer) 49
127.0.0.1:6379> BITFIELD bfkey incrby i8 1 0
1) (integer) 98
127.0.0.1:6379> set bfkey 12
OK
127.0.0.1:6379> BITFIELD bfkey incrby i8 1 0
1) (integer) 98
127.0.0.1:6379> set bfkey 1
OK
127.0.0.1:6379> BITFIELD bfkey incrby i5 1 0
1) (integer) 12
127.0.0.1:6379>

1的ascii码是49 对应2进制为0011 0001 。

• GET <type> <offset> – 返回指定的位域

• SET <type> <offset> <value> – 设置指定位域的值并返回它的原值

• INCRBY <type> <offset> <increment> – 自增或自减（如果increment为负数）指定位域的值并返回它的新值

  incrby i8 1 0就表示需要 有符号整型，向左偏移1为 并且自增0。至于后面的GET i8 0就是从第0位开始获取8位有符号整型。 其他的命令也这么理解就可以了。

位和位偏移

bitfield命令有两种方式来指定位偏移。如果未定带数字的前缀，将会以字符串的第0位作为起始位。

不过，如果偏移量带有#前缀，那么指定的偏移量需要乘以整型宽度，例如：

BITFIELD mystring SET i8 #0 100 i8 #1 200

将会在第1个i8整数的偏移0位和第2个整数的偏移8位进行设值。如果想得到一个给定长度的普通整型数组，则不一定要在客户端进行计算。

溢出控制

使用OVERFLOW命令，用户可以通过指定下列其中一种行为来调整自增或自减操作溢出（或下溢）后的行为：

• WRAP: 回环算法，适用于有符号和无符号整型两种类型。对于无符号整型，回环计数将对整型最大值进行取模操作（C语言的标准行为）。对于有符号整型，上溢从最负的负数开始取数，下溢则从最大的正数开始取数，例如，如果i8整型的值设为127，自加1后的值变为-128。
• SAT: 饱和算法，下溢之后设为最小的整型值，上溢之后设为最大的整数值。例如，i8整型的值从120开始加10后，结果是127，继续增加，结果还是保持为127。下溢也是同理，但量结果值将会保持在最负的负数值。
• FAIL: 失败算法，这种模式下，在检测到上溢或下溢时，不做任何操作。相应的返回值会设为NULL，并返回给调用者。

注意每种溢出（OVERFLOW）控制方法，仅影响紧跟在INCRBY命令后的子命令，直到重新指定溢出（OVERFLOW）控制方法。

如果没有指定溢出控制方法，默认情况下，将使用WRAP算法。

这里还很好理解的，就是溢出的位怎么处理的问题、

返回值

本命令返回一个针对子命令给定位置的处理结果组成的数组。OVERFLOW子命令在响应消息中，不会统计结果的条数。

下面是OVERFLOW FAIL返回NULL的样例：

> BITFIELD mykey OVERFLOW FAIL incrby u2 102 1
1) (nil)

BITOP operation destkey key [key …]

就是两个关键字进行 “与”操作，当然还有其他位操作。例如：

• BITOP AND destkey srckey1 srckey2 srckey3 ... srckeyN ，对一个或多个 key 求逻辑并，并将结果保存到 destkey 。
• BITOP OR destkey srckey1 srckey2 srckey3 ... srckeyN，对一个或多个 key 求逻辑或，并将结果保存到 destkey 。
• BITOP XOR destkey srckey1 srckey2 srckey3 ... srckeyN，对一个或多个 key 求逻辑异或，并将结果保存到 destkey 。
• BITOP NOT destkey srckey，对给定 key 求逻辑非，并将结果保存到 destkey 。

除了Not操作之外，其他操作都可以接受一个或多个key作为输入。当OP处理不同长度的字符串的时候，较短的那个字符串所缺少的部分都会被看作0；空key也会被看作0的字符串。

例子：

127.0.0.1:6379> set key2 "1"
OK
127.0.0.1:6379> BITOP and  dest key1 key2
(integer) 1
127.0.0.1:6379> get dest
"1"

应用：使用bitop实现用户上线次数统计

具体没看如何实现，但是官网给了偏文章。这里贴下链接

BITPOS key bit [start] [end]

返回字符串里面第一个被设置为1或者0的bit位。默认情况下整个字符串都会被检索一次，除非指定了start和end。

例子：

127.0.0.1:6379> set mykey "\xff\xf0\x00"
OK
127.0.0.1:6379> bitpos mykey 0
(integer) 12
127.0.0.1:6379>
127.0.0.1:6379> bitpos mykey 0 1 4   //指定了star和end
(integer) 12

DECR key

对key对应的数字做减一操作。

127.0.0.1:6379> set mykey "10"
OK
127.0.0.1:6379> decr mykey
(integer) 9
127.0.0.1:6379>

DECRBY key decrement

将key对应的值减去 decrement

127.0.0.1:6379> set key "10"
OK
127.0.0.1:6379> DECRBY KEY 5
(integer) -5

GET key

返回key的value

127.0.0.1:6379> set key "1"
OK
127.0.0.1:6379> get key
"1"

GETBIT key offset

返回key对应位置的bit值。当offset超出字符串长度的时候，这个字符串就被假定为由0比特填充的连续空间。当key不存在的时候也会默认是由0填充的

127.0.0.1:6379> set key "\x0f"
OK
127.0.0.1:6379> getbit key 0
(integer) 0
127.0.0.1:6379> getbit key 4
(integer) 1

127.0.0.1:6379> set key "\x0f"
OK
127.0.0.1:6379> getbit key 0
(integer) 0
127.0.0.1:6379> getbit key 4
(integer) 1

GETRANGE key start end

获得指定范围内的值。这个函数处理超出范围的请求时，都把结果限制在string内。

127.0.0.1:6379> set key "123456789"
OK
127.0.0.1:6379> getrange key 0 3
"1234"
127.0.0.1:6379> getrange key -3 -1
"789"

GETSET key value

获取之前的value 再将key对应的value重置。举个例子：每当有事件发生的时候，一段程序都会调用INCR给key mycounter加1，但是有时我们需要获取计数器的值，并且自动将其重置为0。这可以通过GETSET mycounter “0”来实现：

127.0.0.1:6379> set key "1"
OK
127.0.0.1:6379>
127.0.0.1:6379> INCR key
(integer) 2
127.0.0.1:6379> GETSET key "0"
"2"
127.0.0.1:6379> get key
"0"
127.0.0.1:6379>

对存储在指定key的数值执行原子的加一操作。如果key不存在则设为0

127.0.0.1:6379> set key "1"
OK
127.0.0.1:6379> INCR key
(integer) 2
127.0.0.1:6379>

实例

这个看起来应用比较多。主要可以用来做计数器和限速器

计数器

例如利用用户的id做key，然后用户每访问一次就加一。

限速器1

FUNCTION LIMIT_API_CALL(ip)
ts = CURRENT_UNIX_TIME()
keyname = ip+":"+ts
current = GET(keyname)
IF current != NULL AND current > 10 THEN
    ERROR "too many requests per second"
ELSE
    MULTI
        INCR(keyname,1)
        EXPIRE(keyname,10)
    EXEC
    PERFORM_API_CALL()
END

这种方法的基本点是每个ip每秒生成一个可以记录请求数的计数器。

但是这些计数器每次递增的时候都设置了10秒的过期时间，这样在进入下一秒之后，redis会自动删除前一秒的计数器。

注意上面伪代码中我们用到了MULTI和EXEC命令，将递增操作和设置过期时间的操作放在了一个事务中， 从而保证了两个操作的原子性。

上面是官方的解释。但是我有疑问，他设置的过期时间明明是10秒，为什么说进入下一秒之后，redis会自动删除前一秒的计数器呢？只能说下一个10秒之后会删除之前的key。

限速器2

FUNCTION LIMIT_API_CALL(ip):
current = GET(ip)
IF current != NULL AND current > 10 THEN
    ERROR "too many requests per second"
ELSE
    value = INCR(ip)
    IF value == 1 THEN
        EXPIRE(value,1)
    END
    PERFORM_API_CALL()
END

这个就是好理解点，就是直接设置一秒的过期时间。一秒内次数不能超，过期之后会被删除key。然后INCR操作会直接重新生成key。

当时上面可能会出现竞态条件，比如同时两个线程进来了，在第一个线程还没有设置过期时间之前，把key的值加1了，这样就不符合设置过期时间的条件。

解决方法

官网文档利用Lua脚本并执行EVAL命令，不是很懂还是贴上代码。

local current
current = redis.call("incr",KEYS[1])
if tonumber(current) == 1 then
    redis.call("expire",KEYS[1],1)
end

下面就是利用redis的list来解决。

FUNCTION LIMIT_API_CALL(ip)
current = LLEN(ip)
IF current > 10 THEN
    ERROR "too many requests per second"
ELSE
    IF EXISTS(ip) == FALSE
        MULTI
            RPUSH(ip,ip)
            EXPIRE(ip,1)
        EXEC
    ELSE
        RPUSHX(ip,ip)
    END
    PERFORM_API_CALL()
END

先是利用MULTI和EXEC让里面操作是原子的，然后将检测对应key的长度。但是这也存在问题比如 EXIS(ip)存在问题，但是另外一个客户端创建了之后，我们就会少记录一个请求。

我想在java里面可以使用锁来控制。但是分布式的服务呢？分布式锁？

INCRBY key increment

将key对应的数字增加 increment，如果可以不存在那么就创建并置为0。

127.0.0.1:6379> set mykey 1
OK
127.0.0.1:6379> get mykey
"1"
127.0.0.1:6379> INCRBY mykey 5
(integer) 6
127.0.0.1:6379> get mykey
"6"

INCRBYFLOAT key increment

将对应的key数字增加increment 只不过可以是小数

redis> SET mykey 10.50
OK
redis> INCRBYFLOAT mykey 0.1
"10.6"
redis> SET mykey 5.0e3
OK
redis> INCRBYFLOAT mykey 2.0e2
"5200"
redis> 

MGET key [key …]

可以一次性获取多个key，不存在就返回nil

127.0.0.1:6379> set k1 1
OK
127.0.0.1:6379> set k2 2
OK
127.0.0.1:6379> mget k1 k2 k3
1) "1"
2) "2"
3) (nil)

MSET key value [key value …]

可以一次性设置多个key

127.0.0.1:6379> mset m1 1 m2 2 m3 3
OK
127.0.0.1:6379> mget m1 m2 m3
1) "1"
2) "2"
3) "3"

MSETNX key value [key value …]

一次性设置多个key，但是只要有一个key不存在那么就会全部失败，并且这个操作是原子的。返回1表示设置成功，返回0表示设置失败。

127.0.0.1:6379> msetnx l1 1 l2 2
(integer) 1
127.0.0.1:6379> mget l1 l2
1) "1"
2) "2"
127.0.0.1:6379> msetnx l1 2 j1 1
(integer) 0
127.0.0.1:6379> mget l1 j1
1) "1"
2) (nil)

PSETEX key milliseconds value

可以设置key 的到期时间（毫秒为单位）

127.0.0.1:6379> psetex key 100000 "hello"
OK
127.0.0.1:6379> pttl key
(integer) 98527
127.0.0.1:6379> pttl key //到期
(integer) -2

SET key value [EX seconds] [PX milliseconds] [NX|XX]

将key设置为指定字符串的值，若key存在则会覆盖。

从2.6.12版本开始，redis为SET命令增加了一系列选项:

• EX seconds – 设置键key的过期时间，单位时秒
• PX milliseconds – 设置键key的过期时间，单位时毫秒
• NX – 只有键key不存在的时候才会设置key的值
• XX – 只有键key存在的时候才会设置key的值

注意: 由于SET命令加上选项已经可以完全取代SETNX, SETEX, PSETEX的功能，所以在将来的版本中，redis可能会不推荐使用并且最终抛弃这几个命令。

127.0.0.1:6379> set key 1 ex 10
OK
127.0.0.1:6379> pttl key
(integer) 4976
127.0.0.1:6379> pttl key
(integer) -2
127.0.0.1:6379> set key 2 nx
(nil)
127.0.0.1:6379> set key 2 xx
OK

SETBIT key offset value

设置或者清空key的value在offset处的值且offset小于232。如果值不存在则创建且保证在offset处有bit值

127.0.0.1:6379> setbit mmkey 7 1
(integer) 0
127.0.0.1:6379> get mmkey
"\x01"
127.0.0.1:6379> setbit mmkey 7 0
(integer) 1
127.0.0.1:6379> get mmkey
"\x00"

SETEX key seconds value

可以给key设置过期时间（秒为单位）

redis> SETEX mykey 10 "Hello"
OK
redis> TTL mykey
(integer) 10
redis> GET mykey
"Hello"

SETNX key value

将key设置值为value，如果key不存在，这种情况下等同SET命令。 当key存在时，什么也不做。SETNX是”SET if Not eXists”的简写。

返回1 表示设置成功 ，0表示该key没有被设置

redis> SETNX mykey "Hello"
(integer) 1
redis> SETNX mykey "World"
(integer) 0
redis> GET mykey
"Hello"

Design pattern: Locking with !SETNX

设计模式：使用!SETNX加锁

暂时还不明白分布式锁，留个坑以后看 。

SETRANGE key offset value

覆盖key的部分值，如果offset超出则补0。

127.0.0.1:6379> set key "123456789"
OK
127.0.0.1:6379> SETRANGE key 1 "redis"
(integer) 9
127.0.0.1:6379> get key
"1redis789"
127.0.0.1:6379> SETRANGE key 11 "redis"
(integer) 16
127.0.0.1:6379> get key
"1redis789\x00\x00redis"

STRLEN key

返回key的string类型长度

127.0.0.1:6379> set key "123"
OK
127.0.0.1:6379> strlen key
(integer) 3

Lists命令组

BLPOP key [key …] timeout

弹出list的第一个元素，如果不存在该元素那么就会进入阻塞直到可弹出新的元素或者等待超时。传入多个key的时候，按key 的顺序检查各个列表，弹出第一个非空列表的头元素。如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接， 直到有另一个客户端对给定的这些 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。

返回值

• 当没有元素的时候会弹出一个 nil 的多批量值，并且 timeout 过期。

• 当有元素弹出时会返回一个双元素的多批量值，其中第一个元素是弹出元素的 key，第二个元素是 value。

  127.0.0.1:6379> RPUSH LK 1 2 3
  (integer) 3
  127.0.0.1:6379> BLPOP LK
  (error) ERR wrong number of arguments for 'blpop' command
  127.0.0.1:6379> BLPOP LK 0
  1) "LK"
  2) "1"
  127.0.0.1:6379> BLPOP LK1 10
  (nil)
  (10.01s)
  

BRPOP key [key …] timeout

和上面类似只不过是从list右边弹。

BRPOPLPUSH source destination timeout

弹出source左边的第一个值，，并加入destination里面。如果source不存在或者为空则等其push（或者创建后push）进元素否则则要等到timeout结束。

127.0.0.1:6379> lpush lk 1 2 3
(integer) 3
127.0.0.1:6379> BRPOPLPUSH lk des 1
"1"
127.0.0.1:6379> LRANGE des 0 1
1) "1"

LINDEX key index

返回对应索引的值

127.0.0.1:6379> lpush lk 1 2 3
(integer) 3
127.0.0.1:6379> LINDEX lk 0
"3"
127.0.0.1:6379>

LINSERT key BEFORE|AFTER pivot value

把value插入存于key的列表中在基准值pivot前面或者后面

127.0.0.1:6379> LINSERT lk  after "3" "4"
(integer) 3
127.0.0.1:6379> lrange lk 0 -1
1) "3"
2) "4"
3) "2"

LLEN key

返回list的长度，不存在就看作是空list，并且长度为0。如果key的value不是一个list则返回error。

127.0.0.1:6379> rPUSH key  1 2 3
(integer) 3
127.0.0.1:6379> llen key
(integer) 3
127.0.0.1:6379> llen ky
(integer) 0
127.0.0.1:6379> llen key
(integer) 3
127.0.0.1:6379> set sk "1222"
OK
127.0.0.1:6379> llen sk
(error) WRONGTYPE Operation against a key holding the wrong kind of value

LPUSH key value [value …]

将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在，那么在进行 push 操作前会创建一个空列表。 如果 key 对应的值不是一个 list 的话，那么会返回一个错误。

127.0.0.1:6379> lpush key 1 2 3
(integer) 3
127.0.0.1:6379> LRANGE key 0 -1
1) "3"
2) "2"
3) "1"

LRANGE key start stop

显示key的指定范围内的值。-1表示最后一个

127.0.0.1:6379> lpush key 1 2 3
(integer) 3
127.0.0.1:6379> LRANGE key 0 -1
1) "3"
2) "2"
3) "1

LREM key count value

从存于 key 的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作：

• count > 0: 从头往尾移除值为 value 的元素。
• count < 0: 从尾往头移除值为 value 的元素。
• count = 0: 移除所有值为 value 的元素。

**返回值：**移除值的数量

127.0.0.1:6379> rpush key 1 1 1 2 2 2 3 3 3
(integer) 9
127.0.0.1:6379> lrem key -2 e
(integer) 0
127.0.0.1:6379> lrem key -2 3
(integer) 2
127.0.0.1:6379> lrange key 0 -1
1) "1"
2) "1"
3) "1"
4) "2"
5) "2"
6) "2"
7) "3"

LTRIM key start stop

修剪list 保留 start 到 stop的数。

127.0.0.1:6379> rpush t 1 2 3 4
(integer) 4
127.0.0.1:6379> lrange t 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
127.0.0.1:6379> LTRIM t 1 -1
OK
127.0.0.1:6379> lrange t 0 -1
1) "2"
2) "3"
3) "4"
127.0.0.1:6379>

RPOP key

弹出lits最后一个值。

返回值： key不存在返回nil，存在则返回最后一个值

127.0.0.1:6379> rpush k 1 2 3
(integer) 3
127.0.0.1:6379> RPOP k
"3"

RPOPLPUSH source destination

弹出source列表的最后一个值，到destination列表的第一个元素位置。如果source不存在，那么就会返回nil值并且不会执行任何操作。如果 source 和 destination 是同样的，那么这个操作等同于移除列表最后一个元素并且把该元素放在列表头部， 所以这个命令也可以当作是一个旋转列表的命令。

**返回值：**被移除和放入的元素

127.0.0.1:6379> rpush k 1 2 3 4
(integer) 4
127.0.0.1:6379> RPOPLPUSH k des
"4"
127.0.0.1:6379> LRANGE  des 0 -1
1) "4"

RPUSH key value [value …]

向存于 key 的列表的尾部插入所有指定的值。如果 key 不存在，那么会创建一个空的列表然后再进行 push 操作。 当 key 保存的不是一个列表，那么会返回一个错误。

127.0.0.1:6379> RPUSH t 1 2 3
(integer) 3
127.0.0.1:6379> LRANGE t 0 -1
1) "1"
2) "2"
3) "3"

RPUSHX key value

将值 value 插入到列表 key 的表尾, 当且仅当 key 存在并且是一个列表。 和 RPUSH 命令相反, 当 key 不存在时，RPUSHX 命令什么也不做。

127.0.0.1:6379> RPUSHX t 4
(integer) 4
127.0.0.1:6379> LRANGE t 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
127.0.0.1:6379> RPUSHX t1 4
(integer) 0
127.0.0.1:6379> LRANGE t1 0 -1
(empty list or set)

Set命令组

SADD key member [member …]

添加一个或多个指定的member元素到集合的key中。如果key不存在则新建key之后再添加

**返回值：**1成功，0失败

127.0.0.1:6379> SADD ks "12"
(integer) 1
127.0.0.1:6379> SADD ks "34"
(integer) 1
127.0.0.1:6379> SADD ks "34"
(integer) 0
127.0.0.1:6379> SADD ks "34"
(integer) 0
127.0.0.1:6379> SMEMBERS ks
1) "12"
2) "34"

SCARD key

返回集合存储的key的基数(集合元素的数量)

**返回值：**集合元素的数量

127.0.0.1:6379> sadd kk 1
(integer) 1
127.0.0.1:6379> sadd kk 2
(integer) 1
127.0.0.1:6379> sadd kk 2
(integer) 0
127.0.0.1:6379> SCARD kk
(integer) 2

SDIFF key [key …]

返回第一个集合和后面几个集合的差集

127.0.0.1:6379> sadd k1 1
(integer) 1
127.0.0.1:6379> sadd k1 2
(integer) 1
127.0.0.1:6379> sadd k2 2
(integer) 1
127.0.0.1:6379> sadd k2 3
(integer) 1
127.0.0.1:6379> sdiff k1 k2
1) "1"
127.0.0.1:6379> sdiff k2 k1
1) "3"

SDIFFSTORE destination key [key …]

将第一个集合和后面集合的差集存于destination里面，如果destination集合不存在则先创健如果存在则覆盖。

127.0.0.1:6379> sdiff k2 k1
1) "3"
127.0.0.1:6379> sdiffstore des k2 k1
(integer) 1
127.0.0.1:6379> SMEMBERS des
1) "3"

SINTER key [key …]

返回指定所有集合的成员的交集

127.0.0.1:6379> SADD k1 1
(integer) 1
127.0.0.1:6379> SADD k1 2
(integer) 1
127.0.0.1:6379> SADD k2 2
(integer) 1
127.0.0.1:6379> SADD k2 3
(integer) 1
127.0.0.1:6379> SINTER k1 k2
1) "2"

SINTERSTORE destination key [key …]

将上面那个命令的交集结果存在des中。

127.0.0.1:6379> SINTER k1 k2
1) "2"
127.0.0.1:6379> SINTERstore des k1 k2
(integer) 1

SISMEMBER key member

返回成员member是否存在于集合中

**返回值：**1存在，0不存在

127.0.0.1:6379> sadd k3 1 2 3
(integer) 3
127.0.0.1:6379> SMEMBERS k3
1) "1"
2) "2"
3) "3"
127.0.0.1:6379> SISMEMBER 1
(error) ERR wrong number of arguments for 'sismember' command
127.0.0.1:6379> SISMEMBER k3 1
(integer) 1
127.0.0.1:6379> SISMEMBER k3 4
(integer) 0

SMEMBERS key

返回key集合所有的元素。

127.0.0.1:6379> sadd k3 1 2 3
(integer) 3
127.0.0.1:6379> SMEMBERS k3
1) "1"
2) "2"
3) "3"

SMOVE source destination member

将member从source里面移到destination里面。如果member不存在与source里面则不执行任何操作。

**返回值：**1成功 0失败

127.0.0.1:6379> sadd k1 1 2
(integer) 2
127.0.0.1:6379> sadd k2 3
(integer) 1
127.0.0.1:6379> SMOVE k1 k2 1
(integer) 1
127.0.0.1:6379> SMEMBERS k2
1) "1"
2) "3"
127.0.0.1:6379> SMOVE k1 k2 4
(integer) 0
127.0.0.1:6379> SMEMBERS k2
1) "1"
2) "3"

SPOP key [count]

从存储在key的集合中移除并返回一个或多个随机元素。

count参数将在更高版本中提供，但是在2.6、2.8、3.0中不可用。

**返回值：**被删除的元素，或者当key不存在时返回nil。

127.0.0.1:6379> SADD k3 "a" "b" "c" "d"
(integer) 3
127.0.0.1:6379> spop k3
"d"
127.0.0.1:6379> spop k3 2
1) "c"
2) "a"

SRANDMEMBER key [count]

• count小于元素个数，返回含有count个不同的元素的数组。
• count大于元素个数，返回整个集合的所有元素。
• count是负数，返回包含count的绝对值的个数元素的数组
• count的绝对值大于元素个数，则返回的结果集合里面会出现一个元素多次出现的情况。
• count不写，则随机返回（注意：不是删除只是返回）

127.0.0.1:6379> sadd k1 1 2 3 4 5 6 7
(integer) 7
127.0.0.1:6379> SRANDMEMBER k1
"1"
127.0.0.1:6379> SRANDMEMBER k1 -2
1) "6"
2) "4"
127.0.0.1:6379> SRANDMEMBER k1 2
1) "2"
2) "4"

SREM key member [member …]

移除集合中指定的元素。如果该元素不存在于集合中则忽略。如果key集合不存在则视为空集合返回0。

127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> SREM 1
(error) ERR wrong number of arguments for 'srem' command
127.0.0.1:6379> SREM k1 q
(integer) 0
127.0.0.1:6379> SREM k1 1
(integer) 1
127.0.0.1:6379> SREM k1 2 3
(integer) 2
127.0.0.1:6379> SREM k2 1
(integer) 0
127.0.0.1:6379> sadd k1 1 2 3 4
(integer) 4
127.0.0.1:6379> SREM k1 q
(integer) 0
127.0.0.1:6379> SREM k1 1
(integer) 1
127.0.0.1:6379> SREM k1 2 3
(integer) 2
127.0.0.1:6379> SREM k2 1
(integer) 0

SSCAN key cursor [MATCH pattern] [COUNT count]

这个命令我理解了一会。我把参数一个个解释一下吧

key：集合的key

cursor：游标，和这个要和后面的count结合起来说。count默认是10就是说一个返回10个元素。那么游标的作用就是记住你上次迭代到那个位置了。游标设为0则重新迭代，当返回0的时候表示迭代结束了。

MATCH：这个就是正则表达式，用来匹配迭代的值做过滤用的。

COUNT：一次返回多少个。测试的时候发现很坑爹因为有时候发现返回的数量并不是指定的数量。然后在官网看到这个一句话：使用COUNT 选项对于对增量式迭代命令相当于一种提示， 大多数情况下这种提示都比较有效的控制了返回值的数量。（坑爹呢）

127.0.0.1:6379> sadd k1 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10
(integer) 10
127.0.0.1:6379> sadd k1 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 v21
(integer) 11
127.0.0.1:6379> sscan k1 0
1) "14"
2)  1) "v18"
    2) "v4"
    3) "v13"
    4) "v19"
    5) "v16"
    6) "v11"
    7) "v7"
    8) "v2"
    9) "v9"
   10) "v6"
127.0.0.1:6379> sscan k1 14
1) "11"
2)  1) "v3"
    2) "v17"
    3) "v20"
    4) "v8"
    5) "v14"
    6) "v10"
    7) "v1"
    8) "v12"
    9) "v21"
   10) "v15"
127.0.0.1:6379> sscan k1 11
1) "0"
2) 1) "v5"
127.0.0.1:6379> sscan k1 0 MATCH v18
1) "14"
2) 1) "v18"
127.0.0.1:6379> sscan k1 0 count 3
1) "10"
2) 1) "v18"
   2) "v4"
   3) "v13"
   4) "v19"
127.0.0.1:6379> sscan k1 10 count 3
1) "6"
2) 1) "v16"
   2) "v11"
   3) "v7"
   4) "v2"
   5) "v9"
127.0.0.1:6379> sscan k1 6 count 3
1) "1"
2) 1) "v6"
   2) "v3"
   3) "v17"
127.0.0.1:6379> sscan k1 1
1) "0"
2) 1) "v20"
   2) "v8"
   3) "v14"
   4) "v10"
   5) "v1"
   6) "v12"
   7) "v21"
   8) "v15"
   9) "v5"

SUNION key [key …]

返回多个集合的合集

127.0.0.1:6379> sadd k1 1 2
(integer) 2
127.0.0.1:6379> sadd k2 3 4
(integer) 2
127.0.0.1:6379> SUNION k1 k2
1) "1"
2) "2"
3) "3"
4) "4"

SUNIONSTORE destination key [key …]

就是把合集的结果保存到destination里面，如果destination 已经存在,则将其覆盖。

127.0.0.1:6379> sadd k1 1 2
(integer) 2
127.0.0.1:6379> sadd k2 3 4
(integer) 2
127.0.0.1:6379> SUNION k1 k2
1) "1"
2) "2"
3) "3"
4) "4"

Hash命令组

从key指定的哈希集中删除指定的域。如果不存在就忽略，如果key不存在，则被认为是空的哈希集将返回0。

返回值：返回从哈希集中成功移除的域的数量，不包括指出但不存在的那些域

127.0.0.1:6379> HSET myhash f "foo"
(integer) 1
127.0.0.1:6379> HDEL myhash f
(integer) 1
127.0.0.1:6379> HDEL myhash f1
(integer) 0
127.0.0.1:6379> HDEL myhash f
(integer) 0
127.0.0.1:6379> HGET myhash f
(nil)

HEXISTS key field

返回hash里面男的filed是否存在

返回值： 1-存在 0-field不存在或者key不存在

127.0.0.1:6379> HSET h f "1"
(integer) 1
127.0.0.1:6379> HEXISTS h f
(integer) 1
127.0.0.1:6379> HEXISTS h f1
(integer) 0

HGET key field

返回key指定的哈希集中该字段所关联的值

**返回值：**存在返回值，不存在返回nil

127.0.0.1:6379> HSET h f "1"
(integer) 0
127.0.0.1:6379> HGET h f
"1"
127.0.0.1:6379> HGET h f11
(nil)

HGETALL key

返回 key 指定的哈希集中所有的字段和值。返回值中，每个字段名的下一个是它的值，所以返回值的长度是哈希集大小的两倍

127.0.0.1:6379> HSET h f "1"
(integer) 0
127.0.0.1:6379> HGETALL h
1) "f"
2) "1"

HINCRBY key field increment

增加哈希集中指定字段的值

**返回值：**增值后该字段的值

127.0.0.1:6379> HSET h f 1
(integer) 0
127.0.0.1:6379> HINCRBY h f 1
(integer) 2
127.0.0.1:6379> HGET h f
"2"

HINCRBYFLOAT key field increment

给key的哈希集中指定file字段的值增加incremen，increment是浮点数。如果filed不存在则在执行操作前设置为0。如果出现下列情况：

• file的值包含的类型错误（不是字符串）
• 当前filed或者increment不能解析为一个float类型

**返回值：**filed增值后的值

127.0.0.1:6379> HSET h f 1.0
(integer) 0
127.0.0.1:6379> HINCRBYFloat h f 0.1
"1.1"

HKEYS key

返回 key 指定的哈希集中所有字段的名字。

127.0.0.1:6379> hset h f 1
(integer) 0
127.0.0.1:6379> hset h f1 2
(integer) 1
127.0.0.1:6379> HKEYS h
1) "f"
2) "f1"

HLEN key

返回 key 指定的哈希集包含的字段的数量。

127.0.0.1:6379> flushall
OK
127.0.0.1:6379> hset h f 1
(integer) 1
127.0.0.1:6379> HLEN h
(integer) 1

HMGET key field [field …]

返回 key 指定的哈希集中指定字段的值。没有就返回nil

**返回值：**含有给点字段以及值的列表。

127.0.0.1:6379> hset h f 1
(integer) 1
127.0.0.1:6379> hset h f1 2
(integer) 1
127.0.0.1:6379> hset h f3 3
(integer) 1
127.0.0.1:6379> HMGET h f f11
1) "1"
2) (nil)
127.0.0.1:6379> HMGET h f f1
1) "1"
2) "2"

HMSET key field value [field value …]

一次性设置多个key filed。

127.0.0.1:6379> hset h f1 1 f2 2 f3 3
(integer) 3
127.0.0.1:6379> HGETALL h
1) "f1"
2) "1"
3) "f2"
4) "2"
5) "f3"
6) "3"

HSCAN key cursor [MATCH pattern] [COUNT count]

这个上面我写的sscan差不多。尝试了好多次设置count结果没用，谁能告诉我为什么。。。。。可以看到下面设置了count 1 结果没效果。。。。

127.0.0.1:6379> hset h f1 1 f2 2 f3 3 f4 4 f5 5 f6 6 f7 7 f8 8 f9 9 f10  10 f11 11 f12 12
(integer) 12
127.0.0.1:6379> hscan h 0 COUNT 1
1) "0"
2)  1) "f1"
    2) "1"
    3) "f2"
    4) "2"
    5) "f3"
    6) "3"
    7) "f4"
    8) "4"
    9) "f5"
   10) "5"
   11) "f6"
   12) "6"
   13) "f7"
   14) "7"
   15) "f8"
   16) "8"
   17) "f9"
   18) "9"
   19) "f10"
   20) "10"
   21) "f11"
   22) "11"
   23) "f12"
   24) "12"

HSET key field value

设置一个指定字段的值，如果存在将被重写。如果key不存在将会被创建

127.0.0.1:6379> hset h f 1
(integer) 1

HSETNX key field value

key指定的哈希集中不存在此filed才能设置其值。如果key不存在则先创建

**返回值:**1-设置成功 0-说明该filed存在了，所以操作没有被执行

127.0.0.1:6379> hset h f 1
(integer) 1
127.0.0.1:6379> HSETNX h f 2
(integer) 0
127.0.0.1:6379> HSETNX h f1 2
(integer) 1
127.0.0.1:6379> HGETALL h
1) "f"
2) "1"
3) "f1"
4) "2"

HSTRLEN key field

返回hash指定field的value的字符串长度，如果hash或者field不存在，返回0.

127.0.0.1:6379> hset h f 123
(integer) 1
127.0.0.1:6379> HSTRLEN h f
(integer) 3
127.0.0.1:6379> HSTRLEN h f1
(integer) 0

HVALS key

返回 key 指定的哈希集中所有字段的值。

127.0.0.1:6379>  hmset h f1 1 f2 2 f3 3
OK
127.0.0.1:6379> HVALS h
1) "1"
2) "2"
3) "3"

ZSET命令组（Sorted Sets）

BZPOPMAX key [key …] timeout

在参数中的所有有序集合均为空的情况下，阻塞连接。返回多个有序集合中第一个非空key中分数最大的成员和对应的分数。timeout表示阻塞时间，等于0的时候表示永久阻塞。否则等到timeout时间到了之后返回nil。这个在我的版本里面还木有。。。

**返回值：**当有序集合无结果返回且超时设置过期时返回 nil。返回三元素multi-bulk结果，第一元素key名称，第二元素成员名称，第三元素分数

redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMAX zset1 zset2 0
1) "zet1"
2) "2"
2) "c"

BZPOPMIN key [key …] timeout

在参数中的所有有序集合均为空的情况下，阻塞连接。返回多个有序集合中第一个非空key中分数最小的成员和对应的分数。timeout表示阻塞时间，等于0的时候表示永久阻塞。否则等到timeout时间到了之后返回nil。这个在我的版本里面还木有。。。

**返回值：**当有序集合无结果返回且超时设置过期时返回 nil。返回三元素multi-bulk结果，第一元素key名称，第二元素成员名称，第三元素分数

redis> DEL zset1 zset2
(integer) 0
redis> ZADD zset1 0 a 1 b 2 c
(integer) 3
redis> BZPOPMIN zset1 zset2 0
1) "zet1"
2) "0"
2) "a"

ZADD key [NX|XX] [CH] [INCR] score member [score member …]

将所有指定成员添加到键为key有序集合（sorted set）里面。如果指定的成员已经存在则覆盖score，并更新到正确的排序位置。如果key不存在则会先创健。

ZADD参数

• XX: 仅仅更新存在的成员，不添加新成员。
• NX: 不更新存在的成员。只添加新成员。
• CH: 修改返回值为发生变化的成员总数，原始是返回新添加成员的总数 (CH 是 changed 的意思)。更改的元素是新添加的成员，已经存在的成员更新分数。 所以在命令中指定的成员有相同的分数将不被计算在内。注：在通常情况下，ZADD返回值只计算新添加成员的数量。
• INCR: 当ZADD指定这个选项时，成员的操作就等同ZINCRBY命令，对成员的分数进行递增操作。

返回值：

• 添加到有序集合的成员数量，不包括已经存在更新分数的成员。

如果指定INCR参数, 返回将会变成bulk-string-reply ：

• 成员的新分数（双精度的浮点型数字）字符串。

127.0.0.1:6379> zadd zk 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> ZRANGE zk 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> ZRANGE zk 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"
127.0.0.1:6379> zadd zk INCR 1  "one"
"2"
127.0.0.1:6379> ZRANGE zk 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "2"
5) "three"
6) "3"

ZCARD key

返回key的有序元素的个数

127.0.0.1:6379> zcard zk
(integer) 3
127.0.0.1:6379> ZRANGE zk 0 -1
1) "one"
2) "two"
3) "three"

ZCOUNT key min max

返回score值在min和max之间的数量

127.0.0.1:6379> ZRANGE zk 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "2"
5) "three"
6) "3"
127.0.0.1:6379> ZCOUNT zk 1 3
(integer) 3
127.0.0.1:6379> ZCOUNT zk 2 3
(integer) 3
127.0.0.1:6379> ZCOUNT zk 3 3
(integer) 1

ZINCRBY key increment member

给有序集中member的score加上increment。如果不存在member则先创健然后score就是increment。如果key不存在就先创健有序集key

**返回值：**增加后的score。

127.0.0.1:6379> ZRANGE zk 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "2"
5) "three"
6) "3"
127.0.0.1:6379> ZINCRBY zk 1 "one"
"3"

ZINTERSTORE destination numkeys key [key …] [WEIGHTS weight] [SUM|MIN|MAX]

有点小长，但是我们慢慢来看。求numkeys个有序集的交集并把结果放进destination里面 WEIGHTS表示乘法因子 例如 2 3 就是吧key1 key2分别乘2 和 3。

返回值：

结果有序集的个数

127.0.0.1:6379> zadd k1 1 "one"
(integer) 1
127.0.0.1:6379> zadd k1 2 "two"
(integer) 1
127.0.0.1:6379> zadd k2 2 "two"
(integer) 1
127.0.0.1:6379> zadd k2 1 "one"
(integer) 1
127.0.0.1:6379> ZINTERSTORE des 2 k1 k2
(integer) 2
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "4"
127.0.0.1:6379> ZINTERSTORE des 2 k1 k2 WEIGHTS 2 3
(integer) 2
127.0.0.1:6379> ZINTERSTORE des 2 k1 k2
(integer) 2
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "4"
127.0.0.1:6379> ZINTERSTORE des1 2 k1 k2 WEIGHTS 2 3
(integer) 2
127.0.0.1:6379> ZRANGE des1 0 -1 withscores
1) "one"
2) "5"
3) "two"
4) "10"
127.0.0.1:6379> ZINTERSTORE des2 2 k1 k2 WEIGHTS 2 3 AGGREGATE min
(integer) 2
127.0.0.1:6379> ZRANGE des2 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "4"
127.0.0.1:6379> ZINTERSTORE des2 2 k1 k2 WEIGHTS 2 3 AGGREGATE MAX
(integer) 2
127.0.0.1:6379> ZRANGE des2 0 -1 withscores
1) "one"
2) "3"
3) "two"
4) "6"

ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight] [SUM|MIN|MAX]

顺带把这个也说了吧，这个就是求并集，其余和上面差不多。

127.0.0.1:6379> flushall
OK
127.0.0.1:6379> zadd k1 1 "one" 2 "two"
(integer) 2
127.0.0.1:6379> flushall
OK
127.0.0.1:6379> zadd k2 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> zadd k1 1 "one" 2 "two"
(integer) 2
127.0.0.1:6379> ZUNIONSTORE des 2 k1 k2
(integer) 3
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "2"
3) "three"
4) "3"
5) "two"
6) "4"
127.0.0.1:6379> ZUNIONSTORE des 2 k1 k2 weights 2 3
(integer) 3
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "5"
3) "three"
4) "9"
5) "two"
6) "10"
127.0.0.1:6379> ZUNIONSTORE des 2 k1 k2 weights 2 3 AGGREGATE min
(integer) 3
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "2"
3) "two"
4) "4"
5) "three"
6) "9"
127.0.0.1:6379> ZUNIONSTORE des 2 k1 k2 weights 2 3 AGGREGATE max
(integer) 3
127.0.0.1:6379> ZRANGE des 0 -1 withscores
1) "one"
2) "3"
3) "two"
4) "6"
5) "three"
6) "9"

ZLEXCOUNT key min max

用于计算有序集合中指定成员之间的成员数量。

返回值：

满足条件的元素的数量

127.0.0.1:6379> zadd k 1 a 2 b 3 c 4 d 5 e 6 f
(integer) 6
127.0.0.1:6379> ZLEXCOUNT k [b [d
(integer) 3
127.0.0.1:6379> ZLEXCOUNT k [1 [3
(integer) 0
127.0.0.1:6379> ZLEXCOUNT k - +
(integer) 6
127.0.0.1:6379> ZLEXCOUNT k [c +
(integer) 4
127.0.0.1:6379> ZLEXCOUNT k - [b
(integer) 2

ZPOPMAX key [count]

删除并返回有序集key中最高得分的前count个的成员。count默认1，如果指定的count大于集合长度不会产生错误。返回多个元素的时候，score高的那个排第一个。

**返回值：**弹出的元素和分数列表

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMAX myzset
1) "3"
2) "three"

ZPOPMIN key [count]

删除并返回有序集key中最低得分前count个成员。count默认1，如果指定的count大于集合长度不会产生错误。返回多个元素的时候，score最低的那个排第一个。

**返回值：**弹出的元素和分数列表

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZPOPMIN myzset
1) "1"
2) "one"

ZRANGE key start stop [WITHSCORES]

返回有序集key的指定范围内的元素。withscores参数表示返回的元素包含score

127.0.0.1:6379> ZRANGE k 0 -1 withscores
 1) "a"
 2) "1"
 3) "b"
 4) "2"
 5) "c"
 6) "3"
 7) "d"
 8) "4"
 9) "e"
10) "5"
11) "f"
12) "6"

ZRANGEBYLEX key min max [LIMIT offset count]

返回指定区间内的成员，按成员字典序正序排序，score值必须相同。 在某些业务场景中,需要对一个字符串数组按名称的字典顺序进行排序时,可以使用Redis中SortSet这种数据结构来处理。（和[区别就是数学集合里面开闭区间

参数说明：

指令	是否必须	说明
ZRANGEBYLEX	是	指令
key	是	有序集合键名称
min	是	字典中排序位置较小的成员,必须以"[“开头,或者以”(“开头,可使用”-"代替
max	是	字典中排序位置较大的成员,必须以"[“开头,或者以”(“开头,可使用”+"代替
LIMIT	否	返回结果是否分页,指令中包含LIMIT后offset、count必须输入
offset	否	返回结果起始位置
count	否	返回结果数量

提示：

• 分数必须相同! 如果有序集合中的成员分数有不一致的,返回的结果就不准。
• 成员字符串作为二进制数组的字节数进行比较。
• 默认是以ASCII字符集的顺序进行排列。如果成员字符串包含utf-8这类字符集的内容,就会影响返回结果,所以建议不要使用。
• 默认情况下, “max” 和 “min” 参数前必须加 “[” 符号作为开头。”[” 符号与成员之间不能有空格, 返回成员结果集会包含参数 “min” 和 “max” 。
• “max” 和 “min” 参数前可以加 “(“ 符号作为开头表示小于, “(“ 符号与成员之间不能有空格。返回成员结果集不会包含 “max” 和 “min” 成员。
• 可以使用 “-“ 和 “+” 表示得分最小值和最大值
• “min” 和 “max” 不能反, “max” 放前面 “min”放后面会导致返回结果为空
• 与ZRANGEBYLEX获取顺序相反的指令是ZREVRANGEBYLEX。
• 源码中采用C语言中memcmp()函数, 从字符的第0位到最后一位进行排序,如果前面部分相同,那么较长的字符串比较短的字符串排序靠后。

127.0.0.1:6379> zadd k 1  a 1 b 1 c 1 d 1 aa 1 BB
(integer) 6
127.0.0.1:6379> ZRANGEBYLEX k - +
1) "BB"
2) "a"
3) "aa"
4) "b"
5) "c"
6) "d"
127.0.0.1:6379> ZRANGEBYLEX k - +  Limit 0 1
1) "BB"
127.0.0.1:6379> ZRANGEBYLEX k - [c  Limit 0 1
1) "BB"
127.0.0.1:6379> ZRANGEBYLEX k - [c
1) "BB"
2) "a"
3) "aa"
4) "b"
5) "c"
127.0.0.1:6379> ZRANGEBYLEX k  [c +
1) "c"
2) "d"
127.0.0.1:6379> ZRANGEBYLEX k  [a [c
1) "a"
2) "aa"
3) "b"
4) "c"
127.0.0.1:6379> ZRANGEBYLEX k  (a (c
1) "aa"
2) "b"

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

返回key的有序集合中score在min和max之间的所有元素（包括min和max）。元素从低分到高分排序。score相同就按照字典序排列。

注意，如果offset太大，定位offset就可能遍历整个有序集合，这会增加O(N)的复杂度。

可选参数WITHSCORES会返回元素和其分数，而不只是元素。这个选项在redis2.0之后的版本都可用。

127.0.0.1:6379> zadd k 1 a 2 b 3 c 4 d 5 e 6 f
(integer) 6
127.0.0.1:6379> ZRANGEBYSCORE k -inf +inf
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"
127.0.0.1:6379> ZRANGEBYSCORE k 1 2
1) "a"
2) "b"
127.0.0.1:6379> ZRANGEBYSCORE k 1 2 withscores
1) "a"
2) "1"
3) "b"
4) "2"
127.0.0.1:6379> ZRANGEBYSCORE k (1 2 withscores
1) "b"
2) "2"
127.0.0.1:6379> ZRANGEBYSCORE k (1 (2 withscores
(empty list or set)
127.0.0.1:6379> ZRANGEBYSCORE k (1 (3 withscores
1) "b"
2) "2"
127.0.0.1:6379> ZRANGEBYSCORE k -inf +inf withscores LIMIT 0 2
1) "a"
2) "1"
3) "b"
4) "2"

ZRANK key member

返回有序集key中成员member的排名，其中有序集合成员按score值递增并且以0开始。

返回值：

• 如果member是有序集key的成员，返回：member的排名。
• 如果member不是有序集key的成员，返回: nil。

127.0.0.1:6379> zadd k 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> ZRANK k b
(integer) 1

ZREM key member [member …]

删除指定元素。当key存在，但是其不是有序集合类型，就返回一个错误

127.0.0.1:6379> zadd k 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zadd k 4 a
(integer) 0
127.0.0.1:6379> ZREM k a
(integer) 1
127.0.0.1:6379> ZRANGE k 0 -1 withscores
1) "b"
2) "2"
3) "c"
4) "3"

ZREMRANGEBYLEX key min max

删除名称按字典由低到高排序成员之间的所有成员。不要在成员分数不同的有序集合中使用此命令，因为他是基于分数一致的有序集合设计的，如果使用 ，会导致删除的结果不正确。

返回值：

删除元素的个数

127.0.0.1:6379> zadd k 0 a 0 aa 0 abc 0 appl 0 b 0 c 0  d 0 d1 0 dd 0 dobb1
(integer) 8
127.0.0.1:6379> ZRANGE k 0 -1
 1) "a"
 2) "aa"
 3) "abc"
 4) "appl"
 5) "b"
 6) "c"
 7) "d"
 8) "d1"
 9) "dd"
10) "dobb1"
127.0.0.1:6379> ZREMRANGEBYLEX k (a [abc
(integer) 2
127.0.0.1:6379> ZRANGE k 0 -1
1) "a"
2) "appl"
3) "b"
4) "c"
5) "d"
6) "d1"
7) "dd"
8) "dobb1"
127.0.0.1:6379>
127.0.0.1:6379> ZREMRANGEBYLEX k - +
(integer) 8
127.0.0.1:6379> ZREMRANGEBYLEX k - +
(integer) 0
127.0.0.1:6379> ZRANGE k 0 -1
(empty list or set)

ZREMRANGEBYRANK key start stop

删除有序集合key中，指定排名区间内的所有成员。start 和 stop都以0为低，0处世分数最小的那个元素。负数表示位移从最高分处开始数。

返回值：

被移除成员的数量

127.0.0.1:6379> zadd k 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> ZREMRANGEBYRANK k 0 1
(integer) 2
127.0.0.1:6379> ZRANGE k 0 -1
1) "three"
127.0.0.1:6379> ZRANGE k 0 -1 withscores
1) "three"
2) "3"

ZREMRANGEBYSCORE key min max

移除有序集key中，所有score值介于min和max之间的成员，包含min和max。2.1.6开始就不包含min和max了。

返回值：

删除的元素的个数。

127.0.0.1:6379> zadd k 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> ZREMRANGEBYSCORE k -inf (2
(integer) 1
127.0.0.1:6379> ZRANGE k 0 -1 withscores
1) "two"
2) "2"
3) "three"
4) "3

ZREVRANGE key start stop [WITHSCORES]

返回有序集key中指定区间内的成员。其中成员的位置按score值递减。具有相同score值的成员按字典序的反序排列。除了成员按score值递减的次序排列这一点外，其他方面和ZRANGE命令一样。

127.0.0.1:6379> zadd k 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> ZREVRANGE k 0 -1
1) "three"
2) "two"
3) "one"

ZREVRANGEBYLEX key max min [LIMIT offset count]

ZREVRANGEBYLEX 返回指定成员区间内的成员，按成员字典倒序排序, 分数必须相同。在某些业务场景中,需要对一个字符串数组按名称的字典顺序进行倒序排列时,可以使用Redis中SortSet这种数据结构来处理。

提示：

• 分数必须相同! 如果有序集合中的成员分数有不一致的,返回的结果就不准。
• 成员字符串作为二进制数组的字节数进行比较。
• 默认是以ASCII字符集的顺序进行排列。如果成员字符串包含utf-8这类字符集的内容,就会影响返回结果,所以建议不要使用。
• 源码中采用C语言中memcmp()函数, 从字符的第0位到最后一位进行排序,如果前面部分相同,那么较长的字符串比较短的字符串排序靠前。
• 默认情况下, “max” 和 “min” 参数前必须加 “[” 符号作为开头。”[” 符号与成员之间不能有空格, 返回成员结果集会包含参数 “max”和 “min”
• “max” 和 “min” 参数前可以加 “(“ 符号作为开头表示小于, “(“ 符号与成员之间不能有空格。返回成员结果集不会包含 “max” 和 “min” 成员。
• 可以使用 “-“ 和 “+” 表示得分最小值和最大值
• “max”和 “min” 不能反, “max” 放后面 “min”放前面会导致返回结果为空
• 与ZREVRANGEBYLEX获取顺序相反的指令是ZRANGEBYLEX。

返回值：

指定成员范围的元素列表。

127.0.0.1:6379> zadd k  0 a 0 aa 0 abc 0 apple 0 b 0 c 0 d 0 d1 0 dd 0 dobble 0 z 0 z1
(integer) 12
127.0.0.1:6379> ZREVRANGEBYLEX k + -
 1) "z1"
 2) "z"
 3) "dobble"
 4) "dd"
 5) "d1"
 6) "d"
 7) "c"
 8) "b"
 9) "apple"
10) "abc"
11) "aa"
12) "a"
127.0.0.1:6379> ZREVRANGEBYLEX k + - LIMIT 0 3
1) "z1"
2) "z"
3) "dobble"
127.0.0.1:6379> ZREVRANGEBYLEX k [z + LIMIT 0 3
(empty list or set)
127.0.0.1:6379> ZREVRANGEBYLEX k [z - LIMIT 0 3
1) "z"
2) "dobble"
3) "dd"

使用场景实例：

电话号码排序：

redis> zadd phone 0 13100111100 0 13110114300 0 13132110901 
(integer) 3
redis> zadd phone 0 13200111100 0 13210414300 0 13252110901 
(integer) 3
redis> zadd phone 0 13300111100 0 13310414300 0 13352110901 
(integer) 3

从大到小获取所有号码:

redis> ZREVRANGEBYLEX phone + -
1) "13352110901"
2) "13310414300"
3) "13300111100"
4) "13252110901"
5) "13210414300"
6) "13200111100"
7) "13132110901"
8) "13110114300"
9) "13100111100"

获取132号段:

redis> ZREVRANGEBYLEX phone (133 [132
1) "13252110901"
2) "13210414300"
3) "13200111100"

获取132、133号段:

redis> ZREVRANGEBYLEX phone (134 [132
1) "13352110901"
2) "13310414300"
3) "13300111100"
4) "13252110901"
5) "13210414300"
6) "13200111100"

姓名排序

将名称存储到SortSet中:

redis> zadd names 0 Toumas 0 Jake 0 Bluetuo 0 Gaodeng 0 Aimini 0 Aidehua 
(integer) 6

获取所有人的名字倒序排列:

redis> ZREVRANGEBYLEX names + -
1) "Toumas"
2) "Jake"
3) "Gaodeng"
4) "Bluetuo"
5) "Aimini"
6) "Aidehua"

获取名字中大写字母A开头的所有人:

redis> ZREVRANGEBYLEX names (B [A
1) "Aimini"
2) "Aidehua"

获取名字中大写字母C到Z的所有人:

redis> ZREVRANGEBYLEX names [Z [C
1) "Toumas"
2) "Jake"
3) "Gaodeng"

后面的例子就直接复制的官网，发现这个命令可能会用的比较多。

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

返回有序集合中指定分数区间内的成员，分数由高到底。

提示:

• "max" 和 "min"参数前可以加 "(" 符号作为开头表示小于, "(" 符号与成员之间不能有空格
• 可以使用 "+inf" 和 "-inf" 表示得分最大值和最小值
• "max" 和 "min" 不能反, "max" 放后面 "min"放前面会导致返回结果为空
• 计算成员之间的成员数量不加 "(" 符号时,参数 "min" 和 "max" 的位置也计算在内。
• ZREVRANGEBYSCORE集合中按得分从高到底排序,所以"max"在前面,"min"在后面, ZRANGEBYSCORE集合中按得分从底到高排序,所以"min"在前面,"max"在后面。

127.0.0.1:6379> zadd k 1 "one" 2 "two" 3 "three"
(integer) 3
127.0.0.1:6379> ZREVRANGEBYSCORE k +inf -inf Withscores
1) "three"
2) "3"
3) "two"
4) "2"
5) "one"
6) "1"

应用：

实时新闻

ZREVRANK key member

返回有序集key中成员member的排名，其中有序集成员按score值从大到小排列。排名以0为底，也就是说，score值最大的成员排名为0。

使用ZRANK命令可以获得成员按score值递增(从小到大)排列的排名。

返回值：

• 如果member是有序集key的成员，返回integer-reply:member的排名。
• 如果member不是有序集key的成员，返回bulk-string-reply: nil。

redis> ZADD myzset 1 "one"
(integer) 1
redis> ZADD myzset 2 "two"
(integer) 1
redis> ZADD myzset 3 "three"
(integer) 1
redis> ZREVRANK myzset "one"
(integer) 2
redis> ZREVRANK myzset "four"
(nil)
redis> 

ZSCAN key cursor [MATCH pattern] [COUNT count]

增量式迭代命令和前面的HSCAN差不多。

127.0.0.1:6379> ZADD K 0 a 1 b 2 c 3 d 4 e 5 f 6 g
(integer) 7
127.0.0.1:6379> ZADD K 0 aa 1 bb 2 cc 3 dd 4 ee 5 ff 6 gg
(integer) 7
127.0.0.1:6379> ZADD K 0 aaa 1 bbb 2 ccc 3 ddd 4 eee 5 fff 6 ggg
(integer) 7
127.0.0.1:6379> ZSCAN K 0
1) "0"
2)  1) "a"
    2) "0"
    3) "aa"
    4) "0"
    5) "aaa"
    6) "0"
    7) "b"
    8) "1"
    9) "bb"
   10) "1"
   11) "bbb"
   12) "1"
   13) "c"
   14) "2"
   15) "cc"
   16) "2"
   17) "ccc"
   18) "2"
   19) "d"
   20) "3"
   21) "dd"
   22) "3"
   23) "ddd"
   24) "3"
   25) "e"
   26) "4"
   27) "ee"
   28) "4"
   29) "eee"
   30) "4"
   31) "f"
   32) "5"
   33) "ff"
   34) "5"
   35) "fff"
   36) "5"
   37) "g"
   38) "6"
   39) "gg"
   40) "6"
   41) "ggg"
   42) "6"

不过为什么Count参数依旧没有效果，谁能告诉我。。。。

ZSCORE key member

返回有序集key中，成员member的score值。

如果member元素不是有序集key的成员，或key不存在，返回nil。

127.0.0.1:6379> zadd k 0 a 2 b
(integer) 2
127.0.0.1:6379> ZSCORE k a
"0"

ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight] [SUM|MIN|MAX]

计算给定的numkeys个有序集合的并集，并且把结果放到destination中。在给定要计算的key和其它参数之前，必须先给定key个数(numberkeys)。 默认情况下，结果集中某个成员的score值是所有给定集下该成员score值之和。使用WEIGHTS选项，你可以为每个给定的有序集指定一个乘法因子，意思就是，每个给定有序集的所有成员的score值在传递给聚合函数之前都要先乘以该因子。如果WEIGHTS没有给定，默认就是1。

使用AGGREGATE选项，你可以指定并集的结果集的聚合方式。默认使用的参数SUM，可以将所有集合中某个成员的score值之和作为结果集中该成员的score值。如果使用参数MIN或者MAX，结果集就是所有集合中元素最小或最大的元素。

如果key destination存在，就被覆盖。

返回值：

结果有序集合destination中元素个数。

127.0.0.1:6379> zadd k 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zadd k1 0 a 1 b 2 D
(integer) 3
127.0.0.1:6379> ZUNIONSTORE OUT 2 k  k1
(integer) 4
127.0.0.1:6379> ZRANGE OUT 0 -1
1) "a"
2) "D"
3) "b"
4) "c"
127.0.0.1:6379> ZRANGE OUT 0 -1 withscores
1) "a"
2) "0"
3) "D"
4) "2"
5) "b"
6) "2"
7) "c"
8) "2"
127.0.0.1:6379> ZUNIONSTORE OUT 2 k  k1 weights 2 3
(integer) 4
127.0.0.1:6379> ZRANGE OUT 0 -1 withscores
1) "a"
2) "0"
3) "c"
4) "4"
5) "b"
6) "5"
7) "D"
8) "6"

hree"
(integer) 1
redis> ZREVRANK myzset “one”
(integer) 2
redis> ZREVRANK myzset “four”
(nil)
redis>

### ZSCAN key cursor [MATCH pattern] [COUNT count]

增量式迭代命令和前面的HSCAN差不多。

```bash
127.0.0.1:6379> ZADD K 0 a 1 b 2 c 3 d 4 e 5 f 6 g
(integer) 7
127.0.0.1:6379> ZADD K 0 aa 1 bb 2 cc 3 dd 4 ee 5 ff 6 gg
(integer) 7
127.0.0.1:6379> ZADD K 0 aaa 1 bbb 2 ccc 3 ddd 4 eee 5 fff 6 ggg
(integer) 7
127.0.0.1:6379> ZSCAN K 0
1) "0"
2)  1) "a"
    2) "0"
    3) "aa"
    4) "0"
    5) "aaa"
    6) "0"
    7) "b"
    8) "1"
    9) "bb"
   10) "1"
   11) "bbb"
   12) "1"
   13) "c"
   14) "2"
   15) "cc"
   16) "2"
   17) "ccc"
   18) "2"
   19) "d"
   20) "3"
   21) "dd"
   22) "3"
   23) "ddd"
   24) "3"
   25) "e"
   26) "4"
   27) "ee"
   28) "4"
   29) "eee"
   30) "4"
   31) "f"
   32) "5"
   33) "ff"
   34) "5"
   35) "fff"
   36) "5"
   37) "g"
   38) "6"
   39) "gg"
   40) "6"
   41) "ggg"
   42) "6"

不过为什么Count参数依旧没有效果，谁能告诉我。。。。

ZSCORE key member

返回有序集key中，成员member的score值。

如果member元素不是有序集key的成员，或key不存在，返回nil。

127.0.0.1:6379> zadd k 0 a 2 b
(integer) 2
127.0.0.1:6379> ZSCORE k a
"0"

ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight] [SUM|MIN|MAX]

计算给定的numkeys个有序集合的并集，并且把结果放到destination中。在给定要计算的key和其它参数之前，必须先给定key个数(numberkeys)。 默认情况下，结果集中某个成员的score值是所有给定集下该成员score值之和。使用WEIGHTS选项，你可以为每个给定的有序集指定一个乘法因子，意思就是，每个给定有序集的所有成员的score值在传递给聚合函数之前都要先乘以该因子。如果WEIGHTS没有给定，默认就是1。

使用AGGREGATE选项，你可以指定并集的结果集的聚合方式。默认使用的参数SUM，可以将所有集合中某个成员的score值之和作为结果集中该成员的score值。如果使用参数MIN或者MAX，结果集就是所有集合中元素最小或最大的元素。

如果key destination存在，就被覆盖。

返回值：

结果有序集合destination中元素个数。

127.0.0.1:6379> zadd k 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zadd k1 0 a 1 b 2 D
(integer) 3
127.0.0.1:6379> ZUNIONSTORE OUT 2 k  k1
(integer) 4
127.0.0.1:6379> ZRANGE OUT 0 -1
1) "a"
2) "D"
3) "b"
4) "c"
127.0.0.1:6379> ZRANGE OUT 0 -1 withscores
1) "a"
2) "0"
3) "D"
4) "2"
5) "b"
6) "2"
7) "c"
8) "2"
127.0.0.1:6379> ZUNIONSTORE OUT 2 k  k1 weights 2 3
(integer) 4
127.0.0.1:6379> ZRANGE OUT 0 -1 withscores
1) "a"
2) "0"
3) "c"
4) "4"
5) "b"
6) "5"
7) "D"
8) "6"