redis 的数据类型

redis的数据类型

小鬼當街

3625人浏览 · 2022-08-04 09:36:41

小鬼當街 · 2022-08-04 09:36:41 发布

五种数据类型：

String 字符串

Hash 哈希

List 列表

Set 集合

Sorted_set 有序集合

Redis指令参考

一、String

1、Redis 数据存储格式

Redis自身是一个map,其中所有的数据都是采用 key : value的形式存储。

数据类型指的是存储的数据的类型，也就是value部分的类型，key部分永远都是字符串

存储内容：通常使用字符串，如果字符串以正数形式展示，可以作为数字操作使用

2、string类型数据的基本操作

添加/修改

set key value

获取数据

get key

删除数据

del key

删除成功为返回1，删除失败返回0

存在的set则会被覆盖，燕来没有的则会创建增加

小结：

关键命令	对应的
Set key valu	Get key
Mset key1 valu key2 value	Mget key1 key2
Strlen key	获取数据字符长度
Append key value	追加信息到原始信息后面，如果没有则创建

3、String数据的基本操作：

单数据操作与多数据操作的选择

判断发送多个和单个的效率：主要考虑的是发送时长和执行时长。对多条指令进行切割进行最大数据最快传输。

4、String类型数据的扩展操作：

Inor key	数字自增长1
Inocrby key increment	给指定的一个值增加指定的数值；increment 可以是负数
Decr key	数字减1
Incrbyfloat key increment	可以增加小数
Deorby key increment	给指定的一个值增加指定的数值；increment 可以是负数

5、设置数据有指定的生命周期（限制时长）

setex key seconds value	秒
psetex key milliseconds value	毫秒

Redis 控制数据生命周期，通过数据是否失效控制业务行为，适用所有时效性限定控制的操作

注意事项：

数据操作不成功的反馈与数据正常操作之间的差异

1、表示结果是否成功：

（integer） 0 false 失败

（integer） 1 true 成功

判断存不存在则是返回值为0,，1（false，true）

2、表示运行结果

（integer） 3 3 3 个

（integer） 1 1 1个

获取数据长度

获取数据获取到

（nil）等同于 null 不存在

数据最大存储量

512MB

数值计算最大范围（java中的long的最大值）

9223372036854775807

-9223372036854775807

二、hash类型

新的存储需求：对一系列存储的数据进行编组，方便管理，典型应用存储对象信息
需要的存储结构：一个存储空间保存多个键值对数据
Hash类型：底层使用哈希表结构实现数据存储

1、基础操作

添加/修改数据

hset key field value

hmset key field1 value1 field2 value2

获取数据

hget key field

hgetall key

hmget key field1 field2 ....

获取哈希表中字段的数量

hlen key

获取哈希表中是否存在指定字段

hexists key field

不存在0；存在1

删除数据

hdel key field1 [field2]

2、扩展操作：

获取哈希表中所有的字段名或字段值

hkeys key

hvals key

设置指定字段的数值数据增加指定范围的值

hincrby key field increment

hincrbyflot key field increment

3、注意事项

hash类型下的value只能存储字符串，不允许存储其他数据类型，不存在嵌套现象。如果数据未获取到，对应的值为（nil）
每个hash 可以存储2^32-1 个键值对
hash类型十分贴近对象的数据存储形式，并且可以灵活添加删除对象属性，但是hash设计初衷不是为了存储大量对象而设计的，切记不可滥用，更不能将hash作为对象列表使用
hgetall操作可以获取全部属性，如果内部field过多，遍历整体数据效率就很会低，有可能成为数据访问瓶颈

三、List

数据存储需求：存储多个数据，并对数据存储空间的顺序进行区分
需要的存储结构：一个存储空间保存多个数据，且通过数据可以体现进入顺序
list类型：保存多个数据，底层使用双向链表存储结构数显

1、list类型数据基本操作

添加/修改数据

lpush key value1 [value2] .... 从右先进

rpush key value1 [value2] .... 从左先进

获取数据

lrange key start stop start：索引 stop:索引

lindex key index

llen key

获取并移除数据

lpop key

rpop key

移除指定数据

lrem key count value

在规定时间内获取并移除数据

当没有数据时会等待 timeout 秒后执行完成，如果存在就会立刻查询出来

blpop key1 [key2] ... timeout

brpop key1 [key2] ... timeout

2、注意事项

list 中保存的数据都是string 类型的，数据总量是有限的，最多2^23-1 个元素（4294967295）。
list具有索引的概念，但是操作数据时通常以队列的形式进行入队出队操作，或以栈的形式进行入栈出栈操作。
获取全部数据操作结束索引设置为-1。
list可以对数据进行分页操作，通常第一页的信息来自于list，第2页及更多的信息通过数据库的形式加载。

四、Set

新的存储需求:存储大量的数据，在查询方面提供更高的效率。
需要的存储结构:能够保存大量的数据，高效的内部存储机制,便于查询。
set类型:与hash存储结构完全相同，仅存储键，不存储值(nil)，并且值是不允许重复的。

1、set类型数据的基本操作

添加数据

sadd key member1 [member2]

获取全部数据

smemberes key

删除数据

srem key member1 [member2]

获取集合数据总量

scard key

判断集合中是否包含指定数据

sismember key member

随机获取集合中指定数量的数据

srandmember key [count]

随机获取集合中的某个数据并将该数据移出集合

spop key

求两个集合的交、并、差集

sinter key1 [key2]

sunion key1 [key2]

sdiff key1 [key2]

求两个集合的交、并、差集并存储到指定集合中

sinterstore destination key1 [key2]

sunionstore destination key1 [key2]

sdiffstore destination key1 [key2]

指定数据从原始集合中移动到目标集合中

是move source destination member

2、注意事项

set类型不允许数据重复，如果添加的数据在set中已经存在，将只保留一份
set虽然与hash的存储结构相同，但是无法启用hash中存储值的空间

