145.《redis原生超详细使用》

文章目录

什么是redis
redis 安装启动
redis数据类型
redis key操作
- key 的增
- key 的查
- key 的改
- key 的删
- key 是否存在
- key 查看所有
- key 「设置」过期时间
- key 「查看」过期时间
- key 「移除」过期时间
- key 「查看」数据类型
- key 「匹配」符合条件的key
- key 「移动」到其他数据库
redis数据类型操作
- string(字符串)
- - 设置字符串
  - 获取字符串
  - 字符串截取
  - 设置所有(一个或多个)给定 key 的值
  - 获取一个或多个 key-value 对
  - key 不存在时设置 key 的值
  - 返回字符串值的长度
  - key 中储存的数字值增一
  - key 的值加上给定的增量值
  - key 中储存的数字值减一
  - key 所储存的值减去给定的减量值
  - key 后追加新的字符串
- list（列表）
- - 设置列表
  - 移出并获取列表的第一个元素
  - 移出并获取列表的最后一个元素
  - 通过索引获取列表中的元素
  - 在列表的元素前或者后插入元素
  - 获取列表长度
  - 移出并获取列表的第一个元素
  - 将一个值插入到已存在的列表头部
  - 将一个或多个值插入到列表头部
  - 获取列表指定范围内的元素
  - 获取全部元素
  - 移除列表元素
  - 通过索引设置列表元素的值
  - 查找指定区间内的元素
  - 移除列表的最后一个元素，并返回
  - 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
  - 在列表中添加一个或多个值到列表尾部
  - 为已存在的列表添加值
- hash（哈希）
- - 删除一个或多个哈希表字段
  - 查看哈希表 key 中，指定的字段是否存在
  - 获取存储在哈希表中指定字段的值
  - 获取在哈希表中指定 key 的所有字段和值
  - 为哈希表 key 中的指定字段的整数值加上增量 increment
  - 为哈希表 key 中的指定字段的浮点数值加上增量 increment
  - 获取哈希表中的所有字段
  - 获取哈希表中字段的数量
  - 获取所有给定字段的值
  - 同时将多个 field-value (域-值)对设置到哈希表 key 中
  - 将哈希表 key 中的字段 field 的值设为 value
  - 只有在字段 field 不存在时，设置哈希表字段的值
  - 获取哈希表中所有值
  - 迭代哈希表中的键值对
- set（集合）
- - 向集合添加一个或多个成员
  - 获取集合的成员数
  - 返回第一个集合与其他集合之间的差异
  - 返回给定所有集合的差集并存储在 destination 中
  - 返回给定所有集合的交集
  - 返回给定所有集合的交集并存储在 destination 中
  - 判断 member 元素是否是集合 key 的成员
  - 返回集合中的所有成员
  - 将 member 元素从 source 集合移动到 destination 集合
  - 移除并返回集合中的一个随机元素
  - 返回集合中一个或多个随机数
  - 移除集合中一个或多个成员
  - 返回所有给定集合的并集
  - 所有给定集合的并集存储在 destination 集合中
  - 迭代集合中的元素
