Redis命令参考手册(五大基本数据类型)

$参考资料$
http://redisdoc.com/index.html

$字符串$

$set$

set key value [EX seconds] [PX milliseconds] [NX|XX]
将字符串value关联到key。如果key已经持有其他值，set就覆写旧值，无视类型。
当set命令对一个带有生存时间TTL的键进行设置之后，该键原有的TTL被清除。

可选参数
从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改：

• EX seconds：将键的过期时间涉设置为seconds秒，执行set key value EX seconds的效果等同于setex key seconds value
• PX milliseconds：将键的过期时间设置为milliseconds毫秒，执行set key value PX milliseconds的效果等同于执行psetex key milliseconds value
• NX：只在键不存在时， 才对键进行设置操作。 执行 SET key value NX的效果等同于执行 SETNX key value
• XX： 只在键已经存在时， 才对键进行设置操作。

因为 SET 命令可以通过参数来实现 SETNX 、 SETEX 以及 PSETEX 命令的效果， 所以 Redis 将来的版本可能会移除并废弃 SETNX 、 SETEX 和 PSETEX 这三个命令

返回值
在 Redis 2.6.12 版本以前，SET命令总是返回 OK。

从 Redis 2.6.12 版本开始，SET命令只在设置操作成功完成时才返回OK ； 如果命令使用了NX 或者XX 选项， 但是因为条件没达到而造成设置操作未执行， 那么命令将返回空批量回复（NULL Bulk Reply）

代码示例

# 对不存在的键进行设置
set key 'value'  # ok
get key  # 'value'

# 对已存在的键进行设置
set key 'new-value' # ok
get key  # ‘new-value’

# 使用 ex 选项
SET key-with-expire-time "hello" EX 10086 	 # ok
get key-with-expire-time  # 'hello'
TTL key-with-expire-time   # (integer) 10057

# 使用 px 选项
SET key-with-pexpire-time "moto" PX 123321  # ok
GET key-with-pexpire-time    # "moto"
PTTL key-with-pexpire-time    # (integer) 111939

# 使用 NX 选项
SET not-exists-key "value" NX   # ok  键不存在，设置成功
GET not-exists-key  # 'value'
SET not-exists-key "new-value" NX   # nil 键已经存在，设置失败
GET not-exists-key   # 'value'  维持原值不变

# 使用 XX 选项
EXISTS exists-key # (integer) 0
SET exists-key "value" XX  # nil  因为键不存在，设置失败
SET exists-key "value" # ok 先给键设置一个值
SET exists-key "new-value" XX  # nil 设置新值成功
GET exists-key   # 'new-value'

$setnx$

setnx key value
只在键key 不存在的情况下， 将键 key 的值设置为 value 。
若键 key 已经存在， 则 SETNX 命令不做任何动作。
SETNX 是 『SET if Not eXists』 (如果不存在，则 SET)的简写。

返回值
命令在设置成功时返回 1 ， 设置失败时返回 0 。

代码示例

EXISTS job  # (integer)0 job 不存在
SETNX job 'programmer' # (integer)1 job设置成功
SETNX job 'coder' # (integer)0 尝试覆盖job 失败
GET job # 'programmer' 没有被覆盖

$setex$

setex key seconds value
将键key 的值设置为 value， 并将键 key 的生存时间设置为 seconds秒钟。
如果键key已经存在， 那么 SETEX命令将覆盖已有的值。
SETEX命令的效果和以下两个命令的效果类似：

SET key value
EXPIRE key seconds  # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的时候非常实用

返回值
命令在设置成功时返回 OK。 当 seconds 参数不合法时， 命令将返回一个错误。

代码示例

# 在键 key 不存在的情况下执行 SETEX
SETEX cache_user_id 60 10086 # ok
GET cache_user_id  # 10086
TTL cache_user_id  # (integer)49 剩余生存时间

# 键 key 已经存在， 使用 SETEX 覆盖旧值
set cd 'timeless'   # ok
setex cd 3000 'goodby'  # ok
get cd  # 'goodby'
ttl cd # (integer)2997

$psetex$

PSETEX key milliseconds value
这个命令和 SETEX命令相似， 但它以毫秒为单位设置 key的生存时间， 而不是像 SETEX命令那样以秒为单位进行设置。

返回值
命令在设置成功时返回 OK 。

代码示例

PSETEX mykey 1000 "Hello"
PTTL mykey  # (integer)999
GET mykey # 'Hello'

$get$

GET key
返回与键 key 相关联的字符串值。

返回值
如果键key 不存在， 那么返回特殊值 nil； 否则， 返回键 key的值。
如果键key的值并非字符串类型， 那么返回一个错误， 因为GET 命令只能用于字符串值

代码示例

# 对不存在的键 key 或是字符串类型的键 key 执行 GET 命令：
GET db # nil
SET db redis # ok
GET db  # "redis"

# 对不是字符串类型的键 key 执行 GET 命令：
DEL db # (integer)1
LPUSH db redis mongodb mysql # (integer)3
GET db # (error) ERR Operation against a key holding the wrong kind of value

$getset$

GETSET key value
将键key 的值设为 value ， 并返回键 key 在被设置之前的旧值。

返回值
返回给定键 key的旧值。
如果键 key没有旧值， 也即是说， 键 key 在被设置之前并不存在， 那么命令返回 nil 。
当键 key 存在但不是字符串类型时， 命令返回一个错误。

代码示例

GETSET db mongodb  # nil 没有旧值 返回nil
GET db  # 'mongodb'
GETSET DB redis # 'mongodb' 返回旧值mongodb
GET db # 'redis'

$strlen$

strlen key
返回键key存储的字符串值得长度

返回值
STRLEN 命令返回字符串值的长度。
当键 key 不存在时， 命令返回 0 。
当 key 储存的不是字符串值时， 返回一个错误。

代码示例

# 获取字符串值的长度
set mykey "hello world"  # ok
strlen mykey  # (integer)11

# 不存在的键长度为0
strlen nonexisting # (integer) 0

$append$

append key value
如果键key已经存在并且它的值是一个字符串，append命令将把value追加到键key现有值的末尾。
如果键key不存在，append就简单的将key的值设为value，就像执行set key value

返回值
追加value之后，键key的值的长度

示例代码

# 对不存在的 key 执行 APPEND 
exists myname  # (integer)0 myname不存在
append myname  '刘三'  # 不存在的 key 进行 APPEND ，等同于 SET myphone "nokia"
# (integer) 2 返回字符串的长度

# 对已存在的字符串进行 APPEND 
APPEND myname "思"     # 长度从 2个字符增加到3个字符
GET myphone  # '刘三思'

$setrange$

setrange key offset value
从偏移量offset开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。
不存在的键key 当作空白字符串处理。

SETRANGE 命令会确保字符串足够长以便将 value 设置到指定的偏移量上， 如果键key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长，但你设置的offset 是 10 )， 那么原字符和偏移量之间的空白将用零字节(zerobytes, "\x00")进行填充。

因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内， 所以用户能够使用的最大偏移量为 2^29-1(536870911) ， 如果你需要使用比这更大的空间， 请使用多个key。