五、Sorted_set

新的存储需求:数据排序有利于数据的有效展示，需要提供一种可以根据自身特征进行排序的方式
需要的存储结构:新的存储模型，可以保存可排序的数据
sorted_set类型:在set的存储结构基础上添加可排序字段

注意：

min与max用于限定搜索查询的条件
start与stop用于限定查询范围，作用于索引，表示开始和结束索引
offset与count用于限定查询范围，作用于查询结果，表示开始位置和数据总量

1、Sorted_set 类型数据的基本操作

添加数据

zadd key score1 member1 [score2 member2]

获取全部数据

zrange key start stop [WITHSCORES]

zrevrange key start stop [WITHSCORES]

删除数据

zrem key member [member ...]

按条件获取数据

zrangebyscore key min max [MITHSCORES] [LIMIT]

zrevrangebyscore key max min [WITHSCORES]

小皮面板6380:2>zrevrange achievement 0 -1 withscores
 1)  "zs"
 2)  "91"
 3)  "ls"
 4)  "90"
 5)  "lh"
 6)  "90"
 7)  "ww"
 8)  "86"
 9)  "yf"
 10)  "84"
 11)  "xh"
 12)  "80"
 13)  "ll"
 14)  "74"
 15)  "dl"
 16)  "60"
小皮面板6380:2>zrangebyscore achievement 80 90
 1)  "xh"
 2)  "yf"
 3)  "ww"
 4)  "lh"
 5)  "ls"
小皮面板6380:2>zrangebyscore achievement 80 90  withscores
 1)  "xh"
 2)  "80"
 3)  "yf"
 4)  "84"
 5)  "ww"
 6)  "86"
 7)  "lh"
 8)  "90"
 9)  "ls"
 10)  "90"
小皮面板6380:2>zrangebyscore achievement 80 90 withscores  limit  0 3
 1)  "xh"
 2)  "80"
 3)  "yf"
 4)  "84"
 5)  "ww"
 6)  "86"
小皮面板6380:2>zrevrangebyscore achievement 90 80
 1)  "ls"
 2)  "lh"
 3)  "ww"
 4)  "yf"
 5)  "xh"
小皮面板6380:2>zrevrangebyscore achievement 90 80  withscores
 1)  "ls"
 2)  "90"
 3)  "lh"
 4)  "90"
 5)  "ww"
 6)  "86"
 7)  "yf"
 8)  "84"
 9)  "xh"
 10)  "80"

条件删除数据

zremrangebyrank key start stop

zremrangebyscore key min max

# 删除前
小皮面板6380:2>zrevrange achievement 0 -1 withscores
 1)  "zs"
 2)  "91"
 3)  "ls"
 4)  "90"
 5)  "lh"
 6)  "90"
 7)  "ww"
 8)  "86"
 9)  "yf"
 10)  "84"
 11)  "xh"
 12)  "80"
 13)  "ll"
 14)  "74"
 15)  "dl"
 16)  "60"
# 删除
小皮面板6380:2>zremrangebyrank achievement 0 1
"2"
# 删除后
小皮面板6380:2>zrevrange achievement 0 -1 withscores
 1)  "zs"
 2)  "91"
 3)  "ls"
 4)  "90"
 5)  "lh"
 6)  "90"
 7)  "ww"
 8)  "86"
 9)  "yf"
 10)  "84"
 11)  "xh"
 12)  "80"
# 删除范围  80 - 90
小皮面板6380:2>zremrangebyscore achievement 80 90
"5"
# 删除后
小皮面板6380:2>zrevrange achievement 0 -1 withscores
 1)  "zs"
 2)  "91"

获取集合数据总量

zcard key

zcount key min max

小皮面板6380:2>zrevrange achievement 0 -1 withscores
 1)  "zs"
 2)  "85"
 3)  "ls"
 4)  "80"
 5)  "dl"
 6)  "75"
 7)  "ww"
 8)  "70"
小皮面板6380:2>zcard achievement
"4"
小皮面板6380:2>zcount achievement   60   80
"3"

集合交、并操作

zinterstore destination numkeys key [key ...]

zunionstore destination numkeys key [key ....]

小皮面板6380:2>zadd s1 50  a  60 b 70 c
"3"
小皮面板6380:2>zadd s2 60 a 70 b 80 c
"3"
小皮面板6380:2>zinterstore newkey 2 s1 s2
"3"
小皮面板6380:2>zrevrange newkey 0 -1 withscores
 1)  "c"
 2)  "150"
 3)  "b"
 4)  "130"
 5)  "a"
 6)  "110"

获取数据对应的索引

zrank key member

zrevrank key member

小皮面板6380:2>zrevrange newkey 0 -1 withscores

 1)  "c"
 2)  "150"
 3)  "b"
 4)  "130"
 5)  "a"
 6)  "110"
小皮面板6380:2>zrank newkey b
"1"
小皮面板6380:2>zrank newkey c
"2"
小皮面板6380:2>zrevrank newkey  b
"1"
小皮面板6380:2>zrevrank newkey a
"2"

score 值获取与修改

zscore key member

zincrby key increment member

小皮面板6380:2>zrevrange newkey 0 -1 withscores
 1)  "c"
 2)  "150"
 3)  "b"
 4)  "130"
 5)  "a"
 6)  "110"
小皮面板6380:2>zscore newkey a
"110"
#增加 1
小皮面板6380:2>zincrby newkey 1 a
"111"

2、注意事项

score保存的数据存储空间是64位，如果是整数范围是-9007199254740992~9007199254740992
score保存的数据也可以是一个双精度的double值，基于双精度浮点数的特征，可能会丢失精度，使用时候要慎重
sorted_set底层存储还是基于set结构的，因此数据不能重复，如果重复添加相同的数据,score值将被反复覆盖，保留最后一次修改的结果

六、其他操作

1、切换库

select number

总结

1、string

链接redis