- zset(sorted set）
- - 向有序集合添加一个或多个成员，或者更新已存在成员的分数
  - 获取有序集合的成员数
  - 计算在有序集合中指定区间分数的成员数
  - 有序集合中对指定成员的分数加上增量 increment
  - 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中
  - 在有序集合中计算指定字典区间内成员数量
  - 通过索引区间返回有序集合指定区间内的成员
  - 通过字典区间返回有序集合的成员
  - 通过分数返回有序集合指定区间内的成员
  - 返回有序集合中指定成员的索引
  - 移除有序集合中的一个或多个成员
  - 移除有序集合中给定的字典区间的所有成员
  - 移除有序集合中给定的排名区间的所有成员
  - 移除有序集合中给定的分数区间的所有成员
  - 返回有序集中指定区间内的成员，通过索引，分数从高到低
  - 返回有序集中指定分数区间内的成员，分数从高到低排序
  - 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
  - 返回有序集中，成员的分数值
  - 计算给定的一个或多个有序集的并集，并存储在新的 key 中
  - 迭代有序集合中的元素（包括元素成员和元素分值）

什么是redis

REmote DIctionary Server(Redis) 是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。

Redis 是一个开源的使用 ANSI C 语言编写、遵守 BSD 协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的 API。

Redis 通常被称为数据结构服务器，因为值（value）可以是字符串(String)、哈希(Hash)、列表(list)、集合(sets)和有序集合(sorted sets)等类型。

redis 安装启动

在 macOS 上安装 Redis并启动
在 window 上安装 Redis并启动

redis数据类型

Redis 主要支持以下几种数据类型：
常用

string（字符串）：基本的数据存储单元，可以存储字符串、整数或者浮点数。
hash（哈希）:一个键值对集合，可以存储多个字段。
list（列表）:一个简单的列表，可以存储一系列的字符串元素。
set（集合）:一个无序集合，可以存储不重复的字符串元素。
zset(sorted set）：有序集合): 类似于集合，但是每个元素都有一个分数（score）与之关联。

不常用

位图（Bitmaps）：基于字符串类型，可以对每个位进行操作。
超日志（HyperLogLogs）：用于基数统计，可以估算集合中的唯一元素数量。
地理空间（Geospatial）：用于存储地理位置信息。
发布/订阅（Pub/Sub）：一种消息通信模式，允许客户端订阅消息通道，并接收发布到该通道的消息。
流（Streams）：用于消息队列和日志存储，支持消息的持久化和时间排序。
模块（Modules）：Redis 支持动态加载模块，可以扩展 Redis 的功能。

redis key操作

Redis 键命令用于管理 redis 的键。

开始之前，先选择操作的数据库，redis的数据库默认16个，操作之前先选择数据库

# 选择了索引为0的数据库
select 0

下面的所有的操作都在索引为0的数据库里操作

key 的增

127.0.0.1:6379> set name lisi
OK

key 的查

127.0.0.1:6379> get name
"lisi"

key 的改

127.0.0.1:6379> rename name newName
OK
127.0.0.1:6379> get newName
"lisi"

key 的删

127.0.0.1:6379> del newName
(integer) 1
127.0.0.1:6379> get newName
(nil)

key 是否存在

不存在

127.0.0.1:6379> exists newName
(integer) 0

存在

127.0.0.1:6379> exists name
(integer) 1

key 查看所有

127.0.0.1:6379> keys *
1) "runoob3"
2) "runoob1"
3) "name"
4) "runoob2"

key 「设置」过期时间

以秒计

127.0.0.1:6379> expire name 60
(integer) 1

以 UNIX 时间戳

127.0.0.1:6379> expireat runoobkey 1293840000
(integer) 1

以毫秒计

127.0.0.1:6379> pexpire name 1500
(integer) 1

key 「查看」过期时间

pttl
以毫秒为单位返回 key 的剩余的过期时间

127.0.0.1:6379> expire name 60
(integer) 1
127.0.0.1:6379> pttl name 
(integer) 53144

ttl
以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。

127.0.0.1:6379> EXPIRE name 60
(integer) 1
127.0.0.1:6379> ttl name
(integer) 33

key 「移除」过期时间

移除 key 的过期时间，key 将持久保持

127.0.0.1:6379> expire name 60
(integer) 1
127.0.0.1:6379> get name
"lisi"
127.0.0.1:6379> PERSIST name
(integer) 1

key 「查看」数据类型

127.0.0.1:6379> type name
string

key 「匹配」符合条件的key

127.0.0.1:6379> keys runoob*
1) "runoob3"
2) "runoob1"
3) "runoob2"

key 「移动」到其他数据库

127.0.0.1:6379> move name 2
(integer) 1

redis数据类型操作

string(字符串)

设置字符串

命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。

SET key value

127.0.0.1:6379> set name lisi
OK

获取字符串

命令用于获取指定 key 的值。如果 key 不存在，返回 nil 。如果key 储存的值不是字符串类型，返回一个错误。