当生成一个很长的字符串时， Redis 需要分配内存空间， 该操作有时候可能会造成服务器阻塞(block)。 在2010年出产的Macbook Pro上， 设置偏移量为 536870911(512MB 内存分配)将耗费约 300 毫秒， 设置偏移量为 134217728(128MB 内存分配)将耗费约 80 毫秒， 设置偏移量 33554432(32MB 内存分配)将耗费约 30 毫秒， 设置偏移量为 8388608(8MB 内存分配)将耗费约 8 毫秒。

返回值
setrange命令会返回被修改之后，字符串值的长度。

代码示例

# 对非空字符串执行setrange 命令
set greeting 'hi xixi' # ok
setrange greeting 3 'redis' # 8
get greeting # 'hello redis'

# 对空字符串/不存在的键执行 setrange 命令
exists emptystr # (inerger) 0
setrange emptystr 5 'redis' # (integer)10  对不存在的 key 使用 SETRANGE
get emptystr # "\x00\x00\x00\x00\x00redis"   空白处被\x00填充

$getrange$

返回键 key 储存的字符串值的指定部分(这是一个闭区间)， 字符串的截取范围由start 和 end 两个偏移量决定 (包括start 和 end在内)。
负数偏移量表示从字符串的末尾开始计数，-1表示最后一个字符，-2表示倒数第二个字符， 以此类推。
GETRANGE通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

GETRANGE 命令在 Redis 2.0 之前的版本里面被称为 SUBSTR 命令。

返回值
GETRANGE 命令会返回字符串值的指定部分(闭区间)

代码示例

set k1 'hello myboy'
getrange k1 0 4 # 'hello'  返回索引0-4的字符 包括4
getrange k1 -1 -5 # 为空  不支持回绕操作
getrange k1 -3 -1 # 'boy'  负数索引
getrange k1 0 -1 # 返回键k1对应的值
getrange k1 0 11111  # 值域超过实际字符的长度 超过部分自定被忽略 返回对应的值

$incr$

incr key
为键 key储存的数字值加上一。
如果键 key不存在， 那么它的值会先被初始化为0 ， 然后再执行INCR 命令。
如果键 key储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

INCR 命令是一个针对字符串的操作。 因为 Redis 并没有专用的整数类型， 所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

返回值
INCR命令会返回键key 在执行加一操作之后的值。

代码示例

set page 20 
incr page  # (integet) 21
get page  # '21'   数字值在 Redis 中以字符串的形式保存

$incrby$

incrby key increment
为键 key 储存的数字值加上增量increment 。
如果键 key不存在， 那么键key 的值会先被初始化为 0 ， 然后再执行INCRBY命令。
如果键 key 储存的值不能被解释为数字， 那么 INCRBY 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。
$关于递增(increment)/递减(decrement)操作的更多信息，请参见INCR命令的文档$

返回值
在加上增量 increment 之后， 键key 当前的值。

代码示例

# 键存在 并且值为数字
set rank 50
incrby increment 20
get rank

# 键不存在
exists counter
incrby counter 30 
get counter  # '30'

# 键存在，但值无法被解释为数字：
set book 'xxxxx'
incrby book 10   # (error) ERR value is not an integer or out of range

$incrbyfloat$

incrbyfloat key increment
为键key 储存的值加上浮点数增量increment。
如果键key不存在， 那么 INCRBYFLOAT 会先将键key 的值设为 0 ， 然后再执行加法操作。
如果命令执行成功， 那么键 key 的值会被更新为执行加法计算之后的新值， 并且新值会以字符串的形式返回给调用者。

无论是键 key 的值还是增量 increment ， 都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示， 但是， 执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存， 也即是， 它们总是由一个数字， 一个（可选的）小数点和一个任意长度的小数部分组成（比如 3.14 、 69.768 ，诸如此类)， 小数部分尾随的 0 会被移除， 如果可能的话， 命令还会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。
此外， 无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 命令的计算结果最多只保留小数点的后十七位。
当以下任意一个条件发生时， 命令返回一个错误：

• 键 key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）；
• 键 key 当前的值或者给定的增量 increment 不能被解释(parse)为双精度浮点数。

返回值
在加上增量 increment之后， 键key的值。

代码示例

set num 3.0
incrbyfloat num 2.1
get num   # 5.1

$decr$

decr key
为键key储存的数字值减去一。
如果键key不存在， 那么键 key 的值会先被初始化为0 ， 然后再执行DECR操作。
如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

$关于递增(increment)/递减(decrement)操作的更多信息，请参见INCR命令的文档。$

返回值
DECR命令会返回键 key 在执行减一操作之后的值。

代码示例

# 对储存数字值的键 key 执行 DECR 命令
SET failure_times 10  # ok
DECR failure_times  # 9

# 对不存在的键执行 DECR 命令
EXISTS count
DECR count  # -1

$decrby$

decrby key decrement
将键 key 储存的整数值减去减量 decrement。
如果键key不存在， 那么键 key 的值会先被初始化为 0， 然后再执行DECRBY 命令。
如果键 key储存的值不能被解释为数字， 那么 DECRBY命令将返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

返回值
decrby命令会返回键在执行减法操作之后的值

代码示例

# 对已经存在的键执行 DECRBY 命令
set count 100
decrby count 20  # 80

# 对不存在的键执行 DECRBY 命令
exists pages
decrby pages 10  # (integer) -10

$mset$

mset key value [key value]
同时为多个键设置值。
如果某个给定键已经存在， 那么 MSET将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。

MSET是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。

返回值
MSET 命令总是返回OK 。

代码示例

# 同时对多个键进行设置
MSET date "2012.3.30" time "11:00 a.m." weather "sunny"  # ok
MGET data time weather  
# 1) "2012.3.30"
# 2) "11:00 a.m."
# 3) "sunny"

# 覆盖已有的值
MGET k1 k2
# 1) "hello"
# 2) "world"
MSET k1 "good" k2 "bye"

MGET k1 k2
# 1) "good"
# 2) "bye"

$msetnx$

msetnx key value [key value]
当且仅当所有给定键都不存在时， 为所有给定键设置值。
即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
MSETNX是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

返回值
当所有给定键都设置成功时， 命令返回 1 ； 如果因为某个给定键已经存在而导致设置未能成功执行， 那么命令返回 0 。

代码示例

# 对不存在的键执行 MSETNX 命令
MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"
MGET rmdbs nosql key-value-store
# 1) "MySQL"
# 2) "MongoDB"
# 3) "redis"

# 对某个已经存在的键进行设置
MSETNX rmdbs "Sqlite" language "python" # rmdbs 键已经存在，操作失败
EXISTS language  # 因为 MSETNX 命令没有成功执行 所以 language 键没有被设置
GET rmdbs   # rmdbs 键也没有被修改
# MySQL

$mget$

mget key [key,key...]
返回给定的一个或多个字符串键的值。
如果给定的字符串键里面， 有某个键不存在， 那么这个键的值将以特殊值nil表示。

返回值
MGET 命令将返回一个列表， 列表中包含了所有给定键的值。

示例代码