链接本地redis: 直接打开redis-cli客户端工具
链接完成redis: 使用doc命令打开redis-cli, > redis-cli –h ip地址 –p 端口号

功能：设置值：覆盖，创建新的（单个key；多个key）

获取值：获取单个，多个，获取后再修改

修改值：直接覆盖，追加，获取后再覆盖，修改指定位置

获取长度

命令名称	命令使用格式	命令介绍	命令例子
set	set key value	设置指定 key 的值	set a 23
get	get key	获取指定key的值	get a
setnx	setnx key value	nx表示: not exists , 如果不存在则进行设置	setnx a 45
getset	getset key value	获取指定key的值然后再进行重新设置	getset a 89
setrange	setrange key startIndex vlaue	表示把指定的key的值从开始索引开始使用value这个值进行替换	setrange str 2 你好
mset	mset key1 value1 key2 value2...	批量设置数据结构	mset b 34 c 56
msetnx	metnx key1 value1 key2 value2...	nx表示: not exists , 如果可已经存在那么设置失效	msetnx a 11
getrange	getrange key startIndex endIndex	获取指定返回内的数据	getrange str 0 3
mget	mget key1 key2...	批量获取多个key的值	mget a b
incr	incr key	自增1	incr a
incrby	incrby key num	自增指定的数值	incrby a 5
decr	decr key	自减1	decr a
decrby	decrby key num	自减指定的数值	decrby a 2
append	append key str	给指定的key追加指定的value的值	append a 哈哈
strlen	strlen key	获取指定的key的值长度	strlen a

2、hash

命令名称	使用格式	命令介绍	命令例子
hset	hset key field value	添加/修改数据

3、list

在redis中list相当于我们java中的LinkedList可以从头部给列表添加元素,也可以从尾部给列表添加元素

功能：

加入元素：左（头）加入，右（尾）加入，在指定元素的前后插入元素

取元素：都是从左开始取（取集合，指定索引）

修改元素：修改指定索引位置的元素

删除元素：删除指定值的元素，从左/右开始删除元素，

获取list长度

命令名称	命令使用格式	命令介绍	命令例子
lpush	lpush key value1 value2 ...	往list集合中压入元素(l:表示左的意思)	lpush list01 23 45
lrange	lrange key startIndex endIndex	从集合中获取元素	lrange list01 0 -1
linsert	linsert key before/after value newValue	在指定的元素前或者后插入元素	linsert list01 before 23 56
lset	lset key index newValue	设置指定下标的值	lset list01 1 88
lrem	lrem key count value	删除count个与value相同的元素,count=0表示删除所有	lrem list 1 56
lpop	lpop key	从list的头部删除元素	lpop list01
lindex	lindex key index	返回指定索引处的元素	lindex list01 1
llen	llen key	返回列表的长度	llen list01
rpush	rpush key value	从末尾压入元素(r:表示右的意思)	rpush list01 100
rpop	rpop key	从尾部删除一个元素	rpop list01
rpoplpush	rpoplpush key1 key2	从key1链表中弹出最后一个元素然后压入到key2链表中	rpoplpush list01 list02

4、set

Redis的Set是String类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。类似于java中的set集合

命令名称	命令使用格式	命令介绍	命令例子
sadd	sadd key member1 member2...	添加元素	sadd set01 23 45 67 45
scard	scard key	获取成员的数量	scard set01
smembers	smembers key	获取所有的成员	smembers set01
sismember	sismember key member	判断是否存在member这个成员	sismember set01 23
spop	spop key	随机弹出一个成员	spop set01
srandmember	srandmember key [count]	随机获取一个或者多个成员	srandmember set01 2
srem	srem key member1 member2 ....	删除一个或者多个成员,如果成员不存在则忽略	srem set01 23 45
smove	smove source desition member	移动一个成员到指定的set中	smove set01 set02 23
sdiff	sdiff first-key key1 key2...	返回给定集合之间的差集。不存在的集合 key 将视为空集	sdiff set01 set02
sdiffstore	sdiffstore destionset key1 key2 ....	把获取到的差集保存到目标set中	sdiffstore set03 set01 set02
sinter	sinter key1 key2....	获取交集	sinter set01 set02
sinterstore	sinterstore destionset key1 key2....	把获取到的交集存储到目标set中	sinterstore set03 set 01 set02
sunion	sunion key1 key2...	获取并集	sunion set01 set02
sunionstore	sunionstore destionset key1 key2...	把获取到的并集存储到目标set中	sunionstore set03 set01 set02

5、SortedSet

redis 有序集合和set集合一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序