GET key

127.0.0.1:6379> get name
"lisi"

字符串截取

命令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)

GETRANGE key start end

127.0.0.1:6379> get name
"zhangsan nihao"
127.0.0.1:6379> getrange name 1 3
"han"

设置所有(一个或多个)给定 key 的值

命令返回所有(一个或多个)给定 key 的值。如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。

 MGET KEY1 KEY2 .. KEYN

127.0.0.1:6379> mset name 'zhangsan' age 15
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"

获取一个或多个 key-value 对

命令返回所有(一个或多个)给定 key 的值。如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。

MGET KEY1 KEY2 .. KEYN

127.0.0.1:6379> mget name age 
1) "zhangsan"
2) "15"

key 不存在时设置 key 的值

命令在指定的 key 不存在时，为 key 设置指定的值

SETNX KEY_NAME VALUE

127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> setnx sex 'man'
(integer) 1
127.0.0.1:6379> keys *
1) "name"
2) "sex"
3) "age"

返回字符串值的长度

命令用于获取指定 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。

STRLEN key

127.0.0.1:6379> strlen age 
(integer) 2
127.0.0.1:6379> strlen name
(integer) 8

key 中储存的数字值增一

Incr 命令将 key 中储存的数字值增一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

INCR KEY_NAME

127.0.0.1:6379> get age
"16"
127.0.0.1:6379> incr age
(integer) 17

key 的值加上给定的增量值

命令将 key 中储存的数字加上指定的增量值。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

INCRBY KEY_NAME INCR_AMOUNT

127.0.0.1:6379> get age
"17"
127.0.0.1:6379> incrby age
(integer) 19

key 中储存的数字值减一

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

DECR KEY_NAME

127.0.0.1:6379> get age 
"19"
127.0.0.1:6379> decr age
(integer) 18

key 所储存的值减去给定的减量值

命令将 key 所储存的值减去指定的减量值。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。

DECRBY KEY_NAME DECREMENT_AMOUNT

127.0.0.1:6379> get age
"16"
127.0.0.1:6379> decrby age 2
(integer) 14

key 后追加新的字符串

命令用于为指定的 key 追加值。
如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。

 APPEND KEY_NAME NEW_VALUE

127.0.0.1:6379> get name 
"zhangsan"
127.0.0.1:6379> append name " nihao"
(integer) 14
127.0.0.1:6379> get name
"zhangsan nihao"

list（列表）

设置列表

 lpush abc value1 value2 value3

127.0.0.1:6379> lpush abc 11 22 33 44 55
(integer) 5

移出并获取列表的第一个元素

移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

BLPOP key1 [key2 ] timeout

127.0.0.1:6379> blpop abc 1000
1) "abc"
2) "55"

移出并获取列表的最后一个元素

移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

BRPOP key1 [key2 ] timeout

127.0.0.1:6379> brpop abc 1000
1) "abc"
2) "11"

通过索引获取列表中的元素

LINDEX key index

127.0.0.1:6379> lrange abc 0 -1
1) "44"
2) "33"
3) "22"
127.0.0.1:6379> lindex abc 2
"22"

在列表的元素前或者后插入元素

命令用于在列表的元素前或者后插入元素。当指定元素不存在于列表中时，不执行任何操作。
当列表不存在时，被视为空列表，不执行任何操作。
如果 key 不是列表类型，返回一个错误

LINSERT key BEFORE|AFTER pivot value

前

127.0.0.1:6379> lrange abc 0 -1
1) "55"
2) "44"
3) "33"
4) "22"
5) "11"
127.0.0.1:6379> lpush abc 55 66
(integer) 7
127.0.0.1:6379> lrange abc 0 -1
1) "66"
2) "55"
3) "55"
4) "44"
5) "33"
6) "22"
7) "11"
127.0.0.1:6379>

后