SET redis redis.com
SET mongodb mongodb.org
MGET redis mongodb
MGET redis mongodb mysql  # 不存在的 mysql 返回 nil
# 1) "redis.com"
# 2) "mongodb.org"
# 3) (nil)

$哈希表$

$hset$

hset hash field value
将哈希表hash中域field 的值设置为value 。
如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。
如果域field 已经存在于哈希表中， 那么它的旧值将被新值value覆盖。

返回值
当 HSET 命令在哈希表中新创建field域并成功为它设置值时， 命令返回1； 如果域 field已经存在于哈希表， 并且 HSET 命令成功使用新值覆盖了它的旧值， 那么命令返回0。

代码示例

# 设置一个新域
hset website google 'www.google.com' # (integer)1
hget website google # 'www.google.com'

# 对一个已存在的域进行更新
HSET website google "www.google.net"
HGET website google # "www.google.net"

$hsetnx$

当且仅当域 field尚未存在于哈希表的情况下， 将它的值设置为value 。
如果给定域已经存在于哈希表当中， 那么命令将放弃执行设置操作。
如果哈希表hash不存在， 那么一个新的哈希表将被创建并执行HSETNX命令

返回值
HSETNX 命令在设置成功时返回 1 ， 在给定域已经存在而放弃执行设置操作时返回0 。

代码示例

# 域尚未存在， 设置成功
HSETNX database key-value-store Redis  # (integer) 1
HGET database key-value-store # "Redis"

# 域已经存在， 设置未成功， 域原有的值未被改变
HSETNX database key-value-store Riak  # (integer) 0
HGET database key-value-store  # "Redis"

$hget$

hget hash field
返回哈希表中给定域的值

返回值
HGET 命令在默认情况下返回给定域的值。
如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil 。

代码示例

# 域存在的情况
hset homepage redis reids.com  # (integer) 1
hget homepage redis  # "redis.com"

# 域不存在的情况
hget site mysql #(nil)

$hexists$

检查给定域field 是否存在于哈希表 hash当中。

返回值
HEXISTS命令在给定域存在时返回1 ， 在给定域不存在时返回0。

代码示例

# 给定域不存在
hexists phone myphone # (integer)0

# 给定域存在
hset phone myphone 110 # (integet) 1
hexists phone myphone # (integer) 1

$hdel$

hdel key value [field...]

删除哈希表 key中的一个或多个指定域，不存在的域将被忽略

在Redis2.4以下的版本里， HDEL 每次只能删除单个域，如果你需要在一个原子时间内删除多个域，请将命令包含在 MULTI / EXEC 块内。

HGETALL abbr
# 1) "a"
# 2) "apple"
# 3) "b"
# 4) "banana"
# 5) "c"
# 6) "cat"
# 7) "d"
# 8) "dog"

# 删除单个域
HDEL abbr a  # (integer) 1

# 删除不存在的域
HDEL abbr not-exists-field  #(integer) 0

# 删除多个域
HDEL abbr b c  #(integer) 2

HGETALL abbr
# 1) "d"
# 2) "dog"

$hlen$

hlen key
返回哈希表 key中域的数量。

返回值
哈希表中域的数量。
当key不存在时，返回 0。

hset db redis redis.com
hset db mysql mysql.com
hlen db
hset db mongodb mongodb.org
hlen db

$hstrlen$

返回哈希表key 中， 与给定域field相关联的值的字符串长度（string length）。

如果给定的键或者域不存在， 那么命令返回 0 。

redis> HMSET myhash f1 "HelloWorld" f2 "99" f3 "-256"
OK
redis> HSTRLEN myhash f1
(integer) 10
redis> HSTRLEN myhash f2
(integer) 2
redis> HSTRLEN myhash f3
(integer) 4

$hincrby$

incrby key field increment
为哈希表key 中的域field 的值加上增量increment 。
增量也可以为负数，相当于对给定域进行减法操作。
如果 key不存在，一个新的哈希表被创建并执行 HINCRBY命令。
如果域 field不存在，那么在执行命令前，域的值被初始化为0。
对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。
本操作的值被限制在 64 位(bit)有符号数字表示之内。

# increment 为正数

redis> HEXISTS counter page_view    # 对空域进行设置
(integer) 0

redis> HINCRBY counter page_view 200
(integer) 200

redis> HGET counter page_view
"200"


# increment 为负数

redis> HGET counter page_view
"200"

redis> HINCRBY counter page_view -50
(integer) 150

redis> HGET counter page_view
"150"


# 尝试对字符串值的域执行HINCRBY命令

redis> HSET myhash string hello,world       # 设定一个字符串值
(integer) 1

redis> HGET myhash string
"hello,world"

redis> HINCRBY myhash string 1              # 命令执行失败，错误。
(error) ERR hash value is not an integer

redis> HGET myhash string                   # 原值不变
"hello,world"

$hincrbyfloat$

HINCRBYFLOAT key field increment
为哈希表 key中的域 field加上浮点数增量increment 。

如果哈希表中没有域field ，那么 HINCRBYFLOAT 会先将域 field的值设为 0 ，然后再执行加法操作。
如果键key 不存在，那么 HINCRBYFLOAT会先创建一个哈希表，再创建域 field ，最后再执行加法操作。
当以下任意一个条件发生时，返回一个错误：
域field的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
域field 当前的值或给定的增量 increment不能解释(parse)为双精度浮点数(double precision floating point number)
HINCRBYFLOAT命令的详细功能和INCRBYFLOAT key increment 命令类似，请查看 INCRBYFLOAT key increment命令获取更多相关信息。

# 值和增量都是普通小数

redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
"10.6"


# 值和增量都是指数符号

redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
"5200"


# 对不存在的键执行 HINCRBYFLOAT

redis> EXISTS price
(integer) 0
redis> HINCRBYFLOAT price milk 3.5
"3.5"
redis> HGETALL price
1) "milk"
2) "3.5"


# 对不存在的域进行 HINCRBYFLOAT

redis> HGETALL price
1) "milk"
2) "3.5"
redis> HINCRBYFLOAT price coffee 4.5   # 新增 coffee 域
"4.5"
redis> HGETALL price
1) "milk"
2) "3.5"
3) "coffee"
4) "4.5"

$hmset$

hmset key field value [field value...]
同时将多个field-value (域-值)对设置到哈希表 key 中。
此命令会覆盖哈希表中已存在的域。
如果 key不存在，一个空哈希表被创建并执行 HMSET 操作。

返回值
如果命令执行成功，返回OK。
当 key 不是哈希表(hash)类型时，返回一个错误。

示例代码

redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HGET website google
"www.google.com"

redis> HGET website yahoo
"www.yahoo.com"

$hmget$

HMGET key field [field …]
返回哈希表 key中，一个或多个给定域的值。
如果给定的域不存在于哈希表，那么返回一个 nil 值。
因为不存在的key被当作一个空哈希表来处理，所以对一个不存在的key 进行HMGET 操作将返回一个只带有 nil值的表。

返回值
一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

示例代码

redis> HMSET pet dog "doudou" cat "nounou"    # 一次设置多个域
OK

redis> HMGET pet dog cat fake_pet             # 返回值的顺序和传入参数的顺序一样
1) "doudou"
2) "nounou"
3) (nil)                                      # 不存在的域返回nil值