命令名称	命令使用格式	命令介绍	命令例子
zadd	zadd key score1 member1 score2 member2...	添加成员	zadd zset01 1 a 2 b 3 c 4 d 5 e
zcard	zcard key	计算元素个数	zadd zset01
zrange	zrange key start stop [WITHSCORES]	返回指定排名之间的成员(结果是分数由低到高)	zrange zset01 1 3 withscores
zrevrange	zrevrange key start stop [WITHSCORES]	返回指定排名之间的成员(结果是分数由高到低)	zrevrange zset01 1 3 withscores
zincrby	zincrby key number member	给指定的member的分数添加或者减去number这个值	zincrby zset01 3 a
zcount	zcount key min max	获取分数在min和max之间的成员和数量; 默认是闭区间; 想不包含可以: (min (max	zcount zset01 3 5
zrangebyscore	zrangebyscore key min max [withscores]	根据分数的范围获取成员(按照分数: 从低到高)	zrangebyscore zset01 2 5
zrevrangebyscore	zrevrangebyscore key max min [withscores]	根据分数的范围获取成员(从高到低)	zrevrangebyscore zset01 2 5
zrank	zrank key member	返回一个成员的排名(从低到高的顺序)	zrank zset01 3
zrevrank	zrevrank key member	返回一个成员的排名(从高到低)	zrevrank zset01 3
zscore	zscore key member	获取一个成员的分数	zscore zset01 3
zrem	zrem key member1 member2...	删除指定的成员	zrem zset01 2
zremrangebyrank	zremrangebyrank key start stop	根据排名进行删除	zremrangebyrank zset01 1 4
zremrangebyscore	zremrangebyscore key min max	根据分数的范围进行删除	zremrangebyscore zset01 2 6

对Key的通用操作

Redis是一个key-value的数据库,我们可以直接对应key进行相关操作

命令名称	命令使用格式	命令介绍	命令例子
keys	keys pattern	根据指定的规则返回符合条件的key; 当使用 keys *;即可查看所有的key	keys set0*
del	del key1 key2...	删除指定的key	del set01
exists	exists key	判断是否存在指定的key	exists set01
move	move key db	将指定的key移入到指定的数据库中: redis默认存在16个库select 10 : 表示选择9号库	move set02 10
rename	rename key newkey	对key进行重命名	rename set02 set06
renamenx	renamenx key newkey	仅当 newkey 不存在时，将 key 改名为 newkey	renamenx set06 set07
type	type key	返回key的类型	type set01
expire	expire key second	给指定的key设置失效时间,单位为秒	rexpire set01 60
persist	persist key	移除key的失效时间	persist set01
ttl	ttl key	以秒为单位返回key的剩余时间(返回-2表示key不存在, 返回-1表示永远不过时)	ttl set01

Redis（Windows）

下载Redis

地址：Releases · microsoftarchive/redis · GitHub

根据自己电脑选择安装版本（我的电脑是64位，所以选择第二个）

双击redis-server.exe启动redis服务

看到这个界面就是启动成功了！

下载Redis客户端图形界面工具：Redis Desktop Manager

地址：https://pan.baidu.com/s/1l6In9-BClKdCpciqI0vbCw 提取码：k5pu

傻瓜式安装，点击下一步就可以了。

指令参考：

Redis 命令参考 — Redis 命令参考

指令

字符串

set :

将字符串值 value 关联 key,如果key 已经持有其他值，则 set 就覆盖写的旧值，无视类型。当set 命令对一个带有生存时间（TTL）的键进行设置之后，该键原有的TTL 将被清除。

set key value

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

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

set key value ex seconds ==>将键的过期时间设置为 seconds 秒和

setex key setex key seconds value 效果系统

set key value px millisecondes :将键的过期时间设置为 milliseconds 毫秒，和

psetex key milliseconds value相同

set key value nx 只在建不存在时，才对建进行设置。和

setnx key value 的效果相同

set key value xx 只在建已经存在的时，才对建进行设置操作。

setnx：

只在建 key 不存在的情况下，将键 key 的值设置为 value。若键 key 已经存在，则 setnx 命令不做如何动作。

setnx key value

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

setex：

将键 key 的值设置为 value ，并将键 key 的生存时间设置为 seconds 秒钟。如果键 key 已经存在，那么 SETEX 命令将覆盖已有的值。

setex key seconds value

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

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

ttl key --> 查看剩余时间秒如果不存或者已过期在则返回 -2

pttl key ---》查询的是剩余时间毫秒

psetx：

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

psetey key millliseconds value

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

get:

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

get key

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

getset:

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

getset key value

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

strlen:

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

strlen key

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

append:

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

append key value

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

setrange:

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

setrange key offset value

SETRANGE 命令会返回被修改之后，字符串值的长度。
redis> SET greeting "hello world"
OK
redis> SETRANGE greeting 6 "Redis"
(integer) 11
redis> GET greeting
"hello Redis"

getrange:

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

getrange key start end

GETRANGE 命令会返回字符串值的指定部分。
redis> SET greeting "hello, my friend"
OK

redis> GETRANGE greeting 0 4          # 返回索引0-4的字符，包括4。
"hello"

redis> GETRANGE greeting -1 -5        # 不支持回绕操作
""

redis> GETRANGE greeting -3 -1        # 负数索引
"end"

redis> GETRANGE greeting 0 -1         # 从第一个到最后一个
"hello, my friend"

redis> GETRANGE greeting 0 1008611    # 值域范围不超过实际字符串，超过部分自动被符略
"hello, my friend"

incr：

为键 key 储存的数字值加上一。如果键 key 不存在，那么它的值会先被初始化为 0 ，然后再执行 INCR 命令。如果键 key 储存的值不能被解释为数字，那么 INCR 命令将返回一个错误。本操作的值限制在 64 位(bit)有符号数字表示之内。INCR 命令是一个针对字符串的操作。因为 Redis 并没有专用的整数类型，所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

incr key

INCR 命令会返回键 key 在执行加一操作之后的值。
redis> SET page_view 20
OK

redis> INCR page_view
(integer) 21

redis> GET page_view    # 数字值在 Redis 中以字符串的形式保存
"21"

incrby:

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

incrby key insrement

在加上增量 increment 之后，键 key 当前的值。
redis> SET rank 50
OK

redis> INCRBY rank 20
(integer) 70

redis> GET rank
"70"

incrbyfloat:

为键 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)为双精度浮点数。

incrbyfloat key increment

在加上增量 increment 之后，键 key 的值。
redis> GET decimal
"3.0"

redis> INCRBYFLOAT decimal 2.56
"5.56"

redis> GET decimal
"5.56"

decr：

为键 key 储存的数字值减去一。

如果键 key 不存在，那么键 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。

如果键 key 储存的值不能被解释为数字，那么 DECR 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

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

decr key

DECR 命令会返回键 key 在执行减一操作之后的值。
redis> SET failure_times 10
OK

redis> DECR failure_times
(integer) 9

decrby:

将键 key 储存的整数值减去减量 decrement 。

如果键 key 不存在，那么键 key 的值会先被初始化为 0 ，然后再执行 DECRBY 命令。

如果键 key 储存的值不能被解释为数字，那么 DECRBY 命令将返回一个错误。

本操作的值限制在 64 位(bit)有符号数字表示之内。

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

decrby key decrement

DECRBY 命令会返回键在执行减法操作之后的值。
redis> SET count 100
OK

redis> DECRBY count 20
(integer) 80

mset:

同时为多个键设置值。

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

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

mset key value

MSET 命令总是返回 OK 。
redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK

redis> MGET date time weather
1) "2012.3.30"
2) "11:00 a.m."
3) "sunny"