127.0.0.1:6379> lrange abc 0 -1
1) "66"
2) "55"
3) "55"
4) "44"
5) "33"
6) "22"
7) "11"
127.0.0.1:6379> lpush abc after 11 00
(integer) 10
127.0.0.1:6379> lrange abc 0 -11) "00"2) "11"3) "after"4) "66"5) "55"6) "55"7) "44"8) "33"9) "22"
10) "11"

获取列表长度

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

LLEN KEY_NAME

127.0.0.1:6379> llen abc
(integer) 10

移出并获取列表的第一个元素

命令用于移除并返回列表的第一个元素

Lpop KEY_NAME

127.0.0.1:6379> lrange abc 0 -11) "00"2) "11"3) "after"4) "66"5) "55"6) "55"7) "44"8) "33"9) "22"
10) "11"
127.0.0.1:6379> lpop abc
"00"
127.0.0.1:6379> lrange abc 0 -1
1) "11"
2) "after"
3) "66"
4) "55"
5) "55"
6) "44"
7) "33"
8) "22"
9) "11"

将一个值插入到已存在的列表头部

将一个值插入到已存在的列表头部，列表不存在时操作无效

LPUSHX key value

127.0.0.1:6379> lpush abc liuhuan
(integer) 13
127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "2"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

将一个或多个值插入到列表头部

命令将一个或多个值插入到列表头部。如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。

	LPUSH key value1 [value2]

127.0.0.1:6379> lpush abc 1 2 3
(integer) 12
127.0.0.1:6379> lrange abc 0 -11) "3"2) "2"3) "1"4) "11"5) "after"6) "66"7) "55"8) "55"9) "44"
10) "33"
11) "22"
12) "11"

获取列表指定范围内的元素

返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

LRANGE KEY_NAME START END

127.0.0.1:6379> lrange abc 2 5
1) "2"
2) "1"
3) "11"
4) "after"

获取全部元素

127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "2"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

移除列表元素

语法

 LREM key count VALUE

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

redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "hello"
(integer) 2
redis> RPUSH mylist "foo"
(integer) 3
redis> RPUSH mylist "hello"
(integer) 4
redis> LREM mylist -2 "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "foo"
redis>

通过索引设置列表元素的值

通过索引来设置元素的值。
当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误。

LSET key index value

4) "after"
127.0.0.1:6379> lset abc 2 zhangsan
OK
127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "zhangsan"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"

查找指定区间内的元素

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

127.0.0.1:6379> lrange abc 0 -11) "liuhuan"2) "3"3) "zhangsan"4) "1"5) "11"6) "after"7) "66"8) "55"9) "55"
10) "44"
11) "33"
12) "22"
13) "11"
127.0.0.1:6379> ltrim abc 3 6
OK
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "66"

移除列表的最后一个元素，并返回

移除列表的最后一个元素，返回值为移除的元素。

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "66"
127.0.0.1:6379> rpop abc
"66"
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"

移除列表的最后一个元素，并将该元素添加到另一个列表并返回

命令用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。

redis 127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
redis 127.0.0.1:6379> RPUSH mylist "foo"
(integer) 2
redis 127.0.0.1:6379> RPUSH mylist "bar"
(integer) 3
redis 127.0.0.1:6379> RPOPLPUSH mylist myotherlist
"bar"
redis 127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "foo"

在列表中添加一个或多个值到列表尾部

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
127.0.0.1:6379> rpush abc 33 44 55
(integer) 6
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"

为已存在的列表添加值

127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"
127.0.0.1:6379> rpushx abc 66
(integer) 7
127.0.0.1:6379> lrange abc 0 -1
1) "1"
2) "11"
3) "after"
4) "33"
5) "44"
6) "55"
7) "66"

hash（哈希）

删除一个或多个哈希表字段

命令用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。

HDEL key field1 [field2]

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "dec"
5) "sex"
127.0.0.1:6379> hdel info  dec sex
(integer) 2
127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"

查看哈希表 key 中，指定的字段是否存在

命令用于查看哈希表的指定字段是否存在

HEXISTS key field

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
127.0.0.1:6379> exists info name
(integer) 1

获取存储在哈希表中指定字段的值

命令用于查看哈希表的指定字段是否存在