$hkeys$

HKEYS key
返回哈希表 key 中的所有域。
返回值
一个包含哈希表中所有域的表。
当 key 不存在时，返回一个空表。
示例代码

# 哈希表非空
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK
redis> HKEYS website
1) "google"
2) "yahoo"

# 空哈希表/key不存在
redis> EXISTS fake_key
(integer) 0

redis> HKEYS fake_key
(empty list or set)

$hvals$

HVALS key
返回哈希表 key 中所有域的值。

返回值：
一个包含哈希表中所有值的表。
当 key 不存在时，返回一个空表。

示例代码

# 非空哈希表
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK

redis> HVALS website
1) "www.google.com"
2) "www.yahoo.com"

# 空哈希表/不存在的key
redis> EXISTS not_exists
(integer) 0

redis> HVALS not_exists
(empty list or set)

$hgetall$

hgetall key
返回哈希表 key 中，所有的域和值。
在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

返回值
以列表形式返回哈希表的域和域的值。
若 key 不存在，返回空列表。

示例代码

redis> HSET people jack "Jack Sparrow"
(integer) 1

redis> HSET people gump "Forrest Gump"
(integer) 1

redis> HGETALL people
1) "jack"          # 域
2) "Jack Sparrow"  # 值
3) "gump"
4) "Forrest Gump"

$列表$

$lpush$

lpush key value [value]
将一个或多个值 value插入到列表 key 的表头
如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
如果 key不存在，一个空列表会被创建并执行 LPUSH 操作。
当 key 存在但不是列表类型时，返回一个错误。

返回值
执行lpush命令后，列表的长度

代码示例

# 加入单个元素
lpush languages python

# 加入重复元素
lpush languages python

# 加入多个元素
lpush mylist a b c

$lpushx$

lpushx key value
将值value插入到列表key 的表头，当且仅当key存在并且是一个列表。
和 LPUSH key value [value …] 命令相反，当key不存在时，LPUSHX 命令什么也不做。

返回值
lpushx 命令执行后，返回表的长度

示例代码

# 对空列表执行
llen greet  # 0 greet是一个空列表
lpushx greet hello # 尝试lpushx 失败 因为列表为空

# 对非空列表执行lpushx
lpush greet 'hello'
lpushx greet 'hi'
lrange greet 0 -1

$rpush$

将一个或多个值value插入到列表key的表尾(最右边)。

如果有多个 value 值，那么各个value 值按从左到右的顺序依次插入到表尾：比如对一个空列表mylist 执行 RPUSH mylist a b c，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c。
如果key 不存在，一个空列表会被创建并执行 RPUSH 操作
当 key存在但不是列表类型时，返回一个错误。

返回值
执行rpush操作后，表的长度

示例代码

# 添加单个元素
rpush languages C

# 添加重复元素
rpush languages C

# 添加多个元素
rpush mylist a b c

$rpushx$

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

返回值
rpushx执行后，返回的长度

代码示例

# 对空列表执行
llen greet  # 0 greet是一个空列表
rpushx greet hello # 尝试lpushx 失败 因为列表为空

# 对非空列表执行lpushx
rpush greet 'hello'
rpushx greet 'hi'
lrange greet 0 -1

$lpop$

lpop key
移除并返回列表key的头元素

返回值
列表的头元素，当key不存在时，返回nil

示例代码

rpush course algorithm
rpush course c++
lpop course # 移除头元素 'algorithm'

$rpop$

rpop key
移除并返回列表key的尾元素

返回值
列表的尾元素，当key不存在时，返回nil

示例代码

rpush mylist 1
rpush mylist 2
rpush mylist 3
rpop mylist # 3 返回并弹出尾部的元素

$rpoplpush$

rpoplpush source destination
命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

• 将列表 source中的最后一个元素(尾元素)弹出，并返回给客户端。
• 将source弹出的元素插入到列表destination ，作为 destination列表的的头元素。

举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。

如果source不存在，值nil 被返回，并且不执行其他动作。
如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

返回值
被弹出的元素

代码示例

# source destination不同
lpush source 1 2 3
rpoplpush source des
lrange des 0 -1 # 1

# source destination 相同
rpoplpush source source  # 2
lrange source 0 -1 # 2 3

模式： 安全的队列
Redis的列表经常被用作队列(queue)，用于在不同程序之间有序地交换消息(message)。一个客户端通过 LPUSH key value [value …] 命令将消息放入队列中，而另一个客户端通过 RPOP key 或者 BRPOP key [key …] timeout 命令取出队列中等待时间最长的消息。

不幸的是，上面的队列方法是『不安全』的，因为在这个过程中，一个客户端可能在取出一个消息之后崩溃，而未处理完的消息也就因此丢失。

使用 RPOPLPUSH 命令(或者它的阻塞版本 BRPOPLPUSH source destination timeout )可以解决这个问题：因为它不仅返回一个消息，同时还将这个消息添加到另一个备份列表当中，如果一切正常的话，当一个客户端完成某个消息的处理之后，可以用 LREM key count value 命令将这个消息从备份表删除。

最后，还可以添加一个客户端专门用于监视备份表，它自动地将超过一定处理时限的消息重新放入队列中去(负责处理该消息的客户端可能已经崩溃)，这样就不会丢失任何消息了。

模式：循环列表
通过使用相同的 key 作为 RPOPLPUSH 命令的两个参数，客户端可以用一个接一个地获取列表元素的方式，取得列表的所有元素，而不必像 LRANGE key start stop 命令那样一下子将所有列表元素都从服务器传送到客户端中(两种方式的总复杂度都是 O(N))。

以上的模式甚至在以下的两个情况下也能正常工作：

• 有多个客户端同时对同一个列表进行旋转(rotating)，它们获取不同的元素，直到所有元素都被读取完，之后又从头开始。
• 有客户端在向列表尾部(右边)添加新元素。

这个模式使得我们可以很容易实现这样一类系统：有 N 个客户端，需要连续不断地对一些元素进行处理，而且处理的过程必须尽可能地快。一个典型的例子就是服务器的监控程序：它们需要在尽可能短的时间内，并行地检查一组网站，确保它们的可访问性。

注意，使用这个模式的客户端是易于扩展(scala)且安全(reliable)的，因为就算接收到元素的客户端失败，元素还是保存在列表里面，不会丢失，等到下个迭代来临的时候，别的客户端又可以继续处理这些元素了。

$lrem$

lrem key count value
根据参数count的值，移除列表中与参数value相同的元素
count的值可以是以下几种：

• count > 0:从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count。
• count < 0 :从表尾开始向表头搜索，移除与value 相等的元素，数量为 count的绝对值。
• count = 0 :移除表中所有与value 相等的值。

返回值
被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

代码示例

# 先创建一个表，内容排列是
# morning hello morning helllo morning

redis> LPUSH greet "morning"
(integer) 1
redis> LPUSH greet "hello"
(integer) 2
redis> LPUSH greet "morning"
(integer) 3
redis> LPUSH greet "hello"
(integer) 4
redis> LPUSH greet "morning"
(integer) 5