msetnx:

当且仅当所有给定键都不存在时，为所有给定键设置值。

即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。

MSETNX 是一个原子性(atomic)操作，所有给定键要么就全部都被设置，要么就全部都不设置，不可能出现第三种状态。

msetnx key value

当所有给定键都设置成功时，命令返回 1 ；如果因为某个给定键已经存在而导致设置未能成功执行，那么命令返回 0 。
redis> MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"
(integer) 1

redis> MGET rmdbs nosql key-value-store
1) "MySQL"
2) "MongoDB"
3) "redis"

mget:

返回给定的一个或多个字符串键的值。

如果给定的字符串键里面，有某个键不存在，那么这个键的值将以特殊值 nil 表示。

mget key

MGET 命令将返回一个列表，列表中包含了所有给定键的值。
redis> SET redis redis.com
OK

redis> SET mongodb mongodb.org
OK

redis> MGET redis mongodb
1) "redis.com"
2) "mongodb.org"

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

哈希表

hset:

将哈希表 hash 中域 field 的值设置为 value 。

如果给定的哈希表并不存在，那么一个新的哈希表将被创建并执行 HSET 操作。

如果域 field 已经存在于哈希表中，那么它的旧值将被新值 value 覆盖。

hset hash field value

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

hsetnx:

当且仅当域 field 尚未存在于哈希表的情况下，将它的值设置为 value 。

如果给定域已经存在于哈希表当中，那么命令将放弃执行设置操作。

如果哈希表 hash 不存在，那么一个新的哈希表将被创建并执行 HSETNX 命令。

hsetnx hash field value

HSETNX 命令在设置成功时返回 1 ，在给定域已经存在而放弃执行设置操作时返回 0 。
redis> HSETNX database key-value-store Redis
(integer) 1

redis> HGET database key-value-store
"Redis"

hget:

返回哈希表中给定域的值。

hget hash fieod

HGET 命令在默认情况下返回给定域的值。

如果给定域不存在于哈希表中，又或者给定的哈希表并不存在，那么命令返回 nil 。
redis> HSET homepage redis redis.com
(integer) 1

redis> HGET homepage redis
"redis.com"

hexists:

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

hexists hash field

HEXISTS 命令在给定域存在时返回 1 ，在给定域不存在时返回 0 。
redis> HEXISTS phone myphone
(integer) 0

hdel:

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

hdel hkey

被成功移除的域的数量，不包括被忽略的域。

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

redis> HDEL abbr a
(integer) 1


# 删除不存在的域

redis> HDEL abbr not-exists-field
(integer) 0


# 删除多个域

redis> HDEL abbr b c
(integer) 2
redis> HGETALL abbr
1) "d"
2) "dog"

hlen

HLEN key

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

时间复杂度：

O(1)

返回值：

哈希表中域的数量。

当 key 不存在时，返回 0
redis> HSET db redis redis.com
(integer) 1

redis> HSET db mysql mysql.com
(integer) 1

redis> HLEN db
(integer) 2

redis> HSET db mongodb mongodb.org
(integer) 1

redis> HLEN db
(integer) 3

hstrlen:

hstrlen key field

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

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

可用版本：

>= 3.2.0

时间复杂度：

O(1)

返回值：

一个整数。
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

hincrby key field increment

为哈希表 key 中的域 field 的值加上增量 increment 。

增量也可以为负数，相当于对给定域进行减法操作。

如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。

如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。

对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。

本操作的值被限制在 64 位(bit)有符号数字表示之内。

可用版本：

>= 2.0.0

时间复杂度：

O(1)

返回值：

执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。
# 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 命令获取更多相关信息。

可用版本：

>= 2.6.0

时间复杂度：

O(1)

返回值：

执行加法操作之后 field 域的值。
# 值和增量都是普通小数

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 操作。

可用版本：

>= 2.0.0

时间复杂度：

O(N)， N 为 field-value 对的数量。

返回值：

如果命令执行成功，返回 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 值的表。

可用版本：

>= 2.0.0

时间复杂度：

O(N)， N 为给定域的数量。

返回值：

一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。
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 中的所有域。

可用版本：

>= 2.0.0

时间复杂度：

O(N)， N 为哈希表的大小。

返回值：

一个包含哈希表中所有域的表。

当 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 中所有域的值。

可用版本：

>= 2.0.0

时间复杂度：

O(N)， N 为哈希表的大小。

返回值：

一个包含哈希表中所有值的表。

当 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)，所以返回值的长度是哈希表大小的两倍。

可用版本：

>= 2.0.0

时间复杂度：

O(N)， N 为哈希表的大小。

返回值：

以列表形式返回哈希表的域和域的值。

若 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"

列表（list）

lpush

LPUSH key value [value …]

可用版本： >= 1.0.0

时间复杂度： O(1)

将一个或多个值 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 存在但不是列表类型时，返回一个错误。

Note

在Redis 2.4版本以前的 LPUSH 命令，都只接受单个 value 值。

返回值

执行 LPUSH 命令后，列表的长度。

代码示例
# 加入单个元素
redis> LPUSH languages python
(integer) 1
# 加入重复元素
redis> LPUSH languages python
(integer) 2
redis> LRANGE languages 0 -1     # 列表允许重复元素
1) "python"
2) "python"
# 加入多个元素
redis> LPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "c"
2) "b"
3) "a"

lpushx

lpushx key value

可用版本： >= 2.2.0

时间复杂度： O(1)

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。

和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。

返回值