HGET key field

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
127.0.0.1:6379> hget info name
"zhangsan"

获取在哈希表中指定 key 的所有字段和值

命令用于返回哈希表中，所有的字段和值。在返回值里，紧跟每个字段名(field name)之后是字段的值(value)，所以返回值的长度是哈希表大小的两倍

HGETALL key

127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "18"
5) "gender"
6) "main"

为哈希表 key 中的指定字段的整数值加上增量 increment

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

HINCRBY key field increment

127.0.0.1:6379> hget info age
"19"
127.0.0.1:6379> hincrby info age 2
(integer) 21

为哈希表 key 中的指定字段的浮点数值加上增量 increment

命令用于为哈希表中的字段值加上指定浮点数增量值。
如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0

HINCRBYFLOAT key field increment

127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "12.2"
127.0.0.1:6379> hincrbyfloat info money 1.2 
"13.4"

获取哈希表中的所有字段

命令用于获取哈希表中的所有域（field）

HKEYS key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"

获取哈希表中字段的数量

令用于获取哈希表中字段的数量

HLEN key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"
127.0.0.1:6379> hlen info
(integer) 4

获取所有给定字段的值

命令用于返回哈希表中，一个或多个给定字段的值。
如果指定的字段不存在于哈希表，那么返回一个 nil 值

HMGET key field1 [field2]

127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"

同时将多个 field-value (域-值)对设置到哈希表 key 中

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

HMSET key field1 value1 [field2 value2 ]

127.0.0.1:6379> hmset user name zhansgan age 18 sex man
OK
127.0.0.1:6379> hgetall user
1) "name"
2) "zhansgan"
3) "age"
4) "18"
5) "sex"
6) "man"

将哈希表 key 中的字段 field 的值设为 value

命令用于为哈希表中的字段赋值。
如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。
如果字段已经存在于哈希表中，旧值将被覆盖。

HSET key field value

127.0.0.1:6379> hgetall info
1) "name"
2) "lisi"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> HSET info name zhangsan
(integer) 0
127.0.0.1:6379> hgetall info
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"

只有在字段 field 不存在时，设置哈希表字段的值

命令用于为哈希表中不存在的的字段赋值。
如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。
如果字段已经存在于哈希表中，操作无效。
如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令

HSETNX key field value

127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> hsetnx info name 111
(integer) 0
127.0.0.1:6379> hgetall info 
1) "name"
2) "zhangsan"
3) "age"
4) "21"
5) "gender"
6) "main"
7) "money"
8) "13.4"
127.0.0.1:6379> hsetnx info address beijing
(integer) 1
127.0.0.1:6379> hgetall info 1) "name"2) "zhangsan"3) "age"4) "21"5) "gender"6) "main"7) "money"8) "13.4"9) "address"
10) "beijing"

获取哈希表中所有值

HVALS key

127.0.0.1:6379> hkeys info
1) "name"
2) "age"
3) "gender"
4) "money"
5) "address"

迭代哈希表中的键值对

命令用于迭代哈希表中的键值对

HSCAN key cursor [MATCH pattern] [COUNT count]

> HMSET sites google "google.com" runoob "runoob.com" weibo "weibo.com" 4 "taobao.com"
OK
> HSCAN sites 0 match "run*"
1) "0"
2) 1) "runoob"
2) "runoob.com"

set（集合）

向集合添加一个或多个成员

命令将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。
假如集合 key 不存在，则创建一个只包含添加的元素作成员的集合。
当集合 key 不是集合类型时，返回一个错误。
注意：在 Redis2.4 版本以前， SADD 只接受单个成员值。

SADD KEY_NAME VALUE1..VALUEN

127.0.0.1:6379> sadd myset 11 22 33 44
(integer) 4
127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"

获取集合的成员数

命令返回集合中元素的数量

SCARD key

127.0.0.1:6379> scard myset
(integer) 4

返回第一个集合与其他集合之间的差异