redis> LRANGE greet 0 4         # 查看所有元素
1) "morning"
2) "hello"
3) "morning"
4) "hello"
5) "morning"

redis> LREM greet 2 morning     # 移除从表头到表尾，最先发现的两个 morning
(integer) 2                     # 两个元素被移除

redis> LLEN greet               # 还剩 3 个元素
(integer) 3

redis> LRANGE greet 0 2
1) "hello"
2) "hello"
3) "morning"

redis> LREM greet -1 morning    # 移除从表尾到表头，第一个 morning
(integer) 1

redis> LLEN greet               # 剩下两个元素
(integer) 2

redis> LRANGE greet 0 1
1) "hello"
2) "hello"

redis> LREM greet 0 hello      # 移除表中所有 hello
(integer) 2                    # 两个 hello 被移除

redis> LLEN greet
(integer) 0

$llen$

llen key
返回列表key的长度。
如果key不存在，则 key被解释为一个空列表，返回 0 .
如果key不是列表类型，返回一个错误。

返回值
列表 key 的长度

示例代码

llen job  # 0
lpush job 'run' 'eat'
llen job  # 2

$lindex$

lindx key index
返回列表 key 中，下标为 index的元素。
下标(index)参数start和 stop都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
如果 key 不是列表类型，返回一个错误。

返回值
列表中下标为 index的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

示例代码

redis> LPUSH mylist "World"
(integer) 1

redis> LPUSH mylist "Hello"
(integer) 2

redis> LINDEX mylist 0
"Hello"

redis> LINDEX mylist -1
"World"

redis> LINDEX mylist 3        # index不在 mylist 的区间范围内
(nil)

$linsert$

linsert key before |after pivot value
pivot：表示在列表中寻找的目的元素
将值 value 插入到列表key当中，位于值pivot之前或之后。
当 pivot不存在于列表 key时，不执行任何操作。
当key不存在时，key 被视为空列表，不执行任何操作。
如果key 不是列表类型，返回一个错误。

返回值
如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到pivot ，返回-1 。 如果 key 不存在或为空列表，返回 0 。

代码示例

redis> RPUSH mylist "Hello"
(integer) 1

redis> RPUSH mylist "World"
(integer) 2

redis> LINSERT mylist BEFORE "World" "There"
(integer) 3

redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"

# 对一个非空列表插入，查找一个不存在的 pivot

redis> LINSERT mylist BEFORE "go" "let's"
(integer) -1                                    # 失败

# 对一个空列表执行 LINSERT 命令

redis> EXISTS fake_list
(integer) 0

redis> LINSERT fake_list BEFORE "nono" "gogogog"
(integer) 0                                      # 失败

$lset$

lset key index value
将列表 key下标为index的元素的值设置为 value 。
当index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
关于列表下标的更多信息，请参考 LINDEX key index 命令。
返回值
操作成功返回 ok ，否则返回错误信息。
示例代码

# 对空列表(key 不存在)进行 LSET
redis> EXISTS list
(integer) 0

redis> LSET list 0 item
(error) ERR no such key

# 对非空列表进行 LSET
redis> LPUSH job "cook food"
(integer) 1

redis> LRANGE job 0 0
1) "cook food"

redis> LSET job 0 "play game"
OK

redis> LRANGE job  0 0
1) "play game"

# index 超出范围
redis> LLEN list                    # 列表长度为 1
(integer) 1

redis> LSET list 3 'out of range'
(error) ERR index out of range

$lrange$

lrange key start stop
返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

注意LRANGE命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表，对该列表执行 LRANGE list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LRANGE 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

返回值
一个列表，包含指定区间内的元素。

示例代码

redis> RPUSH fp-language lisp
(integer) 1

redis> LRANGE fp-language 0 0
1) "lisp"

redis> RPUSH fp-language scheme
(integer) 2

redis> LRANGE fp-language 0 1
1) "lisp"
2) "scheme"

$ltrim$

ltrim key start stop
对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
举个例子，执行命令LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
下标(index)参数start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
当 key 不是列表类型时，返回一个错误。

注意LTRIM命令和编程语言区间函数的区别
假如你有一个包含一百个元素的列表 list，对该列表执行LTRIM list 0 10 ，结果是一个包含11个元素的列表，这表明 stop 下标也在 LTRIM 命令的取值范围之内(闭区间)，这和某些语言的区间函数可能不一致，比如Ruby的 Range.new 、 Array#slice 和Python的 range() 函数。
超出范围的下标
超出范围的下标值不会引起错误。
如果start 下标比列表的最大下标 end (LLEN list 减去 1)还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。
如果 stop下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

返回值
命令执行成功时，返回ok 。

示例代码

# 情况 1： 常见情况， start 和 stop 都在列表的索引范围之内
redis> LRANGE alpha 0 -1       # alpha 是一个包含 5 个字符串的列表
1) "h"
2) "e"
3) "l"
4) "l"
5) "o"

redis> LTRIM alpha 1 -1        # 删除 alpha 列表索引为 0 的元素
OK

redis> LRANGE alpha 0 -1       # "h" 被删除了
1) "e"
2) "l"
3) "l"
4) "o"


# 情况 2： stop 比列表的最大下标还要大
redis> LTRIM alpha 1 10086     # 保留 alpha 列表索引 1 至索引 10086 上的元素
OK

redis> LRANGE alpha 0 -1       # 只有索引 0 上的元素 "e" 被删除了，其他元素还在
1) "l"
2) "l"
3) "o"


# 情况 3： start 和 stop 都比列表的最大下标要大，并且 start < stop
redis> LTRIM alpha 10086 123321
OK

redis> LRANGE alpha 0 -1        # 列表被清空
(empty list or set)


# 情况 4： start 和 stop 都比列表的最大下标要大，并且 start > stop
redis> RPUSH new-alpha "h" "e" "l" "l" "o"     # 重新建立一个新列表
(integer) 5

redis> LRANGE new-alpha 0 -1
1) "h"
2) "e"
3) "l"
4) "l"
5) "o"

redis> LTRIM new-alpha 123321 10086    # 执行 LTRIM
OK

redis> LRANGE new-alpha 0 -1           # 同样被清空
(empty list or set)

$blpop$

blpop key [key...] timeout
BLPOP 是列表的阻塞式(blocking)弹出原语。

它是 LPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个key参数时，按参数key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。

返回值
如果列表为空，返回一个 nil 。 否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

非阻塞行为
当 BLPOP 被调用时，如果给定key内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
当存在多个给定key 时， BLPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。

假设现在有job 、 command 和 request三个列表，其中 job 不存在， command 和 request 都持有非空列表。考虑以下命令：
BLPOP job command request 0
BLPOP 保证返回的元素来自 command ，因为它是按”查找 job -> 查找 command -> 查找 request “这样的顺序，第一个找到的非空列表。

redis> DEL job command request           # 确保key都被删除
(integer) 0

redis> LPUSH command "update system..."  # 为command列表增加一个值
(integer) 1

redis> LPUSH request "visit page"        # 为request列表增加一个值
(integer) 1