LPUSHX 命令执行之后，表的长度。

代码示例
# 对空列表执行 LPUSHX
redis> LLEN greet                       # greet 是一个空列表
(integer) 0
redis> LPUSHX greet "hello"             # 尝试 LPUSHX，失败，因为列表为空
(integer) 0
# 对非空列表执行 LPUSHX
redis> LPUSH greet "hello"              # 先用 LPUSH 创建一个有一个元素的列表
(integer) 1
redis> LPUSHX greet "good morning"      # 这次 LPUSHX 执行成功
(integer) 2
redis> LRANGE greet 0 -1
1) "good morning"
2) "hello"

rpush

rpush key value [value …]

可用版本： >= 1.0.0

时间复杂度： O(1)

将一个或多个值 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 存在但不是列表类型时，返回一个错误。

Note

在 Redis 2.4 版本以前的 RPUSH 命令，都只接受单个 value 值。

返回值

执行 RPUSH 操作后，表的长度。

代码示例
# 添加单个元素
redis> RPUSH languages c
(integer) 1
# 添加重复元素
redis> RPUSH languages c
(integer) 2
redis> LRANGE languages 0 -1 # 列表允许重复元素
1) "c"
2) "c"
# 添加多个元素
redis> RPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "a"
2) "b"
3) "c"

rpushx

rpushx key value

可用版本： >= 2.2.0

时间复杂度： O(1)

将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。

和 RPUSH key value [value …] 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

返回值

RPUSHX 命令执行之后，表的长度。

代码示例
# key不存在
redis> LLEN greet
(integer) 0
redis> RPUSHX greet "hello"     # 对不存在的 key 进行 RPUSHX，PUSH 失败。
(integer) 0
# key 存在且是一个非空列表
redis> RPUSH greet "hi"         # 先用 RPUSH 插入一个元素
(integer) 1
redis> RPUSHX greet "hello"     # greet 现在是一个列表类型，RPUSHX 操作成功。
(integer) 2
redis> LRANGE greet 0 -1
1) "hi"
2) "hello"

lpop

lpop key

可用版本： >= 1.0.0

时间复杂度： O(1)

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

返回值

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

代码示例
redis> LLEN course
(integer) 0
redis> RPUSH course algorithm001
(integer) 1
redis> RPUSH course c++101
(integer) 2
redis> LPOP course  # 移除头元素
"algorithm001"

rpop

rpop key

可用版本： >= 1.0.0

时间复杂度： O(1)

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

返回值

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

代码示例
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOP mylist           # 返回被弹出的元素
"three"
redis> LRANGE mylist 0 -1    # 列表剩下的元素
1) "one"
2) "two"

rpoplpush

rpoplpush source destination

可用版本： >= 1.2.0

时间复杂度： O(1)

命令 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 不同
redis> LRANGE alpha 0 -1         # 查看所有元素
1) "a"
2) "b"
3) "c"
4) "d"
redis> RPOPLPUSH alpha reciver   # 执行一次 RPOPLPUSH 看看
"d"
redis> LRANGE alpha 0 -1
1) "a"
2) "b"
3) "c"
redis> LRANGE reciver 0 -1
1) "d"
redis> RPOPLPUSH alpha reciver   # 再执行一次，证实 RPOP 和 LPUSH 的位置正确
"c"
redis> LRANGE alpha 0 -1
1) "a"
2) "b"
redis> LRANGE reciver 0 -1
1) "c"
2) "d"
# source 和 destination 相同
redis> LRANGE number 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
redis> RPOPLPUSH number number
"4"
redis> LRANGE number 0 -1           # 4 被旋转到了表头
1) "4"
2) "1"
3) "2"
4) "3"
redis> RPOPLPUSH number number
"3"
redis> LRANGE number 0 -1           # 这次是 3 被旋转到了表头
1) "3"
2) "4"
3) "1"
4) "2"

lrem

lrem key count value

可用版本： >= 1.0.0

时间复杂度： O(N)， N 为列表的长度。

根据参数 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

可用版本： >= 1.0.0

时间复杂度： O(1)

返回列表 key 的长度。

如果 key 不存在，则 key 被解释为一个空列表，返回 0 .

如果 key 不是列表类型，返回一个错误。

返回值

列表 key 的长度。

代码示例
# 空列表
redis> LLEN job
(integer) 0
# 非空列表
redis> LPUSH job "cook food"
(integer) 1
redis> LPUSH job "have lunch"
(integer) 2
redis> LLEN job
(integer) 2

lindex

lindex key index

可用版本： >= 1.0.0

时间复杂度：O(N)， N 为到达下标 index 过程中经过的元素数量。因此，对列表的头元素和尾元素执行 LINDEX 命令，复杂度为O(1)。

返回列表 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

可用版本： >= 2.2.0

时间复杂度: O(N)， N 为寻找 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

可用版本： >= 1.0.0

时间复杂度：对头元素或尾元素进行 LSET 操作，复杂度为 O(1)。其他情况下，为 O(N)， N 为列表的长度。

将列表 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

可用版本： >= 1.0.0

时间复杂度: O(S+N)， S 为偏移量 start ， N 为指定区间内元素的数量。

返回列表 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

可用版本： >= 1.0.0

时间复杂度: O(N)， N 为被移除的元素的数量。

对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

当 key 不是列表类型时，返回一个错误。

LTRIM 命令通常和 LPUSH key value [value …] 命令或 RPUSH key value [value …] 命令配合使用，举个例子：
LPUSH log newest_log
LTRIM log 0 99
这个例子模拟了一个日志程序，每次将最新日志 newest_log 放到 log 列表中，并且只保留最新的 100 项。注意当这样使用 LTRIM 命令时，时间复杂度是O(1)，因为平均情况下，每次只有一个元素被移除。

注意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

可用版本： >= 2.0.0

时间复杂度： O(1)

BLPOP 是列表的阻塞式(blocking)弹出原语。

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