命令返回第一个集合与其他集合之间的差异，也可以认为说第一个集合中独有的元素。不存在的集合 key 将视为空集。差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整个 FIRST_KEY OTHER_KEY1…OTHER_KEYN 的差集

SDIFF key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiff myset myset1
1) "11"
2) "22"

返回给定所有集合的差集并存储在 destination 中

命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖

SDIFFSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiffstore abc  myset myset1
(integer) 2
127.0.0.1:6379> smembers abc
1) "11"
2) "22"

返回给定所有集合的交集

命令返回给定所有给定集合的交集。不存在的集合 key 被视为空集。当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

SINTER key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sinter myset1 myset
1) "33"
2) "44"
3) "55"
4) "66"

返回给定所有集合的交集并存储在 destination 中

命令将给定集合之间的交集存储在指定的集合中。如果指定的集合已经存在，则将其覆盖

SINTERSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sdiffstore abc  myset myset1
(integer) 2
127.0.0.1:6379> smembers abc
1) "11"
2) "22"

判断 member 元素是否是集合 key 的成员

命令判断成员元素是否是集合的成员

SISMEMBER key member

127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> sismember myset1 33
(integer) 1

返回集合中的所有成员

命令返回集合中的所有的成员。不存在的集合 key 被视为空集合

SMEMBERS key

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"

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

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

SMOVE source destination member

127.0.0.1:6379> smembers myset
1) "11"
2) "22"
3) "33"
4) "44"
5) "55"
6) "66"
127.0.0.1:6379> smembers myset1
1) "33"
2) "44"
3) "55"
4) "66"
127.0.0.1:6379> smove myset myset1 11
(integer) 1
127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

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

命令用于移除集合中的指定 key 的一个或多个随机元素，移除后会返回移除的元素。该命令类似 Srandmember 命令，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动。

SPOP key [count]

127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> spop myset 1
1) "55"
127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"

返回集合中一个或多个随机数

Redis Srandmember 命令用于返回集合中的一个随机元素。
从 Redis 2.6 版本开始， Srandmember 命令接受可选的 count 参数：
如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动

SRANDMEMBER key [count]

127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"66"
127.0.0.1:6379> srandmember myset
"44"
127.0.0.1:6379> srandmember myset
"22"

移除集合中一个或多个成员

命令用于移除集合中的一个或多个成员元素，不存在的成员元素会被忽略。
当 key 不是集合类型，返回一个错误。
在 Redis 2.4 版本以前， SREM 只接受单个成员值

SREM key member1 [member2]

127.0.0.1:6379> smembers myset
1) "22"
2) "33"
3) "44"
4) "66"
127.0.0.1:6379> srem myset 22 33
(integer) 2
127.0.0.1:6379> smembers myset
1) "44"
2) "66"

返回所有给定集合的并集

命令返回给定集合的并集。不存在的集合 key 被视为空集

SUNION key1 [key2]

127.0.0.1:6379> smembers myset
1) "44"
2) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> sunion myset myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

所有给定集合的并集存储在 destination 集合中

命令将给定集合的并集存储在指定的集合 destination 中。如果 destination 已经存在，则将其覆盖

SUNIONSTORE destination key1 [key2]

127.0.0.1:6379> smembers myset
1) "44"
2) "66"
127.0.0.1:6379> smembers myset1
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"
127.0.0.1:6379> sunionstore abc myset myset1
(integer) 5
127.0.0.1:6379> smembers abc
1) "11"
2) "33"
3) "44"
4) "55"
5) "66"

迭代集合中的元素

命令用于迭代集合中键的元素

cursor - 游标
pattern - 匹配的模式
count - 指定从数据集里返回多少元素，默认值为 10

SSCAN key cursor [MATCH pattern] [COUNT count]

> SADD myset1 "Google"
(integer) 1
> SADD myset1 "Runoob"
(integer) 1
> SADD myset1 "Taobao"
(integer) 1
> SSCAN myset1 0 match R*
1) "0"
2) 1) "Runoob"