redis> BLPOP job command request 0       # job 列表为空，被跳过，紧接着 command 列表的第一个元素被弹出。
1) "command"                             # 弹出元素所属的列表
2) "update system..."                    # 弹出元素所属的值

阻塞行为
如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH key value [value …] 或 RPUSH key value [value …] 命令为止。

超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

redis> EXISTS job                # 确保两个 key 都不存在
(integer) 0
redis> EXISTS command
(integer) 0

redis> BLPOP job command 300     # 因为key一开始不存在，所以操作会被阻塞，直到另一客户端对 job 或者 command 列表进行 PUSH 操作。
1) "job"                         # 这里被 push 的是 job
2) "do my home work"             # 被弹出的值
(26.26s)                         # 等待的秒数

redis> BLPOP job command 5       # 等待超时的情况
(nil)
(5.66s)                          # 等待的秒数

相同的key被多个客户端同时阻塞
相同的 key 可以被多个客户端同时阻塞。
不同的客户端被放进一个队列中，按『先阻塞先服务』(first-BLPOP，first-served)的顺序为 key 执行 BLPOP 命令。

在MULTI/EXEC事务中的BLPOP
BLPOP 可以用于流水线(pipline,批量地发送多个命令并读入多个回复)，但把它用在 MULTI / EXEC块当中没有意义。因为这要求整个服务器被阻塞以保证块执行时的原子性，该行为阻止了其他客户端执行 LPUSH key value [value …]或 RPUSH key value [value …] 命令。

因此，一个被包裹在MULTI / EXEC 块内的 BLPOP 命令，行为表现得就像 LPOP key一样，对空列表返回nil，对非空列表弹出列表元素，不进行任何阻塞操作

# 对非空列表进行操作
redis> RPUSH job programming
(integer) 1

redis> MULTI
OK

redis> BLPOP job 30
QUEUED

redis> EXEC           # 不阻塞，立即返回
1) 1) "job"
   2) "programming"

# 对空列表进行操作
redis> LLEN job      # 空列表
(integer) 0

redis> MULTI
OK

redis> BLPOP job 30
QUEUED

redis> EXEC         # 不阻塞，立即返回
1) (nil)

$brpop$

brpop key [key...] timeout
BRPOP 是列表的阻塞式(blocking)弹出原语。

它是RPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个key参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。

关于阻塞操作的更多信息，请查看 BLPOP key [key …] timeout 命令， BRPOP 除了弹出元素的位置和 BLPOP key [key …] timeout 不同之外，其他表现一致。

返回值
假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

示例代码

redis> LLEN course
(integer) 0

redis> RPUSH course algorithm001
(integer) 1

redis> RPUSH course c++101
(integer) 2

redis> BRPOP course 30
1) "course"             # 被弹出元素所属的列表键
2) "c++101"             # 被弹出的元素

$brpoplpush$

brpoplpush source destination timeout
BRPOPLPUSH 是 RPOPLPUSH source destination 的阻塞版本，当给定列表 source不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH source destination 一样。
当列表 source为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行LPUSH key value [value …]或 RPUSH key value [value …] 命令为止。
超时参数timeout接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

返回值
假如在指定时间内没有任何元素被弹出，则返回一个nil和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。

示例代码

# 非空列表
redis> BRPOPLPUSH msg reciver 500
"hello moto"                        # 弹出元素的值
(3.38s)                             # 等待时长

redis> LLEN reciver
(integer) 1

redis> LRANGE reciver 0 0
1) "hello moto"

# 空列表
redis> BRPOPLPUSH msg reciver 1
(nil)
(1.34s)

$集合$

$sadd$

sadd key member [member...]
将一个或多个member元素加入到集合 key当中，已经存在于集合的 member元素将被忽略。
假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
当 key不是集合类型时，返回一个错误。
返回值
被添加到集合中的新元素的数量，不包括被忽略的元素。
代码示例

# 添加单个元素
redis> SADD bbs "discuz.net"
(integer) 1

# 添加重复元素
redis> SADD bbs "discuz.net"
(integer) 0

# 添加多个元素
redis> SADD bbs "tianya.cn" "groups.google.com"
(integer) 2

redis> SMEMBERS bbs
1) "discuz.net"
2) "groups.google.com"
3) "tianya.cn"

$sismember$

sismember key member
判断 member 元素是否集合 key 的成员。
返回值
如果 member 元素是集合的成员，返回1 。 如果member 元素不是集合的成员，或key 不存在，返回 0 。
代码示例

redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"

redis> SISMEMBER joe's_movies "bet man"
(integer) 0

redis> SISMEMBER joe's_movies "Fast Five"
(integer) 1

$spop$

spop key
移除并返回集合中的一个随机元素。
如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER key [count] 命令。
返回值
被移除的随机元素。 当key不存在或key是空集时，返回 nil 。
示例代码

redis> SMEMBERS db
1) "MySQL"
2) "MongoDB"
3) "Redis"

redis> SPOP db
"Redis"

redis> SMEMBERS db
1) "MySQL"
2) "MongoDB"

redis> SPOP db
"MySQL"

redis> SMEMBERS db
1) "MongoDB"

$srangemember$

srangemember key [count]
如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。
从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count参数：

• 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
• 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

返回值
只提供 key 参数时，返回一个元素；如果集合为空，返回 nil 。 如果提供了 count参数，那么返回一个数组；如果集合为空，返回空数组。

代码示例

# 添加元素

redis> SADD fruit apple banana cherry
(integer) 3

# 只给定 key 参数，返回一个随机元素

redis> SRANDMEMBER fruit
"cherry"

redis> SRANDMEMBER fruit
"apple"

# 给定 3 为 count 参数，返回 3 个随机元素
# 每个随机元素都不相同

redis> SRANDMEMBER fruit 3
1) "apple"
2) "banana"
3) "cherry"

# 给定 -3 为 count 参数，返回 3 个随机元素
# 元素可能会重复出现多次

redis> SRANDMEMBER fruit -3
1) "banana"
2) "cherry"
3) "apple"

redis> SRANDMEMBER fruit -3
1) "apple"
2) "apple"
3) "cherry"

# 如果 count 是整数，且大于等于集合基数，那么返回整个集合

redis> SRANDMEMBER fruit 10
1) "apple"
2) "banana"
3) "cherry"

# 如果 count 是负数，且 count 的绝对值大于集合的基数
# 那么返回的数组的长度为 count 的绝对值

redis> SRANDMEMBER fruit -10
1) "banana"
2) "apple"
3) "banana"
4) "cherry"
5) "apple"
6) "apple"
7) "cherry"
8) "apple"
9) "apple"
10) "banana"

# SRANDMEMBER 并不会修改集合内容

redis> SMEMBERS fruit
1) "apple"
2) "cherry"
3) "banana"

# 集合为空时返回 nil 或者空数组

redis> SRANDMEMBER not-exists
(nil)

redis> SRANDMEMBER not-eixsts 10
(empty list or set)

$srem$

srem key member [member...]
移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
当 key 不是集合类型，返回一个错误。

返回值
被成功移除的元素的数量，不包括被忽略的元素。

代码示例

redis> SMEMBERS languages
1) "c"
2) "lisp"
3) "python"
4) "ruby"