当给定多个 key 参数时，按参数 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)
返回值

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

模式：事件提醒

有时候，为了等待一个新元素到达数据中，需要使用轮询的方式对数据进行探查。

另一种更好的方式是，使用系统提供的阻塞原语，在新元素到达时立即进行处理，而新元素还没到达时，就一直阻塞住，避免轮询占用资源。

对于 Redis ，我们似乎需要一个阻塞版的 SPOP key 命令，但实际上，使用 BLPOP 或者 BRPOP key [key …] timeout 就能很好地解决这个问题。

使用元素的客户端(消费者)可以执行类似以下的代码：
LOOP forever
    WHILE SPOP(key) returns elements
        ... process elements ...
    END
    BRPOP helper_key
END
添加元素的客户端(生产者)则执行以下代码：
MULTI
    SADD key element
    LPUSH helper_key x
EXEC

brpop

brpop key [key …] timeout

可用版本： >= 2.0.0

时间复杂度： O(1)

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

可用版本： >= 2.2.0

时间复杂度： O(1)

BRPOPLPUSH 是 RPOPLPUSH source destination 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH source destination 一样。

当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH key value [value …] 或 RPUSH key value [value …] 命令为止。

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

更多相关信息，请参考 RPOPLPUSH source destination 命令。

返回值

假如在指定时间内没有任何元素被弹出，则返回一个 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)

集合（set）

sadd

sadd key member [member …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 是被添加的元素的数量。

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。

假如 key 不存在，则创建一个只包含 member 元素作成员的集合。

当 key 不是集合类型时，返回一个错误。

Note

在Redis2.4版本以前， SADD 只接受单个 member 值。

返回值

被添加到集合中的新元素的数量，不包括被忽略的元素。

代码示例
# 添加单个元素
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

可用版本： >= 1.0.0

时间复杂度: O(1)

判断 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

可用版本： >= 1.0.0

时间复杂度: O(1)

移除并返回集合中的一个随机元素。

如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 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"

srandmember

srandmember key [count]

可用版本： >= 1.0.0

时间复杂度: 只提供 key 参数时为 O(1) 。如果提供了 count 参数，那么为 O(N) ，N 为返回数组的元素个数。

如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。

从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数：

如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。

如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

该操作和 SPOP key 相似，但 SPOP key 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

返回值

只提供 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 …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 为给定 member 元素的数量。

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。

当 key 不是集合类型，返回一个错误。

Note

在 Redis 2.4 版本以前， SREM 只接受单个 member 值。

返回值

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

代码示例
# 测试数据
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 destination member

可用版本： >= 1.0.0

时间复杂度: O(1)

将 member 元素从 source 集合移动到 destination 集合。

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

可用版本： >= 1.0.0

时间复杂度: O(1)

返回集合 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

可用版本： >= 1.0.0

时间复杂度: O(N)， N 为集合的基数。

返回集合 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"

srem

srem key member [member …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 为给定 member 元素的数量。

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。

当 key 不是集合类型，返回一个错误。

Note

在 Redis 2.4 版本以前， SREM 只接受单个 member 值。

返回值

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

代码示例
# 测试数据
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 destination member

可用版本： >= 1.0.0

时间复杂度: O(1)

将 member 元素从 source 集合移动到 destination 集合。

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

可用版本： >= 1.0.0

时间复杂度: O(1)

返回集合 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

可用版本： >= 1.0.0

时间复杂度: O(N)， N 为集合的基数。

返回集合 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"

sscan

sinter

sinter key [key …]

可用版本： >= 1.0.0

时间复杂度: O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。

返回一个集合的全部成员，该集合是所有给定集合的交集。

不存在的 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 …]

可用版本： >= 1.0.0

时间复杂度: O(N * M)， N 为给定集合当中基数最小的集合， M 为给定集合的个数。

这个命令类似于 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 …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 是所有给定集合的成员数量之和。

返回一个集合的全部成员，该集合是所有给定集合的并集。

不存在的 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 …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 是所有给定集合的成员数量之和。

这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 已经存在，则将其覆盖。

destination 可以是 key 本身。

返回值

结果集中的元素数量。

代码示例
redis> SMEMBERS NoSQL
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 …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 是所有给定集合的成员数量之和。

返回一个集合的全部成员，该集合是所有给定集合之间的差集。

不存在的 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 …]

可用版本： >= 1.0.0

时间复杂度: O(N)， N 是所有给定集合的成员数量之和。

这个命令的作用和 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"

有序集合（SortedSet）

zadd

zadd key score member [[score member] [score member] …]

可用版本： >= 1.2.0

时间复杂度: O(M*log(N))， N 是有序集的基数， M 为成功添加的新成员的数量。

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。

score 值可以是整数值或双精度浮点数。

如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。

当 key 存在但不是有序集类型时，返回一个错误。

对有序集的更多介绍请参见 sorted set 。

Note

在 Redis 2.4 版本以前， ZADD 每次只能添加一个元素。

返回值

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

代码示例
# 添加单个元素
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

可用版本： >= 1.2.0

时间复杂度: O(1)

返回有序集 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 increment member

可用版本： >= 1.2.0

时间复杂度: O(log(N))

为有序集 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

可用版本： >= 1.2.0

时间复杂度: O(1)

返回有序集 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

可用版本： >= 2.0.0

时间复杂度: O(log(N))， N 为有序集的基数。

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

关于参数 min 和 max 的详细使用方法，请参考 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 命令。

返回值

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]

可用版本： >= 1.2.0

时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

返回有序集 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]

可用版本： >= 1.2.0

时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数。

返回有序集 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]

可用版本： >= 1.0.5

时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为被结果集的基数。

返回有序集 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 max min [WITHSCORES] [LIMIT offset count]

可用版本： >= 2.2.0

时间复杂度: O(log(N)+M)， N 为有序集的基数， M 为结果集的基数。

返回有序集 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