zset(sorted set）

向有序集合添加一个或多个成员，或者更新已存在成员的分数

ZADD key score1 member1 [score2 member2]

127.0.0.1:6379> zadd score  1 "one" 2 "two"
(integer) 2
127.0.0.1:6379> zrange score 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"

获取有序集合的成员数

ZCARD key

127.0.0.1:6379> zrange score 0 -1 withscores
1) "one"
2) "1"
3) "two"
4) "2"
127.0.0.1:6379> zcard score
(integer) 2

计算在有序集合中指定区间分数的成员数

ZCOUNT key min max

127.0.0.1:6379> zadd info 1.0 "shuxue" 2.0 "yuwen" 3.0 "yingyu"
(integer) 3
127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"

有序集合中对指定成员的分数加上增量 increment

ZINCRBY key increment member

127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"
127.0.0.1:6379> zincrby info 11 shuxue
"12"
127.0.0.1:6379> zrange info 0 -1 withscores
1) "yuwen"
2) "2"
3) "yingyu"
4) "3"
5) "shuxue"
6) "12"

计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中

ZINTERSTORE destination numkeys key [key ...]

127.0.0.1:6379> zadd zset1 1 shuxue 2 yuwen 3 yingyu
(integer) 3
127.0.0.1:6379> zadd zset2 2 dili 3 yingyu 4 zhengzhi
(integer) 3
127.0.0.1:6379> zinterstore sum_point 2 zset1 zset2
(integer) 1
127.0.0.1:6379> zrange sum_point 0 -1 withscores
1) "yingyu"
2) "6"

在有序集合中计算指定字典区间内成员数量

	ZLEXCOUNT key min max

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e
(integer) 5
redis 127.0.0.1:6379> ZADD myzset 0 f 0 g
(integer) 2
redis 127.0.0.1:6379> ZLEXCOUNT myzset - +
(integer) 7
redis 127.0.0.1:6379> ZLEXCOUNT myzset [b [f
(integer) 5

通过索引区间返回有序集合指定区间内的成员

ZRANGE key start stop [WITHSCORES]

127.0.0.1:6379> zadd info 1.0 "shuxue" 2.0 "yuwen" 3.0 "yingyu"
(integer) 3
127.0.0.1:6379> zrange info 0 -1 withscores
1) "shuxue"
2) "1"
3) "yuwen"
4) "2"
5) "yingyu"
6) "3"

通过字典区间返回有序集合的成员

ZRANGEBYLEX key min max [LIMIT offset count]

redis 127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
(integer) 7
redis 127.0.0.1:6379> ZRANGEBYLEX myzset - [c
1) "a"
2) "b"
3) "c"
redis 127.0.0.1:6379> ZRANGEBYLEX myzset - (c
1) "a"
2) "b"
redis 127.0.0.1:6379> ZRANGEBYLEX myzset [aaa (g
1) "b"
2) "c"
3) "d"
4) "e"
5) "f"
redis>

通过分数返回有序集合指定区间内的成员

返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)次序排列。
具有相同分数值的成员按字典序来排列(该属性是有序集提供的，不需要额外的计算)。
默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]

redis 127.0.0.1:6379> ZADD salary 2500 jack                        # 测试数据
(integer) 0
redis 127.0.0.1:6379> ZADD salary 5000 tom
(integer) 0
redis 127.0.0.1:6379> ZADD salary 12000 peter
(integer) 0redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf               # 显示整个有序集
1) "jack"
2) "tom"
3) "peter"redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"redis 127.0.0.1:6379> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 显示工资 <=5000 的所有成员
1) "jack"
2) "2500"
3) "tom"
4) "5000"redis 127.0.0.1:6379> ZRANGEBYSCORE salary (5000 400000            # 显示工资大于 5000 小于等于 400000 的成员
1) "peter"

返回有序集合中指定成员的索引

返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列

ZRANK key member

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES        # 显示所有成员及其 score 值
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"redis 127.0.0.1:6379> ZRANK salary tom                     # 显示 tom 的薪水排名，第二
(integer) 1

移除有序集合中的一个或多个成员

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

ZREM key member [member ...]