# 移除单个元素
redis> SREM languages ruby
(integer) 1

# 移除不存在元素
redis> SREM languages non-exists-language
(integer) 0

# 移除多个元素
redis> SREM languages lisp python c
(integer) 3

redis> SMEMBERS languages
(empty list or set)

$smove$

smove source detination member
SMOVE是原子性操作。
如果 source集合不存在或不包含指定的 member 元素，则 SMOVE命令不执行任何操作，仅返回0 。否则， member元素从 source 集合中被移除，并添加到destination集合中去。
当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member元素删除。
当 source 或 destination 不是集合类型时，返回一个错误。
返回值
如果 member元素被成功移除，返回1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对destination 集合执行，那么返回 0 。
代码示例

redis> SMEMBERS songs
1) "Billie Jean"
2) "Believe Me"

redis> SMEMBERS my_songs
(empty list or set)

redis> SMOVE songs my_songs "Believe Me"
(integer) 1

redis> SMEMBERS songs
1) "Billie Jean"

redis> SMEMBERS my_songs
1) "Believe Me"

$scard$

scard key
返回集合key的基数(集合中元素的数量)
返回值
集合的基数，当key不存在时返回0
代码示例

redis> SADD tool pc printer phone
(integer) 3

redis> SCARD tool   # 非空集合
(integer) 3

redis> DEL tool
(integer) 1

redis> SCARD tool   # 空集合
(integer) 0

$smembers$

smembers key
返回集合key中的所有成员，不存在key被视为空集合

返回值
集合中所有的成员
代码示例

# key 不存在或集合为空
redis> EXISTS not_exists_key
(integer) 0

redis> SMEMBERS not_exists_key
(empty list or set)

# 非空集合
redis> SADD language Ruby Python Clojure
(integer) 3

redis> SMEMBERS language
1) "Python"
2) "Ruby"
3) "Clojure"

$sinter$

sinter key [key...]
返回一个集合的全部成员，该集合是所有给定集合的交集。
不存在的key被视为空集。
当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

返回值
交集成员的列表
代码示例

redis> SMEMBERS group_1
1) "LI LEI"
2) "TOM"
3) "JACK"

redis> SMEMBERS group_2
1) "HAN MEIMEI"
2) "JACK"

redis> SINTER group_1 group_2
1) "JACK"

$sinterstore$

sinterstore destination key [key...]
这个命令类似于SINTER key [key …]命令，但它将结果保存到 destination集合，而不是简单地返回结果集。
如果destination集合已经存在，则将其覆盖。
destination可以是 key本身。
返回值
结果集中的成员数量
代码示例

redis> SMEMBERS songs
1) "good bye joe"
2) "hello,peter"

redis> SMEMBERS my_songs
1) "good bye joe"
2) "falling"

redis> SINTERSTORE song_interset songs my_songs
(integer) 1

redis> SMEMBERS song_interset
1) "good bye joe"

$sunion$

sunion key [key...]
返回一个集合的全部成员，该集合是所有给定集合的并集。
不存在的 key 被视为空集。

返回值
并集成员的列表
代码示例

redis> SMEMBERS songs
1) "Billie Jean"

redis> SMEMBERS my_songs
1) "Believe Me"

redis> SUNION songs my_songs
1) "Billie Jean"
2) "Believe Me"

$sunionstore$

sunionstore destination key [key...]
这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
如果 destination 已经存在，则将其覆盖。
destination 可以是 key 本身。
返回值
结果集中的元素数量。
代码示例

1) "MongoDB"
2) "Redis"

redis> SMEMBERS SQL
1) "sqlite"
2) "MySQL"

redis> SUNIONSTORE db NoSQL SQL
(integer) 4

redis> SMEMBERS db
1) "MySQL"
2) "sqlite"
3) "MongoDB"
4) "Redis"

$sdiff$

sdiff key [key...]
返回一个集合的全部成员，该集合是所有给定集合的差集
不存在的key被视为空集
返回值
一个包含空集的成员列表
示例代码

redis> SMEMBERS peter's_movies
1) "bet man"
2) "start war"
3) "2012"

redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"

redis> SDIFF peter's_movies joe's_movies
1) "bet man"
2) "start war"

$sdiffstore$

sdiffstore destination key [key...]
这个命令的作用和 SDIFF key [key …]类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
如果 destination 集合已经存在，则将其覆盖。
destination 可以是 key 本身。
返回值
结果集中的元素数量。
代码示例

redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"

redis> SMEMBERS peter's_movies
1) "bet man"
2) "start war"
3) "2012"

redis> SDIFFSTORE joe_diff_peter joe's_movies peter's_movies
(integer) 2

redis> SMEMBERS joe_diff_peter
1) "hi, lady"
2) "Fast Five"

$有序集合$

$zadd$

zadd key score member [[score member] [score member] …]
将一个或多个member元素及其score 值加入到有序集 key 当中。
如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member元素，来保证该 member在正确的位置上。
score值可以是整数值或双精度浮点数。

• 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
• 当 key 存在但不是有序集类型时，返回一个错误。

返回值
被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
代码示例

# 添加单个元素
redis> ZADD page_rank 10 google.com
(integer) 1

# 添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2

redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

# 添加已存在元素，且 score 值不变
redis> ZADD page_rank 10 google.com
(integer) 0

redis> ZRANGE page_rank 0 -1 WITHSCORES  # 没有改变
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"


# 添加已存在元素，但是改变 score 值
redis> ZADD page_rank 6 bing.com
(integer) 0

redis> ZRANGE page_rank 0 -1 WITHSCORES  # bing.com 元素的 score 值被改变
1) "bing.com"
2) "6"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

$zscore$

zscore key member
返回有序集key中，成员member的score值
如果 member元素不是有序集key 的成员，或key不存在，返回nil。
返回值
member成员的 score值，以字符串形式表示。
代码示例

redis> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis> ZSCORE salary peter              # 注意返回值是字符串
"3500"

$zincrby$

zincrby key incrment member
为有序集key的成员member 的 score 值加上增量 increment。
可以通过传递一个负数值increment，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让member的 score值减去 5 。

• 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
• 当 key 不是有序集类型时，返回一个错误。

score 值可以是整数值或双精度浮点数。
返回值
member成员的新score值，以字符串形式表示
代码示例

redis> ZSCORE salary tom
"2000"

redis> ZINCRBY salary 2000 tom   # tom 加薪啦！
"4000"

$zcard$

zcard key
返回有序集key的基数
返回值
当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。
代码示例

redis > ZADD salary 2000 tom    # 添加一个成员
(integer) 1

redis > ZCARD salary
(integer) 1

redis > ZADD salary 5000 jack   # 再添加一个成员
(integer) 1

redis > ZCARD salary
(integer) 2

redis > EXISTS non_exists_key   # 对不存在的 key 进行 ZCARD 操作
(integer) 0

redis > ZCARD non_exists_key
(integer) 0

$zcount$

zcount key min max
返回有序集 key 中，score值在min 和 max之间(默认包括 score 值等于 min 或 max )的成员的数量。

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

代码示例

redis> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"

redis> ZCOUNT salary 2000 5000          # 计算薪水在 2000-5000 之间的人数
(integer) 3