可用版本： >= 2.0.0

时间复杂度: O(log(N))

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

排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

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

返回值

如果 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

可用版本： >= 2.0.0

时间复杂度: O(log(N))

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

排名以 0 为底，也就是说， score 值最大的成员排名为 0 。

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

返回值

如果 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 …]

可用版本： >= 1.2.0

时间复杂度: O(M*log(N))， N 为有序集的基数， M 为被成功移除的成员的数量。

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。

当 key 存在但不是有序集类型时，返回一个错误。

Note

在 Redis 2.4 版本以前， ZREM 每次只能删除一个元素。

返回值

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

代码示例
# 测试数据
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

zremrangebyank

zremrangebyank key start stop

可用版本： >= 2.0.0

时间复杂度: O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

移除有序集 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

可用版本： >= 1.2.0

时间复杂度： O(log(N)+M)， N 为有序集的基数，而 M 为被移除成员的数量。

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

自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内，详情请参见 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count] 命令。

返回值

被移除成员的数量。

代码示例
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]

可用版本： >= 2.8.9

时间复杂度：O(log(N)+M)，其中 N 为有序集合的元素数量，而 M 则是命令返回的元素数量。如果 M 是一个常数（比如说，用户总是使用 LIMIT 参数来返回最先的 10 个元素），那么命令的复杂度也可以看作是 O(log(N)) 。

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序（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 <zset> - + ，命令将返回有序集合中的所有元素。

返回值

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

代码示例
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

可用版本： >= 2.8.9

时间复杂度： O(log(N))，其中 N 为有序集合包含的元素数量。

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

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 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

zremrangebylex

zremrangebylex key min max

可用版本： >= 2.8.9

时间复杂度： O(log(N)+M)，其中 N 为有序集合的元素数量，而 M 则为被移除的元素数量。

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

这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX key min max [LIMIT offset count] 命令的 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"

zscan

zscan key cursor [MATCH pattern] [COUNT count]

zunionstore

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

可用版本：>= 2.0.0

时间复杂度: O(N)+O(M log(M))， N 为给定有序集基数的总和， M 为结果集的基数。

计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和。

WEIGHTS

使用 WEIGHTS 选项，你可以为每个给定有序集分别指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。

如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。

AGGREGATE

使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。

默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之和作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的最大 score 值作为结果集中该成员的 score 值。

返回值

保存到 destination 的结果集的基数。

代码示例
redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"
redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司决定加薪。。。除了程序员。。。
(integer) 6
redis> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
7) "herry"
8) "6000"
9) "mary"
10) "10500"
11) "bob"
12) "12000"

zinterstore

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

可用版本： >= 2.0.0

时间复杂度: O(N*K)+O(M*log(M))， N 为给定 key 中基数最小的有序集， K 为给定有序集的数量， M 为结果集的基数。

计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.

关于 WEIGHTS 和 AGGREGATE 选项的描述，参见 ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX] 命令。

返回值

保存到 destination 的结果集的基数。

代码示例
redis > ZADD mid_test 70 "Li Lei"
(integer) 1
redis > ZADD mid_test 70 "Han Meimei"
(integer) 1
redis > ZADD mid_test 99.5 "Tom"
(integer) 1
redis > ZADD fin_test 88 "Li Lei"
(integer) 1
redis > ZADD fin_test 75 "Han Meimei"
(integer) 1
redis > ZADD fin_test 99.5 "Tom"
(integer) 1
redis > ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3
redis > ZRANGE sum_point 0 -1 WITHSCORES     # 显示有序集内所有成员及其 score 值
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"

数据库

exists:

检查给定 key 是否存在。

exists key

若 key 存在，返回 1 ，否则返回 0 。

type:

返回 key 所储存的值的类型。

type key

none (key不存在)

string (字符串)

list (列表)

set (集合)

zset (有序集)

hash (哈希表)

stream （流）

rename

将 key 改名为 newkey 。

当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。

当 newkey 已经存在时， RENAME 命令将覆盖旧值。

rename key newkey

改名成功时提示 OK ，失败时候返回一个错误。

move:

将当前数据库的 key 移动到给定的数据库 db 当中。

如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。

因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。

move key db

移动成功返回 1 ，失败则返回 0 。

del

删除给定的一个或多个 key 。

不存在的 key 会被忽略。

del key

被删除 key 的数量。

randomkey

从当前数据库中随机返回(不删除)一个 key 。

randomkey

当数据库不为空时，返回一个 key 。当数据库为空时，返回 nil

dbsize

返回当前数据库的 key 的数量。

dbsize

当前数据库的 key 的数量。

keys

keys * 查看当前库中的所有key

info

查看redis库中查看那几个库库中存在数据

# Keyspace
db0:keys=2,expires=0,avg_ttl=0
db2:keys=6,expires=0,avg_ttl=0

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

动态规划实战：泰波拉契数与爬楼梯

set元素类型就是KeyType。元素按KeyType的比较规则（通常是自动排序。元素值唯一。尝试插入重复值会被忽略（insert方法会返回一个包含迭代器和bool的pair，其中bool为false表示插入失败）。multiset元素类型也是KeyType。元素同样自动排序。元素值可以重复。插入操作总是成功。map元素类型是。元素按KeyType的比较规则自动排序。键（Key）唯一。尝试插入相同

2048 AI社区

从Web到AI:多模态Agent Skills生态系统实战（Java+Vue构建跨模态智能体）

2048 AI社区

上下文协议（MCP）Java SDK 指南

我们先通过这个类，定义一个非常简单的 MCP 工具，用来打印收到的提示词（prompt），该方法返回一个.build();});这里我们首先定义了输入的 JSON Schema，用来为用户输入建立一个清晰的契约。接着，使用该输入 Schema 来实例化一个Tool，在处理逻辑中提取出prompt参数，并最终返回包含该prompt的结果。在本文中，我们首先回顾了 MCP 及其 Java SDK 的整