# 测试数据redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"# 移除单个元素redis 127.0.0.1:6379> ZREM page_rank google.com
(integer) 1redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"# 移除多个元素redis 127.0.0.1:6379> ZREM page_rank baidu.com bing.com
(integer) 2redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)# 移除不存在元素redis 127.0.0.1:6379> ZREM page_rank non-exists-element
(integer) 0

移除有序集合中给定的字典区间的所有成员

命令用于移除有序集中，指定排名(rank)区间内的所有成

ZREMRANGEBYLEX key min max

redis 127.0.0.1:6379> ZADD salary 2000 jack
(integer) 1
redis 127.0.0.1:6379> ZADD salary 5000 tom
(integer) 1
redis 127.0.0.1:6379> ZADD salary 3500 peter
(integer) 1redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
(integer) 2redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
1) "tom"
2) "5000"

移除有序集合中给定的排名区间的所有成员

命令用于移除有序集中，指定排名(rank)区间内的所有成员

ZREMRANGEBYRANK key start stop

redis 127.0.0.1:6379> ZADD salary 2000 jack
(integer) 1
redis 127.0.0.1:6379> ZADD salary 5000 tom
(integer) 1
redis 127.0.0.1:6379> ZADD salary 3500 peter
(integer) 1redis 127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1       # 移除下标 0 至 1 区间内的成员
(integer) 2redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 有序集只剩下一个成员
1) "tom"
2) "5000"

移除有序集合中给定的分数区间的所有成员

Zremrangebyscore 命令用于移除有序集中，指定分数（score）区间内的所有成员

ZREMRANGEBYSCORE key min max

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES          # 显示有序集内所有成员及其 score 值
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"redis 127.0.0.1:6379> ZREMRANGEBYSCORE salary 1500 3500      # 移除所有薪水在 1500 到 3500 内的员工
(integer) 2redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成员
1) "jack"
2) "5000"

返回有序集中指定区间内的成员，通过索引，分数从高到低

ZREVRANGE key start stop [WITHSCORES]

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

返回有序集中指定分数区间内的成员，分数从高到低排序

ZREVRANGEBYSCORE key max min [WITHSCORES]

redis 127.0.0.1:6379> ZADD salary 10086 jack
(integer) 1
redis > ZADD salary 5000 tom
(integer) 1
redis 127.0.0.1:6379> ZADD salary 7500 peter
(integer) 1
redis 127.0.0.1:6379> ZADD salary 3500 joe
(integer) 1redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
1) "jack"
2) "peter"
3) "tom"
4) "joe"redis 127.0.0.1:6379> ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
1) "peter"
2) "tom"
3) "joe"

返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

	ZREVRANK key member

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"redis 127.0.0.1:6379> ZREVRANK salary peter     # peter 的工资排第二
(integer) 1redis 127.0.0.1:6379> ZREVRANK salary tom       # tom 的工资最高
(integer) 0

返回有序集中，成员的分数值

ZSCORE key member

redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"redis 127.0.0.1:6379> ZSCORE salary peter              # 注意返回值是字符串
"3500"

计算给定的一个或多个有序集的并集，并存储在新的 key 中

ZUNIONSTORE destination numkeys key [key ...]

redis> ZADD zset1 1 "one"
(integer) 1
redis> ZADD zset1 2 "two"
(integer) 1
redis> ZADD zset2 1 "one"
(integer) 1
redis> ZADD zset2 2 "two"
(integer) 1
redis> ZADD zset2 3 "three"
(integer) 1
redis> ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
(integer) 3
redis> ZRANGE out 0 -1 WITHSCORES
1) "one"
2) "5"
3) "three"
4) "9"
5) "two"
6) "10"
redis>

迭代有序集合中的元素（包括元素成员和元素分值）

ZSCAN key cursor [MATCH pattern] [COUNT count]

> ZADD site 1 "Google" 2 "Runoob" 3 "Taobao" 4 "Weibo"
(integer) 4
> ZSCAN site 0 match "R*"
1) "0"
2) 1) "Runoob"
2) 2.0