redis> ZCOUNT salary 3000 5000          # 计算薪水在 3000-5000 之间的人数
(integer) 2

$zrange$

zrange key start stop [withSCORES]
返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score值递增(从小到大)来排序。
具有相同score值的成员按字典序(lexicographical order )来排列。
如果你需要成员按 score值递减(从大到小)来排列，请使用 ZREVRANGE key start stop [WITHSCORES]命令。

下标参数 start和 stop都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。

可以通过使用WITHSCORES 选项，来让成员和它的 score值一并返回，返回列表以 value1,score1, …, valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。
代码示例

redis > ZRANGE salary 0 -1 WITHSCORES             # 显示整个有序集成员
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis > ZRANGE salary 1 2 WITHSCORES              # 显示有序集下标区间 1 至 2 的成员
1) "tom"
2) "5000"
3) "boss"
4) "10086"

redis > ZRANGE salary 0 200000 WITHSCORES         # 测试 end 下标超出最大下标时的情况
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis > ZRANGE salary 200000 3000000 WITHSCORES   # 测试当给定区间不存在于有序集时的情况
(empty list or set)

$zrevrange$

zrevrange key start stop [WITHSCORES]
返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。
除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。
返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例

redis> ZRANGE salary 0 -1 WITHSCORES        # 递增排列
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

redis> ZREVRANGE salary 0 -1 WITHSCORES     # 递减排列
1) "jack"
2) "5000"
3) "tom"
4) "4000"
5) "peter"
6) "3500"

$zrangebyscore$

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
返回有序集 key 中，所有score值介于min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。
可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。 该选项自 Redis 2.0 版本起可用。

区间及无限
min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

ZRANGEBYSCORE zset (1 5  # 返回所有符合条件 1 < score <= 5 的成员，
ZRANGEBYSCORE zset (5 (10 # 则返回所有符合条件 5 < score < 10 的成员。

返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例

redis> ZADD salary 2500 jack                        # 测试数据
(integer) 0
redis> ZADD salary 5000 tom
(integer) 0
redis> ZADD salary 12000 peter
(integer) 0

redis> ZRANGEBYSCORE salary -inf +inf               # 显示整个有序集
1) "jack"
2) "tom"
3) "peter"

redis> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"

redis> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
1) "jack"
2) "2500"
3) "tom"
4) "5000"

redis> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
1) "peter"

$zrevrangebyscore$

zrevrangebyscore key min max [WITHSOCORES] [LIMIT offset count]
返回有序集key 中，score值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。
除了成员按 score 值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 命令一样。

返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例

redis > ZADD salary 10086 jack
(integer) 1
redis > ZADD salary 5000 tom
(integer) 1
redis > ZADD salary 7500 peter
(integer) 1
redis > ZADD salary 3500 joe
(integer) 1

redis > ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
1) "jack"
2) "peter"
3) "tom"
4) "joe"

redis > ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
1) "peter"
2) "tom"
3) "joe"

$zrank$

zrank key member
返回有序集key中成员 member的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。

排名以 0 为底，也就是说，score值最小的成员排名为0。
返回值
如果 member是有序集key 的成员，返回 member的排名。 如果 member 不是有序集key 的成员，返回 nil。

代码示例

redis> ZRANGE salary 0 -1 WITHSCORES        # 显示所有成员及其 score 值
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

redis> ZRANK salary tom                     # 显示 tom 的薪水排名，第二
(integer) 1

$zrevrank$

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

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

代码示例

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"

redis> ZREVRANK salary peter     # peter 的工资排第二
(integer) 1

redis> ZREVRANK salary tom       # tom 的工资最高
(integer) 0

$zrem$

zrem key member [member...]
移除有序集key中的一个或多个成员，不存在的成员将被忽略。
当key存在但不是有序集类型时，返回一个错误。

返回值
被成功移除的成员的数量，不包括被忽略的成员。

代码示例

# 测试数据
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

# 移除单个元素
redis> ZREM page_rank google.com
(integer) 1

redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"

# 移除多个元素
redis> ZREM page_rank baidu.com bing.com
(integer) 2

redis> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)

# 移除不存在元素
redis> ZREM page_rank non-exists-element
(integer) 0

$zremrangebyrank$

zremrangebyrank key start stop
移除有序集key中，指定排名(rank)区间内的所有成员。
区间分别以下标参数 start 和 stop指出，包含 start和stop在内。
下标参数 start 和 stop 都以0为底，也就是说，以0 表示有序集第一个成员，以 1表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

返回值
被移除成员的数量。

代码示例

redis> ZADD salary 2000 jack
(integer) 1
redis> ZADD salary 5000 tom
(integer) 1
redis> ZADD salary 3500 peter
(integer) 1

redis> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
(integer) 2

redis> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
1) "tom"
2) "5000"

$zremrangebyscore$

zremrangebyscore key min max
移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。

返回值
被移除成员的数量。

示例代码

redis> ZRANGE salary 0 -1 WITHSCORES          # 显示有序集内所有成员及其 score 值
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis> ZREMRANGEBYSCORE salary 1500 3500      # 移除所有薪水在 1500 到 3500 内的员工
(integer) 2

redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成员
1) "jack"
2) "5000"

$zrangebylex$

zrangebylex key min max [LIMIT offset count]
当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。

如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。

命令会使用 C 语言的 memcmp() 函数， 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。

可选的 LIMIT offset count 参数用于获取指定范围内的匹配元素 （就像 SQL 中的 SELECT LIMIT offset count 语句）。 需要注意的一点是， 如果 offset 参数的值非常大的话， 那么命令在返回结果之前， 需要先遍历至 offset 所指定的位置， 这个操作会为命令加上最多 O(N) 复杂度。

如何指定范围区间
合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。

特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX - + ， 命令将返回有序集合中的所有元素。

返回值
数组回复：一个列表，列表里面包含了有序集合在指定范围内的成员。

代码示例

redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7

redis> ZRANGEBYLEX myzset - [c
1) "a"
2) "b"
3) "c"

redis> ZRANGEBYLEX myzset - (c
1) "a"
2) "b"

redis> ZRANGEBYLEX myzset [aaa (g
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"

$zlexcount$

zlexcount key min max
对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。

返回值
整数回复：指定范围内的元素数量。

代码示例

redis> ZADD myzset 0 a 0 b 0 c 0 d 0 e
(integer) 5

redis> ZADD myzset 0 f 0 g
(integer) 2

redis> ZLEXCOUNT myzset - +
(integer) 7

redis> ZLEXCOUNT myzset [b [f
(integer) 5

$zremramgebylex$

zremrangebylex key min max
对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于min和max范围内的所有元素

返回值
整数回复：被移除的元素数量。

示例代码

redis> ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
(integer) 5

redis> ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
(integer) 5

redis> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "alpha"
4) "b"
5) "c"
6) "d"
7) "e"
8) "foo"
9) "zap"
10) "zip"

redis> ZREMRANGEBYLEX myzset [alpha [omega
(integer) 6

redis> ZRANGE myzset 0 -1
1) "ALPHA"
2) "aaaa"
3) "zap"
4) "zip"