概述
Redis （Remote DIctionary Server）通常被称为数据结构服务器，因为值 （value）可以是字符串（String）, 哈希（Map）, 列表 （list）, 集合（Sets）或有序集合（Sorted Sets）等类型。
Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对（Key-Value）存储数据库，并提供多种语言的 API。
Redis 命令
Redis 连接
无密码连接 Redis
1
2
| [root@VM-4-12-centos data]# redis-cli
127.0.0.1:6379>
|
使用密码连接指定地址 Redis（通常不使用 -a）
1
2
3
4
5
| [root@VM-4-12-centos data]# redis-cli -h 127.0.0.1 -p 6379 -a "123456"
127.0.0.1:6379>
[root@VM-4-12-centos data]# redis-cli -h 127.0.0.1 -p 6379
127.0.0.1:6379> auth 123456
OK
|
检测 Redis 是否正常
1
2
| 127.0.0.1:6379> ping
PONG
|
切换数据库操作
1
2
3
4
5
| 127.0.0.1:6379> select 3
OK
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379>
|
退出连接
1
2
| 127.0.0.1:6379> quit
[root@VM-4-12-centos data]#
|
Redis 字符串（String）
String 类型 value 最大可以存储 512 MB
| 命令 | 例子 | 结果 | 描述 |
|---|
set key value | set key hello | 成功返回OK | 设置指定 key 的值 |
get key | get key | 设置的值或(nil) | 获取指定 key 的值 |
setnx key value | setnx key "hello" | 成功 1
失败 0 | key 不存在时设值 |
setex key seconds value | setex key 60 "hello" | 成功返回OK | 设 key 值
过期时间为秒 |
psetex key milliseconds value | psetex key 1000 "Hello" | 成功返回OK | 设 key 值
过期时间为毫秒 |
getset key value | getset key hello1 | 返回旧值 | 设新 key
返回旧 key 值 |
mget key1 [key2] | mget key1 key2 key3 | 返回列表值 | 批量获取值 |
mset key value [key value] | mset key1 "hello1" key2 "hello2" key3 "hello3" | 成功返回OK | 批量设置值 |
msetnx key value [key value] | msetnx key1 "Hello" key2 "there" | 成功 1
失败 0 | 批量设置值
key 都不存在才能成功 |
incr key | incr key1 | 1 | 累加 1 默认 0 |
decr key | decr key1 | -1 | 累减 1 默认 0 |
incrby key increment | incrby key 2 | 2 | 累加指定值
默认 0 |
decrby key decrement | decrby key 2 | -2 | 累减指定值
默认 0 |
incrbyfloat key increment | incrbyfloat key 0.2
incrbyfloat key -0.2 | 0.2
-0.2 | 浮点计算 |
append key value | append key 123 | 字符串长度3 | 追加数据 |
BitMap 相关指令
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| # 用于对 key 所储存的字符串值，设置或清除指定偏移量上的位（bit）。
# offset 参数需要大于等于0，并且小于 2^32（4294967296，512 MB）
setbit key offset value
# 对 key 所储存的字符串值，获取指定偏移量上的位（bit）。
getbit key offset
# 获取指定范围内值为 1 的个数
# start 和 end 以字节为单位，可为负数
bitcount key start end
# BitMap 间的运算
# operations 位移操作符，枚举值
AND 与运算 &
OR 或运算 |
XOR 异或 ^
NOT 取反 ~
# destkey 计算的结果，会存储在该key中
# key1 key2 参与运算的key，not运算只能一个key
# 当 BITOP 处理不同长度的字符串时，较短的那个字符串所缺少的部分会被看作 0。
# 返回值是保存到 destkey 的字符串的长度（以字节 byte 为单位），和输入 key 中最长的字符串长度相等。
bitop operation destkey key1 [key2]
# 返回字符串里面第一个被设置为 1 或者 0 的 bit 位
bitpos key bit [start] [end]
# 可以将一个 Redis 字符串看作是一个由二进制位组成的数组
# 并对这个数组中任意偏移进行访问
# 详细介绍：https://redis.io/commands/bitfield
bitfield key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]
|
set key value
设置指定 key 的值，如果 key 已经存储其他值，set 就覆写旧值，且无视类型。
1
2
| 127.0.0.1:6379> set key hello
OK
|
get key
获取指定 key 的值，如果 key 不存在，返回 nil 。
如果key 储存的值不是字符串类型，返回一个错误。
1
2
3
4
5
6
| 127.0.0.1:6379> get key
"hello"
127.0.0.1:6379> get key1
(nil)
127.0.0.1:6379> get hakey
(error) WRONGTYPE Operation against a key holding the wrong kind of value
|
setnx key value
setnx（ SET if Not eXists ）命令在指定的 key 不存在时，为 key 设置指定的值，这种情况下等同 SET 命令。当 key存在时，什么也不做。
返回值（整数）：
1
2
3
4
| 127.0.0.1:6379> setnx key "hello"
(integer) 1
127.0.0.1:6379> setnx key "hello"
(integer) 0
|
setex key seconds value
将键 key 的值设置为 value，并将键 key 的生存时间设置为 seconds 秒钟。
如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值包括过期时间。
1
2
| 127.0.0.1:6379> setex key 60 "hello"
OK
|
psetex key milliseconds value
与 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间。
1
2
| 127.0.0.1:6379> psetex key 1000 "Hello"
OK
|
getset key value
将给定 key 的值设为 value ，并返回 key 的旧值。
1
2
3
4
5
| 127.0.0.1:6379> getset key hello1
"hello"
127.0.0.1:6379> get key
"hello1"
127.0.0.1:6379>
|
mget key1 [key2]
获取所有（一个或多个）给定 key 的值。
有某个 key 不存在或者值不是字符串，那么这个 key 返回特殊值 nil （使用 get 命令类型不对会报错）。
结果返回一个列表， 列表中包含了所有给定键的值。
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> set key1 hello1
OK
127.0.0.1:6379> set key2 hello2
OK
127.0.0.1:6379> mget key1 key2 key3
1) "hello1"
2) "hello2"
3) (nil)
|
mset key value [key value]
同时设置一个或多个 key-value 对。像 SET 一样，会用新值替换旧值。
该命令是原子操作，所有 key 的值同时设置。
客户端不会看到有些 key 值被修改，而另一些 key 值没变。
1
2
| 127.0.0.1:6379> mset key1 "hello1" key2 "hello2" key3 "hello3"
OK
|
msetnx key value [key value]
同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在才会设置成功。
即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置。
MSETNX 可以用来设置逻辑对象的属性，来确保要么都设置，要么都不设置。
返回值（整数）：
1 key 全部设置设置成功
0 key 有一个或者过多个已存在，不做操作
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> msetnx key1 "Hello" key2 "there"
(integer) 1
127.0.0.1:6379> msetnx key1 "Hello1" key2 "there1" key3 "hi"
(integer) 0
127.0.0.1:6379> get key3
(nil)
127.0.0.1:6379> get key1
"Hello"
|
incr key
将 key 中储存的数字值增一（increment）。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误 。
本操作的值限制在 64 位（bit）有符号数字表示之内。
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> set key1 5
OK
127.0.0.1:6379> incr key1
(integer) 6
127.0.0.1:6379> incr key2
(integer) 1
127.0.0.1:6379> get key1
"6"
127.0.0.1:6379> get key2
"1"
|
decr key
Redis Decr 命令将 key 中储存的数字值减一（decrement）。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位（bit）有符号数字表示之内。
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> set key1 5
OK
127.0.0.1:6379> decr key1
(integer) 4
127.0.0.1:6379> decr key2
(integer) -1
127.0.0.1:6379> get key1
"4"
127.0.0.1:6379> get key2
"-1"
|
incrby key increment
将 key 所储存的值加上给定的增量值，同 incr 指令。
1
2
3
4
| 127.0.0.1:6379> set key 5
OK
127.0.0.1:6379> incrby key 2
(integer) 7
|
decrby key decrement
将 key 所储存的值减去给定的减量值，同 decr 指令。
1
2
3
4
| 127.0.0.1:6379> set key 5
OK
127.0.0.1:6379> decrby key 2
(integer) 3
|
incrbyfloat key increment
将 key 所储存的值加上给定的浮点增量值。
如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。
小数部分尾随的 0 会被移除， 命令会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> set key 3.0
OK
127.0.0.1:6379> get key
"3.0"
127.0.0.1:6379> incrbyfloat key 0.2
"3.2"
127.0.0.1:6379> incrbyfloat key -0.2
"3"
|
append key value
如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原来值（value）的末尾。对不存在的 key 进行 APPEND ，等同于 SET 指令。
返回值（整数）： 追加指定值之后， key 中字符串的长度。
1
2
3
4
5
6
| 127.0.0.1:6379> append key hello
(integer) 5
127.0.0.1:6379> append key 123
(integer) 8
127.0.0.1:6379> get key
"hello123"
|
Redis 哈希（Hash）
Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。
每个哈希键中可以存储多达 40 亿个字段值对。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| # 将哈希表 key 中的字段 field 的值设为 value
# Redis 4.0 起，可一次设置一个或多个 field/value 对
hset key field value
# 获取存储在哈希表中指定字段的值
hget key field
# 查看哈希表 key 中，指定的字段是否存在
hexists key field
# 删除一个或多个哈希表字段
hdel key field1 [field2]
# 获取在哈希表中指定 key 的所有字段和值
hgetall key
# 获取所有哈希表中的字段
hkeys key
# 获取哈希表中所有值
hvals key
# 只有在字段 field 不存在时，设置哈希表字段的值
hsetnx key field value
# 同时将多个 field-value （字段-值）对设置到哈希表 key 中
# Redis 4.0 起，HSET 可替代该命令
hmset key field1 value1 [field2 value2]
# 获取所有给定字段的值
hmget key field1 [field2]
# 为哈希表 key 中的指定字段的整数值加上增量 increment
hincrby key field increment
# 为哈希表 key 中的指定字段的浮点数值加上增量 increment
hincrbyfloat key field increment
# 获取哈希表中字段的数量
hlen key
# 返回哈希表中值长度
hstrlen key field
# 迭代哈希表中的键值对（count 在值少的情况下会失败）
hscan key cursor [MATCH pattern] [COUNT count]
|
hset key field value
用于为存储在 key 中的哈希表的 field 字段赋值 value
（从 Redis 4.0 起，HSET 可以一次设置一个或多个 field/value 对，同 hmset）
返回值：
1
2
3
4
5
6
| 127.0.0.1:6379> hset hkey name "summer"
(integer) 1
127.0.0.1:6379> hset hkey name "summer1"
(integer) 0
127.0.0.1:6379> hset hkey sex "未知"
(integer) 1
|
hget key field
用于返回哈希表中指定字段 field 的值
1
2
3
4
| 127.0.0.1:6379> hget hkey name
"summer"
127.0.0.1:6379> hget hkey name1
(nil)
|
hexists key field
用于查看哈希表的指定字段field 是否存在
1
2
3
4
| 127.0.0.1:6379> hexists hkey name
(integer) 1
127.0.0.1:6379> hexists hkey name1
(integer) 0
|
hdel key field1 [field2]
用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。
删空所有（字段-值）对后 key 值将不存在。
返回值：被成功删除字段的数量，不包括被忽略的字段。
1
2
| 127.0.0.1:6379> hdel hkey name sex name1
(integer) 2
|
hgetall key
返回存储在 key 中的哈希表中所有的字段和值。
返回值里，紧跟每个字段（field name）之后是字段的值（value），所以返回值的长度是哈希表大小的两倍。（在开发语言中会呈现键值对形式）
1
2
3
4
5
6
7
| 127.0.0.1:6379> hgetall hkey
1) "sex"
2) "1"
3) "name"
4) "summer"
127.0.0.1:6379> hgetall hkey1
(empty array)
|
hkeys key
获取存储在 key 中哈希表的所有字段
1
2
3
4
5
| 127.0.0.1:6379> hkeys hkey
1) "sex"
2) "name"
127.0.0.1:6379> hkeys hkey1
(empty array)
|
hvals key
获取哈希表所有字段（field）的值
1
2
3
4
5
| 127.0.0.1:6379> hvals hkey
1) "1"
2) "summer"
127.0.0.1:6379> hvals hkey1
(empty array)
|
hsetnx key field value
用于为哈希表中不存在的字段赋值 。
如果字段已经存在于哈希表中，操作无效。
成功返回1，失败返回0
1
2
3
4
| 127.0.0.1:6379> hsetnx hkey field "val"
(integer) 1
127.0.0.1:6379> hsetnx hkey field "val"
(integer) 0
|
hmset key field1 value1 [field2 value2]
用于同时将多个 field-value (字段-值)对设置到哈希表中。
此命令会覆盖哈希表中已存在的字段。
如果哈希表不存在，会创建一个空哈希表，并执行 HMSET 操作。
Redis 4.0.0起，HMSET 被废弃，请使用 HSET 代替。
1
2
| 127.0.0.1:6379> hmset hkey sex "1" name "summer"
OK
|
hmget key field1 [field2]
返回哈希表中，一个或多个给定字段的值。
如果指定的字段不存在于哈希表，那么返回一个 nil 值。
1
2
3
4
| 127.0.0.1:6379> hmget hkey name sex name1
1) "summer"
2) "1"
3) (nil)
|
hincrby key field increment
为哈希表 key 中的域 field 的值加上增量 increment 。
增量也可以为负数，相当于对给定域进行减法操作。
如果 key 不存在，一个新的哈希表被创建并执行hincrby 命令。
如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
对一个储存字符串值的域 field 执行hincrby命令将造成一个错误 ERR ERR hash value is not an integer。
本操作的值被限制在 64 位（bit）有符号数字表示之内。
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> hincrby hkey age 1
(integer) 1
127.0.0.1:6379> hincrby hkey age 1
(integer) 2
127.0.0.1:6379> hincrby hkey age 3
(integer) 5
127.0.0.1:6379> hincrby hkey age -3
(integer) 2
127.0.0.1:6379> hincrby hkey name 1
(error) ERR hash value is not an integer
|
hincrbyfloat key field increment
用于为哈希表中的字段值加上指定浮点数增量值。
命令的详细功能和 INCRBYFLOAT命令类似。
1
2
3
4
| 127.0.0.1:6379> hincrbyfloat hkey field1 5.1
"5.1"
127.0.0.1:6379> hincrbyfloat hkey field1 -0.1
"5"
|
hlen key
获取哈希表中字段fields的数量。
1
2
3
4
| 127.0.0.1:6379> hset hkey name "summer" age 18
(integer) 2
127.0.0.1:6379> hlen hkey
(integer) 2
|
hstrlen key field
存储在 key 中的哈希表里， 与给定域 field 相关联的值的字符串长度（string length）。
如果给定的键或者域不存在， 那么命令返回 0
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> hset hkey name "summer" age 18
(integer) 2
127.0.0.1:6379> hstrlen hkey name
(integer) 6
127.0.0.1:6379> hstrlen hkey age
(integer) 2
127.0.0.1:6379> hstrlen hkey name1
(integer) 0
127.0.0.1:6379> hstrlen hkey1 name1
(integer) 0
|
hscan key cursor [MATCH pattern] [COUNT count]
用于遍历哈希表中的键值对。可用作删除 bigkey
- cursor - 游标。
- pattern - 匹配的模式。
- count - 指定从数据集里返回多少元素，默认值为 10 。（键值对少会失效 - 约100）
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> hset hkey name "summer" name1 "summer1" name2 "summer2" age 18
(integer) 4
127.0.0.1:6379> hscan hkey 0 match "na*"
1) "0"
2) 1) "name"
2) "summer"
3) "name1"
4) "summer1"
5) "name2"
6) "summer2"
|
Redis 列表（Lists）
Redis 列表是按插入顺序排序的字符串列表。
可以在列表的头部（左边）或尾部（右边）添加元素。
数据主要要体现顺序，底层使用双向链表实现。有索引的概念，元素可重复。
列表可以包含超过 40 亿 个元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| # 将一个或多个值插入到列表头部
lpush key value1 [value2]
# 将一个值插入到已存在的列表头部
lpushx key value
# 获取列表指定范围内的元素
lrange key start stop
# 移出并获取列表的第一个元素
lpop key
# 获取列表长度
llen key
# 在列表的元素前或者后插入元素
linster key before|after pivot value
# 通过索引获取列表中的元素
lindex key index
# 通过索引设置列表元素的值
lset key index value
# 移除列表元素
lrem key count value
# 对一个列表进行修剪(trim)。
# 让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
ltrim key start stop
# 在列表尾部添加一个或多个值
rpush key value1 [value2]
# 为已存在的列表添加值
rpushx key value
# 移除列表的最后一个元素，返回值为移除的元素。
rpop key
# 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
rpoplpush source destination
# 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
blpop key1 [key2] timeout
# 移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
brpop key1 [key2] timeout
# 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它。
# 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
brpoplpush source destination timeout
|
技巧
Redis 版本>= 6.0.6. 提供 LPOS 指令
Redis 版本>= 6.2.0. 提供 BLMOVE、LMOVE 指令
lpush key value1 [value2]
将一个或者多个值（多值 >= 2.4 版本）插入到列表key头部。
如果 key 不存在，那么在进行 push 操作前会创建一个空列表。
如果 key 对应的值不是 list 类型，那么会返回一个错误。
插入多元素时，value 从左到右依次插入到 list 的头部，最右边的数值为最终头（索引值为 0）。
返回值：执行插入后列表的最终长度。
1
2
3
4
5
6
7
8
9
| 127.0.0.1:6379> lpush lkey a
(integer) 1
127.0.0.1:6379> lpush lkey a b c
(integer) 4
127.0.0.1:6379> lrange lkey 0 -1 # 查询列表中所有值
1) "c"
2) "b"
3) "a"
4) "a"
|
lpushx key value1 [value2]
将一个或者多个值（多值 >= 4.0 版本）插入到列表key头部。
当key不存在时不做任何操作。
返回值：成功操作后最终长度，key不存在返回 0
1
2
3
4
5
6
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lpushx lkey a b c
(integer) 6
127.0.0.1:6379> lpushx lkey1 a b c
(integer) 0
|
lrange key start stop
获取列表中指定区间内的元素。
其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。
以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
注意：lrange 命令属于闭区间，如： lrange lkey 0 10 是返回 11 个元素的列表。
范围超过下标志不会报错。
如果 start 下标大于列表最大下标，返回空列表。
如果 stop 下标大于列表最大下标， 则 Redis 会将 stop 值设为最大下标
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> lrange lkey 0 1
1) "c"
2) "b"
127.0.0.1:6379> lrange lkey 10 100
(empty array)
127.0.0.1:6379> lrange lkey 0 10
1) "c"
2) "b"
3) "a"
|
lpop key
移除并返回列表的第一个元素。
key 不存在时返回 nil
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> lpop lkey
"c"
127.0.0.1:6379> lpop lkey
"b"
127.0.0.1:6379> lpop lkey
"a"
127.0.0.1:6379> lpop lkey
(nil)
|
llen key
返回存储在 key 中的列表长度。
如果 key 不存在，则 key 被解释为一个空列表，返回 0 。
如果 key 不是列表类型，返回一个错误。
1
2
3
4
5
6
| 127.0.0.1:6379> llen lkey
(integer) 3
127.0.0.1:6379> llen hkey
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> llen lkey1
(integer) 0
|
linster key before|after pivot value
把 value 插入到列表 key 中参考值 pivot 的前面或后面。
当 key 或者 pivot 不存在时，什么都不执行。
当 key 存在，值不是列表类型时，返回错误。
返回值：如果值存在，返回操作后列表长度。如果 key 不存在返回0，参考值pivot不存在返回-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> linsert lkey before b bef
(integer) 4
127.0.0.1:6379> linsert lkey after b after
(integer) 5
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "bef"
3) "b"
4) "after"
5) "a"
127.0.0.1:6379> linsert lkey1 before d test
(integer) 0
127.0.0.1:6379> linsert lkey before d test
(integer) -1
|
lindex key index
用于通过索引获取列表中的元素。
index 下标是从 0 开始索引。
负数用于从列表尾部开始索引的元素，-1 表示最后一个元素，-2 表示倒数第二个元素。
当 key 值不是列表的时候，会返回错误。
返回值：查询的值，当超出索引返回会返回nil
1
2
3
4
5
6
7
8
9
10
11
12
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> lindex lkey 0
"c"
127.0.0.1:6379> lindex lkey -1
"a"
127.0.0.1:6379> lindex lkey 10
(nil)
|
lset key index value
通过索引来设置指定元素的值。
当索引值超出范围，或对一个空列表进行 LSET 时，返回一个错误。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 127.0.0.1:6379> lpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> lset lkey 1 bb
OK
127.0.0.1:6379> lrange lkey 0 -1
1) "c"
2) "bb"
3) "a"
127.0.0.1:6379> lset lkey1 0 bb
(error) ERR no such key
127.0.0.1:6379> lset lkey 10 bb
(error) ERR index out of range
|
lrem key count value
用于从列表 key 中删除前 count 个值等于 value 的元素。
这个 count 参数通过下面几种方式影响这个操作：
- count > 0: 从头到尾扫描，删除个数为 count 值为 value 的元素。
- count < 0: 从尾到头扫描，删除个数为 count（绝对值） 值为 value 的元素。
- count = 0: 移除所有值为 value 的元素。
当 key 或者 value 不存在时返回 0
返回值：删除元素的个数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| 127.0.0.1:6379> lpush lkey a a a b c c c d a a
(integer) 10
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
2) "a"
3) "d"
4) "c"
5) "c"
6) "c"
7) "b"
8) "a"
9) "a"
10) "a"
127.0.0.1:6379> lrem lkey -2 a # 删除尾部两个 a
(integer) 2
127.0.0.1:6379> lrem lkey 1 a # 删除头部一个 a
(integer) 1
127.0.0.1:6379> lrem lkey 0 c # 删除全部 c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
2) "d"
3) "b"
4) "a"
127.0.0.1:6379> lrem lkey 0 ss
(integer) 0
127.0.0.1:6379> lrem lkey1 0 ss
(integer) 0
|
ltrim key start stop
用于修剪（trim）一个已存在的 list，这样 list 就会只包含指定范围的指定元素。
0 是列表里的第一个元素， -1 表示列表里的最后一个元素。
如果 start 超过列表尾部（索引最大值），或者 start > stop`，结果会是列表变成空表（该 key 会被移除）。
如果 stop`超过列表尾部（索引最大值），Redis 会将其当作列表的最后一个元素。
技巧
LTRIM 的一个常见用法是和 LPUSH / RPUSH 一起使用。 例如：
1
2
| LPUSH lkey value
LTRIM lkey 0 99
|
这对命令会将一个新的元素 push 进列表里，并保证该列表不会增长到超过100个元素。
这是很有用的，比如当用 Redis 来存储日志。 需要特别注意的是，当用这种方式来使用 LTRIM 的时候，操作的复杂度是 O(1) ， 因为平均情况下，每次只有一个元素会被移除。
rpush key value1 [value2]
将一个或者多个值（多值 >= 2.4 版本）插入到列表key尾部（右边）。
如果 key 不存在，那么在进行 push 操作前会创建一个空列表。
如果 key 对应的值不是 list 类型，那么会返回一个错误。
插入多元素时，value 从左到右依次插入到 list 的尾部，最右边的数值为最终尾（索引值为 -1）。
返回值：执行插入后列表的最终长度。
1
2
3
4
5
6
7
8
9
| 127.0.0.1:6379> rpush lkey a
(integer) 1
127.0.0.1:6379> rpush lkey b c d
(integer) 4
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
|
rpushx key value
将一个或者多个值（多值 >= 4.0 版本）插入到列表key尾部。
当key不存在时不做任何操作。
返回值：成功操作后最终长度，key不存在返回 0
1
2
3
4
5
6
| 127.0.0.1:6379> rpush lkey a b c
(integer) 3
127.0.0.1:6379> rpushx lkey a b c
(integer) 6
127.0.0.1:6379> rpushx lkey1 a b c
(integer) 0
|
rpop key
移除并返回列表的最后一个元素。
key 不存在时返回 nil
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> rpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> rpop lkey
"c"
|
rpoplpush source destination
用于原子地从列表 source 中移除并返回最后一个元素，
然后把这个元素插入为列表destination 的第一个元素。
如果列表 source 不存在，返回 nil ，什么也不执行。
如果列表 source 和destination 相同，相当于从列表的一端删除元素，
在放入列表的另一端，所以可以当做一个列表循环命令。
返回值：移除并又插入的元素。
从 Redis 6.2.0 起， RPOPLPUSH 被废弃，使用 LMOVE 替代
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 127.0.0.1:6379> rpush lkey a b c
(integer) 3
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> rpoplpush lkey lkey1
"c"
127.0.0.1:6379> rpoplpush lkey lkey1
"b"
127.0.0.1:6379> lrange lkey 0 -1
1) "a"
127.0.0.1:6379> lrange lkey1 0 -1
1) "b"
2) "c"
|
blpop key1 [key2] timeout
移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。它是LPOP的阻塞版本。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表（参数从左到右顺序），弹出第一个非空列表的头元素。
timeout 参数表示的是一个指定阻塞的最大秒数的整型值（>= 6.0 可使用 double 类型），超时后会解除阻塞状态并且返回 nil 。当 timeout 为 0 是表示永久阻塞。
返回值：
- 所有列表为空并且超时时，返回
nil 。 - 一个两个成员的数组，第一个元素是被移除元素的 key 的名字，第二个元素是被移除元素的值。
brpop key1 [key2] timeout
从给的列表参数中按顺序检查第一个不空的列表，然后从该列表的尾部移除元素。
BRPOP 是 RPOP 的阻塞版本，因为当没有元素从给定的列表中移除的时候，BRPOP 阻塞连接。
BRPOP 和 BLPOP 的功能相同，除了他们一个是从列表头部（左边），另一个是从列表尾部（右边）移除元素。
brpoplpush source destination timeout
从列表中取出最后一个元素，并插入到另外一个列表的头部。
如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
BRPOPLPUSH 是 RPOPLPUSH的阻塞版本，当给定列表 source 不为空时，
BRPOPLPUSH的表现和RPOPLPUSH 一样。
超时参数 timeout 接受一个以秒为单位的整数字作为值（>= 6.0 可使用 double 类型），超时返回空。
超时参数设为 0 表示阻塞时间可以无限期延长（block indefinitely） 。
从 Redis 6.2.0 起，建议使用BLMOVE替代BRPOPLPUSH 。
Redis 集合（Set）
Redis 的 Set 是 String 类型的无序集合。
添加、删除、查找的时间复杂都是 O(1)。
与 hash 存储结构相同，但是只存储 fileds 值（键值对中的键） 。
所以集合成员是唯一的，不允许数据重复。
每个集合可存储超过 40 亿个元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| # 将一个或多个成员元素加入到集合中
sadd key member1 [member2]
# 获取集合中全部成员
smembers key
# 判断 member 是否为 集合 key 中的成员
sismember key member
# 获取集合的成员数
scard key
# 随机取集合中一个或多个成员移除并返回
spop key [count]
# 随机取 count 个成员，不删除
srandmember key [count]
# 移除集合中一个或多个成员
srem key member1 [member2]
# 将成员 member 从 source 集合移动到 destination 集合
smove source destination member
# 返回第一个集合独自拥有的成员
sdiff key1 [key2]
# 返回第一个集合独自拥有的成员，并存入 destination
sdiffstore destination key1 [key2]
# 返回所有给定集合的成员交集
sinter key1 [key2]
# 返回所有给定集合的成员交集，并存入 destination
sinterstore destination key1 [key2]
# 返回给定集合并集
sunion key1 [key2]
# 返回给定集合并集，并存入 destination
sunionstore destination key1 [key2]
# 迭代集合中键的元素
sscan key cursor [MATCH pattern] [COUNT count]
|
技巧
Redis 版本 >= 6.2.0. 提供 SMISMEMBER 指令
sadd key member1 [member2]
将一个或多个（多值 >= 2.4 版本）成员元素加入到集合中，
已经存在于集合的成员元素将被忽略。
返回值：成功添加到集合中，元素的个数。
1
2
3
4
| 127.0.0.1:6379> sadd skey a b c
(integer) 3
127.0.0.1:6379> sadd skey a b d
(integer) 1
|
smembers key
获取集合中全部成员
1
2
3
4
5
6
| 127.0.0.1:6379> sadd skey a b c
(integer) 3
127.0.0.1:6379> smembers skey
1) "b"
2) "c"
3) "a"
|
sismember key member
判断成员 member 是否为集合 key 中的成员
返回值：成员存在返回 1，成员不存在或者 key 不存在返回 0。
1
2
3
4
5
6
| 127.0.0.1:6379> sadd skey a b c
(integer) 3
127.0.0.1:6379> sismember skey a
(integer) 1
127.0.0.1:6379> sismember skey d
(integer) 0
|
scard key
返回集合中元素的数量
返回值：集合中的成员数量，集合 key 不存在时返回 0
1
2
3
4
| 127.0.0.1:6379> sadd skey a b c
(integer) 3
127.0.0.1:6379> scard skey
(integer) 3
|
spop key [count]
随机取集合中一个或多个（多值 >= 3.2 版本）成员移除并返回
返回值：被删除成员，当 key 不存在时返回 nil
1
2
3
4
5
6
7
8
9
10
11
12
| 127.0.0.1:6379> sadd skey a b c d e
(integer) 5
127.0.0.1:6379> spop skey
"b"
127.0.0.1:6379> spop skey 2
1) "e"
2) "a"
127.0.0.1:6379> smembers skey
1) "c"
2) "d"
127.0.0.1:6379> spop skey1
(nil)
|
srandmember key [count]
随机取集合中一个或多个（多值 >= 2.6 版本）成员，不会删除集合中数据
如果 count 是正数
- 不会返回重复元素
- 且 count 小于等于成员的个数，则返回含有 count 个不同的成员的数组
- 且 count 大于集合中元素的个数时，则返回整个集合的所有成员
当 count 是负数
- 可能会返回一个或者多个重复元素
- 且 count 绝对值小于等于成员个数，则返回包含 count 绝对值个数成员的数组
- 且 count 绝对值大于成员个数，则返回结果集会出现一个元素多次重复的情况（返回集合中不一定包含全部的成员）
返回值：
- 不使用
count 参数查询，key 不存在时返回 nil - 使用
count 参数查询，key 不存在时返回空数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| 127.0.0.1:6379> sadd skey a b c
(integer) 3
127.0.0.1:6379> srandmember skey
"b"
127.0.0.1:6379> srandmember skey1
(nil)
127.0.0.1:6379> srandmember skey 2
1) "b"
2) "c"
127.0.0.1:6379> srandmember skey1 2
(empty array)
127.0.0.1:6379> srandmember skey -2
1) "a"
2) "b"
127.0.0.1:6379> srandmember skey -2
1) "a"
2) "a"
127.0.0.1:6379> srandmember skey 4
1) "b"
2) "c"
3) "a"
127.0.0.1:6379> srandmember skey -4
1) "b"
2) "c"
3) "a"
4) "b"
127.0.0.1:6379> srandmember skey -4
1) "c"
2) "a"
3) "a"
4) "a"
|
srem key member1 [member2]
移除集合中的一个或多个（多值 >= 2.4 版本）成员，不存在的成员会被忽略。
返回值：成功删除的成员个数，key 不存在时返回 0
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> sadd skey a b c d
(integer) 4
127.0.0.1:6379> srem skey b
(integer) 1
127.0.0.1:6379> srem skey b c d
(integer) 2
127.0.0.1:6379> smembers skey
1) "a"
|
smove source destination member
将指定成员 member 从 source 集合移动到 destination 集合。
原子性操作，在任何情况移动的 member 只会存在于 source 和 destination 其中的一个。
如果 member 在集合 destination 存在，则只是从集合source中删除该成员。
如果 source 或 destination 不是集合类型则返回错误。
返回值：成功返回 1，成员 member 不在集合 source 中返回 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 127.0.0.1:6379> sadd skey1 a b c
(integer) 3
127.0.0.1:6379> sadd skey2 b
(integer) 1
127.0.0.1:6379> smove skey1 skey2 a
(integer) 1
127.0.0.1:6379> smove skey1 skey2 a
(integer) 0
127.0.0.1:6379> smove skey1 skey2 b
(integer) 1
127.0.0.1:6379> smembers skey1
1) "c"
127.0.0.1:6379> smembers skey2
1) "b"
2) "a"
|
sdiff key1 [key2]
返回第一个集合与其他集合之间的差异，
可以说是返回第一个集合独自拥有的成员，非所有集合差集。
1
2
3
4
5
6
7
8
9
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
(integer) 3
127.0.0.1:6379> sdiff skey1 skey2 skey3
1) "b"
2) "d"
|
sdiffstore destination key1 [key2]
返回第一个集合独自拥有的成员，并存入 destination。
如果 destination 已存在则被覆盖（里面原有值清空）
返回值：结果集中成员数量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
(integer) 3
127.0.0.1:6379> sdiff skey1 skey2 skey3
1) "b"
2) "d"
127.0.0.1:6379> sadd skey4 a b c
(integer) 3
127.0.0.1:6379> sdiffstore skey4 skey1 skey2 skey3
(integer) 2
127.0.0.1:6379> smembers skey4
1) "b"
2) "d"
|
sinter key1 [key2]
返回所有给定集合的成员交集
如果给定 key 中有一个为空集合，那么结果集一定是空集合。
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
(integer) 3
127.0.0.1:6379> sinter skey1 skey2 skey3
1) "c"
|
sinterstore destination key1 [key2]
返回所有给定集合的成员交集，并存入 destination。
如果 destination 已存在则被覆盖（里面原有值清空）
返回值：结果集中成员数量
1
2
3
4
5
6
7
8
9
10
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
(integer) 3
127.0.0.1:6379> sinterstore skey4 skey1 skey2 skey3
(integer) 1
127.0.0.1:6379> smembers skey4
1) "c"
|
sunion key1 [key2]
返回给定集合并集
1
2
3
4
5
6
7
8
9
10
11
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
127.0.0.1:6379> sunion skey1 skey2 skey3
1) "c"
2) "a"
3) "d"
4) "b"
5) "e"
|
sunionstore destination key1 [key2]
返回给定集合并集，并存入 destination。
如果 destination 已存在则被覆盖（里面原有值清空）
返回值：结果集中成员数量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 127.0.0.1:6379> sadd skey1 a b c d
(integer) 4
127.0.0.1:6379> sadd skey2 c
(integer) 1
127.0.0.1:6379> sadd skey3 a c e
(integer) 3
127.0.0.1:6379> sunionstore skey4 skey1 skey2 skey3
(integer) 5
127.0.0.1:6379> smembers skey4
1) "c"
2) "a"
3) "d"
4) "b"
5) "e"
|
sscan key cursor [MATCH pattern] [COUNT count]
用于遍历集合中键的成员，继承自SCAN
Redis 有序集合（Sorted Set）
有序集合和集合一样也是 String 类型元素的集合，且不允许重复的成员。
不同的是每个元素都会关联一个 double 类型的分数。
Redis 正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的，但分数 score 却可以重复。
添加、删除、查找的时间复杂都是 O(1)。
每个有序集合可存储超过 40 亿个成员。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
| # 向有序集合添加一个或多个成员，或者更新已存在成员的分数
zadd key [NX|XX] [CH] [INCR] score1 member1 [score2 member2]
# 通过索引区间返回有序集合指定区间内的成员
zrange key start stop [WITHSCORES]
# 返回有序集中指定区间内的成员，通过索引，分数从高到低
zrevrange key start stop [WITHSCORES]
# 获取有序集合的成员个数
zcard key
# 计算在有序集合中指定区间分数的成员数（默认闭区间）
zcount key min max
# 有序集合中对指定成员的分数加上增量 increment
zincrby key increment member
# 返回有序集中，成员的分数值
zscore key member
# 返回有序集合中指定成员的索引
zrank key member
# 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
zrevrank key member
# 移除有序集合中的一个或多个成员
zrem key member1 [member2]
# 移除有序集合中给定的排名区间的所有成员
zremrangebyrank key start stop
# 移除有序集合中给定的分数区间的所有成员
zremrangebyscore key min max
# 通过分数返回有序集合指定区间内的成员
zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
# 返回有序集中指定分数区间内的成员，分数从高到低排序
zrevrangebyscore key max min [WITHSCORES]
# 在有序集合中计算指定字典区间内成员数量
zlexcount key min max
# 通过字典区间返回有序集合的成员
zrangebylex key min max [LIMIT offset count]
# 通过字典区间返回有序集合的成员，倒序
zrevrangebylex key max min [LIMIT offset count]
# 移除有序集合中给定的字典区间的所有成员
zremrangebylex key min max
# 计算给定的一个或多个有序集的并集，并存储在新的 destination 中
zunionstore destination numkeys key1 [key2]
# 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中
zinterstore destination numkeys key1 [key2]
# 迭代有序集合中的元素（包括元素成员和元素分值）
zscan key cursor [MATCH pattern] [COUNT count]
|
技巧
Redis 版本>= 5.0 提供 BZPOPMIN、ZPOPMAX、ZPOPMIN 指令
Redis 版本>= 6.0 提供 BZPOPMAX 指令
Redis 版本>= 6.2.0. 提供 ZINTER、ZUNION、ZMSCORE 指令
zadd key [NX|XX] [CH] [INCR] score1 member1 [score2 member2]
用于将一个或多个（多值 >= 2.4 版本）分数 score、成员 member 对加入到有序集合 key 当中。
当 member 已存在时，只更新该成员的 score 值，并重新插入该成员以保证在正确的排行。
score 值可以是整数值或双精度浮点数，也可以为负数。
-2^53 到 +2^53 或者说是 -9007199254740992 到 9007199254740992。
当 key 不是有序集合类型时，返回错误。
返回值：未指定特殊参数时，返回添加成功成员的数量（不包括更新操作的成员数）。
Redis 版本 >= Redis 3.0.2 时， ZADD 支持以下参数
- XX ： 只更新存在的成员，不添加新成员。
- NX ：不更新存在的成员，只添加新成员。
- INCR ： 指定参数指令操作等同
ZINCRBY 命令，对成员的分数进行递增操作，在此模式下只能指定一对分数/成员。（成功则返回更新后的分数失败返回 nil） - CH：指定该参数后返回新添加的成员 + 发生更新的成员。(注意：成员分数都相同，则不会发生更新)
技巧
Redis 版本 >= 3.0.2 提供 [NX|XX] [CH] [INCR] 选项
Redis 版本 >= 6.2 提供 [GT|LT] 选项
- LT: 更新新的分值比当前分值小的成员，不存在则新增。
- GT: 更新新的分值比当前分值大的成员，不存在则新增。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zadd zkey 0 a 11 b 2 c
(integer) 0
127.0.0.1:6379> zadd zkey 0 a 11 b 2 d
(integer) 1
127.0.0.1:6379> zrange zkey 0 -1 withscores
1) "a"
2) "0"
3) "c"
4) "2"
5) "d"
6) "2"
7) "b"
8) "11"
|
zrange key start stop [WITHSCORES]
返回有序集合中指定区间内的成员（闭区间）。
成员的位置按分数值递增（从小到大）排序。
相同分数值的成员按字典序（lexicographical order）来排列。
下标参数都是从 0 开始，也可为负数，
如 -1 表示最后一个成员，-2 表示倒数第二个成员。
超出范围的索引不会产生错误，
start 大于有序集合最大索引，或者 start > stop返回空列表。
stop 大于有序集合最大索引，则默认视为最后一个成员位置。
WITHSCORES ：带上该参数则会连同分数返回，不带则只返回成员。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zrange zkey 0 -1
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrange zkey 0 -1 withscores
1) "a"
2) "0"
3) "b"
4) "1"
5) "c"
6) "2"
|
zrevrange key start stop [WITHSCORES]
返回有序集合中指定区间内的成员（闭区间）。
成员的位置按分数值递减（从大到小）排序。
相同分数值的成员按字典序（lexicographical order）来排列。
除成员排序相反外，与指令 ZRANGE 无异。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zrevrange zkey 0 -1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> zrevrange zkey 0 -1 withscores
1) "c"
2) "2"
3) "b"
4) "1"
5) "a"
6) "0"
|
zcard key
获取有序集合的成员个数
返回值：有序集合成员个数，当 key 不存在时，返回 0。
1
2
3
4
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zcard zkey
(integer) 3
|
zcount key min max
计算在有序集合中指定区间分数的成员数（默认闭区间）
参数 min 和 max 可以是 -inf 和 +inf（最低分与最高分）
默认闭区间，可给参数前添加符号 ( 来设置开区间
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zcount zkey 1 2 # 等同于 1 <= score <= 2
(integer) 2
127.0.0.1:6379> zcount zkey (1 2 # 等同于 1 < score <= 2
(integer) 1
127.0.0.1:6379> zcount zkey -inf +inf # 等同于 最小分数 <= score <= 最大分数
(integer) 3
|
zincrby key increment member
为有序集合 key 的成员 member 的分数 score 加上增量 increment（双精度浮点数）。
当 key 或者 member 不存在时，会自动创建对应值。
当 key 不是有序集合类型时，会丢出一个错误。
返回值：计算后的成员分数值
1
2
3
4
| 127.0.0.1:6379> zincrby zkey -1.5 a
"-1.5"
127.0.0.1:6379> zincrby zkey 6.5 a
"5"
|
zscore key member
返回有序集合中指定成员的分数
当成员或者 key 不存在时，返回 nil
1
2
3
4
5
6
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zscore zkey b
"1"
127.0.0.1:6379> zscore zkey d
(nil)
|
zrank key member
返回有序集key中成员member的排名（分数从小到大排序）
排名从 0 开始
返回值：能查询到该成员则返回成员排名（整数）。否则返回 nil
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> zadd zkey 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zrank zkey a
(integer) 0
127.0.0.1:6379> zrank zkey c
(integer) 2
127.0.0.1:6379> zrank zkey d
(nil)
|
zrevrank key member
返回有序集key中成员member的排名（分数从大到小排序）
排名从 0 开始
返回值：能查询到该成员则返回成员排名（整数）。否则返回 nil
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> zadd zkey 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zrevrank zkey a
(integer) 2
127.0.0.1:6379> zrevrank zkey c
(integer) 0
127.0.0.1:6379> zrevrank zkey d
(nil)
|
zrem key member1 [member2]
删除有序集合中的一个或多个（多值 >= 2.4 版本）成员，不存在的成员将被忽略。
key 存在单类型不对，则丢出一个错误。
返回值：成功删除的成员个数。
1
2
3
4
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zrem zkey a b d
(integer) 2
|
zremrangebyrank key start stop
删除有序集合中指定排名（rank）区间的所有成员（闭区间，0 开始）。
索引可为负数，如 -1 表示最高分 -2 表示倒数第二高分。
返回值：成功删除的成员个数。
1
2
3
4
5
6
7
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c
(integer) 3
127.0.0.1:6379> zremrangebyrank zkey 1 -1
(integer) 2
127.0.0.1:6379> zrange zkey 0 -1 withscores
1) "a"
2) "0"
|
zremrangebyscore key min max
删除有序集合中指定分数（score）内的所有成员（默认闭区间）。
参数 min 和 max 可以是 -inf 和 +inf（最低分与最高分）
默认闭区间，可给参数前添加符号 ( 来设置开区间
返回值：成功删除的成员个数。
1
2
3
4
5
6
7
8
9
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c 3 d
(integer) 4
127.0.0.1:6379> zremrangebyscore zkey 0 (1 # 等同于删除 0<= score <1
(integer) 1
127.0.0.1:6379> zremrangebyscore zkey (1 +inf # 等同于删除 1= score <= 最大分数位置
(integer) 2
127.0.0.1:6379> zrange zkey 0 -1 withscores
1) "b"
2) "1"
|
zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
返回有序集合中指定分数区间内所有成员（默认闭区间）。
有序集合按照递增排序（从小到大）。
相同分数值的成员按字典序（lexicographical order）来排列。
参数 min 和 max 可以是 -inf 和 +inf（最低分与最高分）。
默认闭区间，可给参数前添加符号 ( 来设置开区间。
WITHSCORES ：带上该参数则会连同分数返回，不带则只返回成员。
LIMIT offset count：类似 SQL 中 SELECT LIMIT offset, count，但是 offset, count参数都必须带上。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c 3 d 4 e 5 f
(integer) 6
127.0.0.1:6379> zrangebyscore zkey 1 +inf
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"
127.0.0.1:6379> zrangebyscore zkey 1 +inf withscores
1) "b"
2) "1"
3) "c"
4) "2"
5) "d"
6) "3"
7) "e"
8) "4"
9) "f"
10) "5"
127.0.0.1:6379> zrangebyscore zkey 1 +inf withscores limit 0 2
1) "b"
2) "1"
3) "c"
4) "2"
127.0.0.1:6379> zrangebyscore zkey 1 +inf withscores limit 2 2
1) "d"
2) "3"
3) "e"
4) "4"
127.0.0.1:6379> zrangebyscore zkey -inf 2 withscores
1) "a"
2) "0"
3) "b"
4) "1"
5) "c"
6) "2"
|
zrevrangebyscore key max min [WITHSCORES]
返回有序集合中指定分数区间内所有成员（默认闭区间）。
有序集合按照递减排序（从大到小）。
相同分数值的成员按字典序（lexicographical order）来排列。
参数 min 和 max 可以是 -inf 和 +inf（最低分与最高分）。
默认闭区间，可给参数前添加符号 ( 来设置开区间。
WITHSCORES ：带上该参数则会连同分数返回，不带则只返回成员。
LIMIT offset count：类似 SQL 中 SELECT LIMIT offset, count，但是 offset, count参数都必须带上。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 127.0.0.1:6379> zadd zkey 0 a 1 b 2 c 3 d 4 e 5 f
(integer) 6
127.0.0.1:6379> zrevrangebyscore zkey (5 -inf withscores
1) "e"
2) "4"
3) "d"
4) "3"
5) "c"
6) "2"
7) "b"
8) "1"
9) "a"
10) "0"
|
zlexcount key min max
在有序集合中计算指定字典区间内成员数量。
该命令通常用于成员分数都相同的有序集合。
如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。
min：参数必须包含 ( （开区间）或者 [（闭区间）或使用特殊值 - （负无穷）。
max ：参数必须包含 ( （开区间）或者 [（闭区间）或使用特殊值 + （正无穷）。
返回值：该区间内元素的个数。
1
2
3
4
5
6
| 127.0.0.1:6379> zadd zkey 0 a 0 b 0 c 0 d 0 e 0 f
(integer) 6
127.0.0.1:6379> zlexcount zkey - +
(integer) 6
127.0.0.1:6379> zlexcount zkey (a [d
(integer) 3
|
zrangebylex key min max [LIMIT offset count]
获取字典区间内有序集合的成员（不包含分数）。
该命令通常用于成员分数都相同的有序集合。
如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。
min：参数必须包含 ( （开区间）或者 [（闭区间）或使用特殊值 - （负无穷）。
max ：参数必须包含 ( （开区间）或者 [（闭区间）或使用特殊值 + （正无穷）。
LIMIT offset count：类似 SQL 中 SELECT LIMIT offset, count，但是 offset, count参数都必须带上。
返回值：该区间内成员。
字符串比较详细信息
在匹配规则中，字符串被比较为字节的二进制阵列，按照 ASCII 字符集的指定方式。
有时候对大小写不敏感，但是任然想进行比较可以尝试添加字符串 :
zadd zkey 0 foo:Foo 0 bar:BAR 0 zap:zap
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| 127.0.0.1:6379> zadd zkey 0 bcd 0 d 0 f 0 h
(integer) 4
127.0.0.1:6379> zrangebylex zkey [b +
1) "bcd"
2) "d"
3) "f"
4) "h"
127.0.0.1:6379> zrangebylex zkey [ba + # 逐级比较 a 位于 c 前所以包含该成员
1) "bcd"
2) "d"
3) "f"
4) "h"
127.0.0.1:6379> zrangebylex zkey [bd + # 逐级比较 d 位于 c 后面所以跳过了该成员
1) "d"
2) "f"
3) "h"
# 匹配指定号段手机号
127.0.0.1:6379> zadd zkeyphone 0 13300000000 0 13311111111 0 13600000000
(integer) 3
127.0.0.1:6379> zrangebylex zkeyphone [133 (134
1) "13300000000"
2) "13311111111"
|
zrevrangebylex key max min [LIMIT offset count]
获取字典区间内有序集合的成员（不包含分数）。
除排序顺序相反，与zrangebylex 无异。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 127.0.0.1:6379> zadd zkey 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
127.0.0.1:6379> zrevrangebylex zkey [d -
1) "d"
2) "c"
3) "b"
4) "a"
127.0.0.1:6379> zrevrangebylex zkey [d [aa
1) "d"
2) "c"
3) "b"
127.0.0.1:6379> zrevrangebylex zkey [dd [aa
1) "d"
2) "c"
3) "b"
|
zremrangebylex key min max
删除指定字典内有序集合成员。
命令中 min 和 max 的含义与 zrangebylex 命令相同。
返回值：成功删除成员个数。
1
2
3
4
5
6
7
8
9
10
11
| 127.0.0.1:6379> zadd zkey 0 A 0 B 0 a 0 b 0 c 0 e 0 f 0 z
(integer) 8
127.0.0.1:6379> zremrangebylex zkey [b [d
(integer) 2
127.0.0.1:6379> zrange zkey 0 -1
1) "A"
2) "B"
3) "a"
4) "e"
5) "f"
6) "z"
|
zunionstore destination numkeys key1 [key2]
计算给定的一个或多个有序集合的并集，
其中给定 key 的数量必须以 numkeys 参数指定（有几个 key 数字就写几），
并将该并集储存到 destination，如果destination存在，会被覆盖（原值删除）。
默认情况下，结果集中某个成员的 score 值是所有给定集中该成员 score 值之和。
完整指令如下：
ZUNIONSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]
WEIGHTS：每个有序集合所有成员分数，在计算前先乘以该因子。
AGGREGATE：默认 SUM，可选择取集合中成员最小或者最大分数值。
返回值： 结果集 destination 中成员的数量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| 127.0.0.1:6379> zadd zkey1 1 a 2 b
(integer) 2
127.0.0.1:6379> zadd zkey2 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zunionstore out 2 zkey1 zkey2 weights 2 3
(integer) 3
127.0.0.1:6379> zrange out 0 -1 withscores
1) "a"
2) "5"
3) "c"
4) "9"
5) "b"
6) "10"
127.0.0.1:6379> zunionstore out 2 zkey1 zkey2 weights 2 1 aggregate max
(integer) 3
127.0.0.1:6379> zrange out 0 -1 withscores
1) "a"
2) "2"
3) "c"
4) "3"
5) "b"
6) "4"
|
zinterstore destination numkeys key1 [key2]
计算给定的一个或多个有序集合的交集，
其中给定 key 的数量必须以 numkeys 参数指定（有几个 key 数字就写几），
并将该并集储存到 destination，如果destination存在，会被覆盖（原值删除）。
默认情况下，结果集中某个成员的 score 值是所有给定集中该成员 score 值之和。
完整指令如下：
ZINTERSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]
WEIGHTS：每个有序集合所有成员分数，在计算前先乘以该因子。
AGGREGATE：默认 SUM，可选择取集合中成员最小或者最大分数值。
返回值： 结果集 destination 中成员的数量。
1
2
3
4
5
6
7
8
9
10
11
| 127.0.0.1:6379> zadd zkey1 1 a 2 b
(integer) 2
127.0.0.1:6379> zadd zkey2 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> zinterstore out 2 zkey1 zkey2 weights 2 3
(integer) 2
127.0.0.1:6379> zrange out 0 -1 withscores
1) "a"
2) "5"
3) "b"
4) "10"
|
zscan key cursor [MATCH pattern] [COUNT count]
迭代有序集合中的元素（包括元素成员和元素分值），继承自SCAN
- cursor - 游标。
- pattern - 匹配的模式。
- count - 指定从数据集里返回多少元素，默认值为 10 。
Redis 键 （key）
Redis 键命令用户管理 Redis 的键。
Key 指令详细介绍：https://redis.io/commands#generic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| # 当 key 存在时删除 key
del key1 [key2]
# 当 key 存在时删除 key（异步删除）
unlink key1 [key2]
# 检查给定 key 是否存在
exists key1 [key2]
# 给 key 设置一个过期时间，单位秒
expire key seconds
# 设置 key 的指定过期时间，秒时间戳参数（10 位时间戳）
expireat key timestamp
# 给 key 设置一个过期时间，单位毫秒
pexpire key milliseconds
# 设置 key 的指定过期时间，毫秒时间戳参数（13 位时间戳）
pexpireat key milliseconds-timestamp
# 查找符合给定条件的 key
# 可使用占位符 ? * [a-z] [^a-d] 等
keys pattern
# 将当前 key 移动到指定数据库中
move key db
# 移除 key 的过期时间，key 将不会过期删除。
persist key
# 查询当前 key 的剩余生存时间，单位秒
ttl key
# 查询当前 key 的剩余生存时间，单位毫秒
pttl key
# 从当前数据库随机返回一个 key
randomkey
# 修改 key 名称，当 newkey 存在时直接被覆盖。
rename key newkey
# 修改 key 名称，仅当 newkey 不存在时才会成功。
renamenx key newkey
# 返回当前 key 的数据类型
type key
# 序列化 key（取出redis值，以字符串形式保存）
dump key
# 反序列化，并绑定 key。（值由 dump 生成）
restore key ttl serialized-value
# 迭代数据库中键
scan cursor [MATCH pattern] [COUNT count]
|
Redis 发布订阅 （pub/sub）
Redis 提供了发布订阅功能，可以用于消息的传输，
Redis 的发布订阅机制包括三个部分：发布者、订阅者、Channel。
发布者和订阅者都是 Redis 客户端，Channel 则为 Redis 服务器端。
发布者将消息发送到某个的频道，订阅了这个频道的订阅者就能接收到这条消息。
订阅某个频道
订阅后在客户端是阻塞状态，
指定频道订阅：
1
| subscribe channel1 [channel2 ...]
|
例子：
1
2
3
4
5
6
7
8
| 127.0.0.1:6379> subscribe channel1 channel2
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1
1) "subscribe"
2) "channel2"
3) (integer) 2
|
根据特定模式订阅频道：
1
| psubscribe pattern [pattern2 ...]
|
例子：
1
2
3
4
5
6
7
8
9
10
11
| 127.0.0.1:6379> psubscribe zz.a* zz.b? zz.c[a-d]
Reading messages... (press Ctrl-C to quit)
1) "psubscribe"
2) "zz.a*"
3) (integer) 1
1) "psubscribe"
2) "zz.b?"
3) (integer) 2
1) "psubscribe"
2) "zz.c[a-d]"
3) (integer) 3
|
向某个频道发送消息
1
| publish channel message
|
返回结果：成功收到消息的频道数。
1
2
3
4
| 127.0.0.1:6379> publish zz.bb "test1"
(integer) 1
127.0.0.1:6379> publish channel1 "test2"
(integer) 1
|
退订频道
退订指定频道
1
| unsubscribe [channel1 [channel2 ...]]
|
退订指定模式频道
1
| punsubscribe [pattern1 [pattern2 ...]]
|
频道数据统计
1
| pubsub <subcommand> [argument [argument ...]]
|
常用指令：
1
2
3
4
5
6
7
8
| # 查看被订阅的频道 可用通配符
pubsub channels [pattern1 [pattern2 ...]]
# 查看指定频道订阅人数
pubsub numsub [channel-1 ... channel-N]
# 查看所有客户订阅的模式总数
pubsub numpat
|
参考地址