关于redis:深入学习Redis一

什么是 Redis

Redis 是齐全开源的，恪守 BSD 协定，是一个高性能的 key-value 数据库。

Redis 与其余 key – value 缓存产品有以下三个特点：

• Redis 反对数据的长久化，能够将内存中的数据保留在磁盘中，重启的时候能够再次加载进行应用。
• Redis 不仅仅反对简略的 key-value 类型的数据，同时还提供 list，set，zset，hash 等数据结构的存储。
• Redis 反对数据的备份，即 master-slave 模式的数据备份。

Redis 的个性

个性一：速度快

官网宣称能够达到：10 万 QPS

• 数据是存在内存中的。
• 应用 C 语言编写。
• 单线程模型。

Redis 速度快的次要起因就是 内存

从快到慢顺次是：

• Register 寄存器
• L1 Cache 一级缓存
• L2 Cache 二级缓存
• Main Memory 主存
• Local Disk 本地磁盘
• Remote Disk 近程磁盘

个性二：长久化

Redis 所有数据保留在内存当中，对数据的更新将以 异步 形式保留到磁盘上。

Redis 反对两种长久化形式：

1. RDB
2. AOF

个性三：多种数据结构

另外在 Redis 从 2.2.0 版本开始新增了三种数据结构：

Bitmaps 和 HyperLogLog 其实实质上是字符串，并不算是实在的数据结构，而 GEO 实质上有序汇合实现的。

• BitMaps：能够实现对位的操作。能够把 Bitmaps 设想成一个以位为单位数组，数组中的每个单元只能存 0 或者 1，数组的下标在 bitmaps 中叫做偏移量。单个 bitmaps 的最大长度是 512MB，即 2^32 个比特位。

• HyperLogLog：超小内存惟一值计数。特点是速度快，占用空间小。

• GEO：地理信息定位。

个性四：反对多种客户端语言

• Java
• PHP
• Python
• Ruby
• Lua
• Node
• …

个性五：功能丰富

• 提供公布订阅性能。
• 反对事务。
• 反对 Lua 脚本。
• Pipeline。

个性六：” 简略 ”

1. Redis 的单机外围代码只有 23.000 行左右。
2. Redis 不依赖内部库。
3. Redis 是单线程模型。

个性七：主从复制

主从复制是 Redis 保障高可用的根底

Redis 提供了复制性能，实现了多个雷同数据的 Redis 正本。

个性八：高可用、分布式

Redis 从 2.8 版本正式提供了高可用实现 Redis Sentinel，它可能保障 Redis 节点的故障发现和故障主动转移。

Redis 从 3.0 版本正式提供了分布式实现 Redis Cluster，它是 Redis 真正的分布式实现，提供了高可用、读写和容量的扩展性。

Redis 典型利用场景

• 缓存零碎
• 计数器
• 音讯队列
• 排行榜
• 社交网络，例如：粉丝数、关注数、独特关注、时间轴列表
• 实时零碎，Redis 应用 Bitmap 位图来实现布隆过滤性能，例如：垃圾邮件过滤实时处理

装置 Redis（Linux）

wget http://download.redis.io/releases/redis-3.0.7.tar.gz

tar -xzf redis-3.0.7.tar.gz

ln -s redis-3.0.7 redis

cd redis

make && make install

Redis 可执行文件阐明

进入 src 目录下：

• redis-server：Redis 服务器
• redis-cli：Redis 命令行客户端
• redis-benchmark：Redis 基准测试工具
• redis-check-aof：AOF 文件修复工具
• redis-check-dump：RDB 文件查看工具
• redis-sentinel：Sentinel 服务器

三种启动形式

1. 最简启动：能够间接应用 redis-server 命令以默认参数进行启动。
2. 动静启动：redis-server –port 6380
3. 配置文件启动： redis-server configPath

验证：

• ps -ef | grep redis：（查看 redis 过程是否启动）
• netstat -antpl | grep redis：（查看 redis 服务端口是否存在）
• redis-cli -h ip -p port ping：（查看 redis 客户端到 redis 服务端连通性）

三种启动形式比拟

生产环境抉择配置启动。

单机多实例配置文件能够用端口辨别。

启动 Redis

应用上面命令进行启动：

redis-server

连贯 Redis

redis-cli -h 127.0.0.1 -p 6379

连贯胜利后咱们就能够做一些操作。

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> ping
PONG
127.0.0.1:6379>exit

Redis API 应用和了解

通用命令

KEYS

KEYS [pattern]

查找所有合乎给定模式 pattern 的 key，比如说：

• KEYS * 匹配数据库中所有 key。
• KEYS h?llo 匹配 hello，hallo 和 hxllo 等。
• KEYS h*llo 匹配 hllo 和 heeeeello 等。
• KEYS h[ae]llo 匹配 hello 和 hallo，但不匹配 hillo。

keys 是 O(n)复杂度所以个别不在生产环境应用，因为 Redis 是单线程架构，使用不当会导致 Redis 阻塞。

DBSIZE

返回以后数据库的 key 的数量。在 Redis 外部有一个计数器来保护 Key 的数量，所以它的复杂度是 O(1)。

EXISTS

查看给定 key 是否存在。

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

DEL

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

返回被删除 key 的数量。

EXPIRE

为给定 key 设置生存工夫，当 key 过期时(生存工夫为 0 )，它会被主动删除。

设置胜利返回 1。当 key 不存在或者不能为 key 设置生存工夫时，返回 0。

TTL

以秒为单位，返回给定 key 的残余生存工夫(TTL, time to live)。

当 key 不存在时，返回 -2。当 key 存在但没有设置残余生存工夫时，返回 -1。否则，以秒为单位，返回 key 的残余生存工夫。

PERSIST

移除给定 key 的生存工夫，并变为永不过期的key。

当生存工夫移除胜利时，返回 1 . 如果 key 不存在或 key 没有设置生存工夫，返回 0。

TYPE

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

返回值

• none (key 不存在)
• string (字符串)
• list (列表)
• set (汇合)
• zset (有序集)
• hash (哈希表)
• stream（流）

数据结构和外部编码

redis 对外展示五种数据类型：

• string
• hash
• set
• zset
• list

每种数据结构，redis 都提供了不同的外部编码实现形式（外部编码能够通过 object encoding key 查看），以便应用不同的场景。

127.0.0.1:6379> object encoding hello
"embstr"

string

• raw：大于 39 个字节的字符串，用简略动静字符串（SDS）来保留，将这个字符串的对象编码设置为 raw。
• int：8 个字节的长整型，如果一个字符串保留的类型是整数值，并且这个值能够用 long 类型来示意，name 字符串对象会将整数值保留在字符串对象构造的 ptr 属性外面，并将字符串对象的编码设置为 int。
• embstr：小于等于 39 个字节的字符串，embstr 编码是专门用于保留短字符串的优化编码方式。

embstr 相较于 raw 有以下益处：

1. embstr 编码将创立字符串对象所需的空间调配的次数从 raw 编码的两次升高为一次。
2. 开释 embstr 编码的字符串对象只须要调用一次内存开释函数，而开释 raw 编码对象的字符串对象须要调用两次内存开释函数
3. 因为 embstr 编码的字符串对象的所有数据都保留在一块间断的内存外面，所以这种编码的字符串对象比起 raw 编码的字符串对象能更好地利用缓存带来的劣势。

hash

• ziplist（压缩列表）：当哈希类型元素小于 has-max-ziplist-entries 配置（默认 512 个），同时所有值都小于 hash-max-ziplist-value 配置（默认 64 个字节）时，redis 会应用 ziplist 作为哈希的外部实现。ziplist 应用更加紧凑的构造实现多个元素的间断存储，所以在节俭内存方面比 hashtable 更加优良。
• hashtable（哈希表）：当哈希类型无奈满足 ziplist 的条件时，redis 会应用 hashtable 作为哈希的外部实现。因为 ziplist 的读写效率会降落，而 hashtable 的读写工夫复杂度为 O(1)。

list

• ziplist（压缩列表）：当列表类型元素个数小于 hash-max-ziplist-entries 配置（默认 512 个）同时所有值都小于 hash-max-ziplist-value 配置（默认 64 个字节）时，Redis 会应用 ziplist 作为列表的外部实现。
• linkedlist（链表）：当列表类型无奈满足条件的时候，redis 会应用 linkedlist 作为列表的外部实现。

set

• intset（整数汇合）：当汇合中的元素都是整数且元素个数小于 set-max-intset-entries 配置（默认 512 个）是，redis 会选 intset 作为汇合的外部实现，从而缩小内存应用。
• hashtable（哈希表）：当汇合元素无奈满足 intset 的条件时，redis 会应用 hashtable 作为汇合的外部实现。

zset

• ziplist：当有序汇合的元素个数小于 zset-max-ziplist-entries 配置（默认 128 个）同时每个元素的值小于 zset-max-ziplist-value 配置（默认 64 个字节）时，Redis 会用 ziplist 来作为有序汇合的外部实现，ziplist 能够无效缩小内存应用。
• skiplist（跳跃表）：当 ziplist 条件不满足的时候，有序汇合会应用 skiplist 作为外部 实现，因为 ziplist 的读写效率会降落

字符串类型

特点

• key 是惟一的，不能反复。
• value 数据类型能够是多种，比方：字符串、数字、二进制，只是外部把数字、二进制数据转化为字符串。
• value 也能够是一个 JSON 字符串。
• value 还能够是序列化对象。
• value 能够存储最大的数据大小为：512MB。

罕用的字符串场景

• 缓存
• 计数器
• 分布式锁

GET

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

如果键 key 不存在，那么返回非凡值 nil；否则，返回键 key 的值。

如果键 key 的值并非字符串类型，那么返回一个谬误，因为 GET 命令只能用于字符串值。

SET

将字符串值 value 关联到 key。

如果 key 曾经持有其余值，SET 就覆写旧值，忽视类型。

当 SET 命令对一个带有生存工夫（TTL）的键进行设置之后，该键原有的 TTL 将被革除。

DEL

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

返回被删除 key 的数量。

INCR

为键 key 贮存的数字值加上一。

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

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

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

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

DECR

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

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

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

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

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

INCRBY

为键 key 贮存的数字值加上增量 increment。

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

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

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

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

DECRBY

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

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

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

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

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

SETNX

只在键 key 不存在的状况下，将键 key 的值设置为 value。

若键 key 曾经存在，则 SETNX 命令不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

命令在设置胜利时返回 1，设置失败时返回 0。

SETEX

将键 key 的值设置为 value，并将键 key 的生存工夫设置为 seconds 秒钟。

如果键 key 曾经存在，那么 SETEX 命令将笼罩已有的值。

SETEX 命令的成果和以下两个命令的成果相似：

SET key value
EXPIRE key seconds  # 设置生存工夫

SETEX 和这两个命令的不同之处在于 SETEX 是一个 原子性 (atomic) 操作，它能够在同一时间内实现设置值和设置过期工夫这两个操作，因而 SETEX 命令在贮存缓存的时候十分实用。

命令在设置胜利时返回 OK。当 seconds 参数不非法时，命令将返回一个谬误。

API：SETEX key seconds value

127.0.0.1:6379> setex jack 60 nihao
OK

MGET

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

如果给定的字符串键外面，有某个键不存在，那么这个键的值将以非凡值 nil 示意。

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

MSET

同时为多个键设置值。

如果某个给定键曾经存在，那么 MSET 将应用新值去笼罩旧值。

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

MSET 命令总是返回 OK。

MSETNX

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

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

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

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

API：MSETNX key value [key value …]

127.0.0.1:6379> msetnx jack1 h jack2 e jack3 l  #对不存在的 key 设置 value
(integer) 1
127.0.0.1:6379> msetnx jack1 h jack2 e jack3 l #对存在的 key 设置 value
(integer) 0
127.0.0.1:6379> mget jack1 jack2 jack3  #批量获取 key
1) "h"
2) "e"
3) "l"
127.0.0.1:6379>

GETSET

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

如果键 key 没有旧值，也即是说，键 key 在被设置之前并不存在，那么命令返回 nil。

当键 key 存在但不是字符串类型时，命令返回一个谬误。

APPEND

如果键 key 曾经存在并且它的值是一个字符串，APPEND 命令将把 value 追加到键 key 现有值的开端。

如果 key 不存在，APPEND 就简略地将键 key 的值设为 value，就像执行 SET key value 一样。

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

STRLEN

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

STRLEN 命令返回字符串值的长度。

当键 key 不存在时，命令返回 0。

当 key 贮存的不是字符串值时，返回一个谬误。

INCRBYFLOAT

为键 key 贮存的值加上浮点数增量 increment。

如果键 key 不存在，那么 INCRBYFLOAT 会先将键 key 的值设为 0，而后再执行加法操作。

如果命令执行胜利，那么键 key 的值会被更新为执行加法计算之后的新值，并且新值会以字符串的模式返回给调用者。

当以下任意一个条件产生时，命令返回一个谬误：

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

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

GETRANGE

返回键 key 贮存的字符串值的指定局部，字符串的截取范畴由 start 和 end 两个偏移量决定 (包含 start 和 end 在内)。

正数偏移量示意从字符串的开端开始计数，-1 示意最初一个字符，-2 示意倒数第二个字符，以此类推。

GETRANGE 命令会返回字符串值的指定局部。

SETRANGE

从偏移量 offset 开始，用 value 参数覆写键 key 贮存的字符串值。

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

Hash 类型

• 哈希类型也是 key-value 构造，key 是字符串类型，其 value 分为两个局部：field 和 value。
• 其中 field 局部代表属性，value 代表属性对应的值。

例如上图中，user:1:info为 key,name,age,Date为 user 这个 key 的一些属性，value 是属性对应的值。

在 hash 中，能够为 key 增加一个新的属性和新的值。

比方应用上面的命令向 user:1:info 这个 key 增加一个新属性 viewCounter, 属性对应的值为 100。

hset user:1:info viewCounter 100

特点：

• 适宜存储对象 ，并且能够像数据库中 update 一个属性一样 只批改某一项属性值。
• field 不能雷同，value 能够雷同。

实用场景：

hash 变更的数据 user name age, 尤其是是用户信息之类的，常常变动的信息。hash 更适宜于对象的 存储，String 更加适宜字符串存储！

HGET

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

如果给定域不存在于哈希表中，又或者给定的哈希表并不存在，那么命令返回 nil。

HSET

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

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

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

当 HSET 命令在哈希表中新创建 field 域并胜利为它设置值时，命令返回 1；如果域 field 曾经存在于哈希表，并且 HSET 命令胜利应用新值笼罩了它的旧值，那么命令返回 0。

HSETNX

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

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

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

HSETNX 命令在设置胜利时返回 1，在给定域曾经存在而放弃执行设置操作时返回 0。

HDEL

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

返回被胜利移除的域的数量，不包含被疏忽的域。

HEXISTS

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

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

HLEN

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

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

HMGET

返回哈希表 key 中，一个或多个给定域的值。

如果给定的域不存在于哈希表，那么返回一个 nil 值。

因为不存在的 key 被当作一个空哈希表来解决，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

HMSET

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

此命令会笼罩哈希表中已存在的域。

如果 key 不存在，一个空哈希表被创立并执行 HMSET 操作。

如果命令执行胜利，返回 OK。

当 key 不是哈希表 (hash) 类型时，返回一个谬误。

HGETALL

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

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

HVALS

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

当 key 不存在时，返回一个空表。

HKEYS

返回哈希表 key 中的所有field。

当 key 不存在时，返回一个空表。

HINCRBY

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

增量也能够为正数，相当于对给定域进行减法操作。

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

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

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

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

最终返回哈希表 key 中域 field 的新值。

List 类型

特点：

• 链表 (双向链表) 可演化成栈，队列，在两边插入或者改变值，效率高。
• 有序。
• 能够反复。
• 左右两边插入弹出。

实用场景：

• 最新消息排行等性能(比方朋友圈的工夫线)。
• 音讯队列。

RPUSH

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

如果有多个 value 值，那么各个 value 值按从左到右的程序顺次插入到表尾。

如果 key 不存在，一个空列表会被创立并执行 RPUSH 操作。

当 key 存在但不是列表类型时，返回一个谬误。

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

LPUSH

将一个或多个值 value 插入到列表 key 的表头

如果有多个 value 值，那么各个 value 值按从左到右的程序顺次插入到表头。

如果 key 不存在，一个空列表会被创立并执行 LPUSH 操作。

当 key 存在但不是列表类型时，返回一个谬误。

执行 LPUSH 操作后，返回列表的长度。

LINSERT

将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

当 pivot 不存在于列表 key 时，不执行任何操作。

当 key 不存在时，key 被视为空列表，不执行任何操作。

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

如果命令执行胜利，返回插入操作实现之后，列表的长度。

如果没有找到 pivot，返回 -1。如果 key 不存在或为空列表，返回 0。

LPOP

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

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

RPOP

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

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

LREM

依据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值能够是以下几种：

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

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

LTRIM

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

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

须要留神的是：

• 如果 stop 下标比 end 下标还要大，Redis 将 stop 的值设置为 end。
• 下标从 0 开始。

命令执行胜利时，返回 ok。

LRANGE

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

须要留神的是：

• 如果 stop 下标比 end 下标还要大，Redis 将 stop 的值设置为 end。
• 下标从 0 开始。
• 蕴含 start 和stop。

命令执行胜利时，返回指定区间内的元素。

LINDEX

返回列表 key 中，下标为 index 的元素。

以 0 示意列表的第一个元素，以 1 示意列表的第二个元素，以此类推。

也能够应用正数下标，以 -1 示意列表的最初一个元素，-2 示意列表的倒数第二个元素，以此类推。

LLEN

返回列表 key 的长度。

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

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

LSET

将列表 key 下标为 index 的元素的值设置为 value。

当 index 参数超出范围，或对一个空列表 (key 不存在) 进行 LSET 时，返回一个谬误。

操作胜利返回 ok，否则返回谬误。

BLPOP

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

当给定列表内没有任何元素可供弹出的时候，连贯将被阻塞，直到期待超时或发现可弹出元素为止。

当存在多个给定 key 时，按给定 key 参数排列的先后顺序，顺次查看各个列表。

超时参数 timeout 承受一个以秒为单位的数字作为值。超时参数设为 0 示意阻塞工夫能够无限期缩短(block indefinitely)。

API：BLPOP key [key …] timeout

127.0.0.1:6379> blpop list1 list2 0  # 无限期阻塞
1) "list1"                           # 用另一个连贯 lpush list1 a
2) "a"                                                   # 被弹出的值
(30.31s)

BLPOP 保障返回的元素来自第一个非空的列表，因为它是按”查找 list1 -> 查找 list2 这样的程序，第一个找到的非空列表。

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

BRPOP 和 BLPOP 命令正好相同，就不演示了。

List 的小技巧

• LPUSH + LPOP = Stack
• LPUSH + RPOP = Queue
• LPUSH +BRPOP = Message Queue

Set 类型

右边为 key 是字符串类型，左边为 values, 能够将一些字符串进行一些组合，能够向 value 中增加或者删除一个元素。

特点：

• 哈希表实现，元素不反复。
• 增加、删除, 查找的复杂度都是 O(1)。
• 为汇合提供了求交加、并集、差集等操作。
• 无序。

实用场景：

• 独特好友。
• 利用唯一性，统计拜访网站的所有独立 ip。
• 好友举荐时，依据 tag 求交加，大于某个阈值就能够举荐。

SADD

将一个或多个 member 元素退出到汇合 key 当中，曾经存在于汇合的 member 元素将被疏忽。

如果 key 不存在，则创立一个只蕴含 member 元素作成员的汇合。

当 key 不是汇合类型时，返回一个谬误。

返回被增加到汇合中的新元素的数量，不包含被疏忽的元素。

SREM

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

当 key 不是汇合类型，返回一个谬误。

返回被胜利移除的元素的数量，不包含被疏忽的元素。

SCARD

返回汇合 key 的基数(汇合中元素的数量)。

汇合的基数。当 key 不存在时，返回 0。

API：SCARD key

127.0.0.1:6379> sadd myset a b c d e f
(integer) 6
127.0.0.1:6379> scard myset
(integer) 6

SISMEMBER

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

如果 member 元素是汇合的成员，返回 1。如果 member 元素不是汇合的成员，或 key 不存在，返回 0。

API：SISMEMBER key member

127.0.0.1:6379> sismember myset a  #存在
(integer) 1
127.0.0.1:6379> sismember myset z #不存在
(integer) 0

SRANDMEMBER

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

从 Redis 2.6 版本开始，承受可选的 count 参数：

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

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

API：SRANDMEMBER key [count]

127.0.0.1:6379> srandmember myset #不填 count 随机返回一个
"b"
127.0.0.1:6379> srandmember myset 2 # count 为负数
1) "e"
2) "f"
127.0.0.1:6379> srandmember myset -2 # count 为正数
1) "e"
2) "a"
127.0.0.1:6379> srandmember myset -2 # count 为正数
1) "f"
2) "f"

SMEMBERS

返回汇合 key 中的所有成员。

不存在的 key 被视为空集合。

API：SMEMBERS key

127.0.0.1:6379> smembers myset
1) "a"
2) "e"
3) "d"
4) "f"
5) "c"
6) "b"

SPOP

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

返回被移除的随机元素。当 key 不存在或 key 是空集时，返回 nil。

API：SPOP key

127.0.0.1:6379> spop myset
"d"

SINTER

返回一个汇合的全副成员，该汇合是所有给定汇合的交加。

不存在的 key 被视为空集。

当给定汇合当中有一个空集时，后果也为空集(依据汇合运算定律)。

API：SINTER key [key …]

127.0.0.1:6379> smembers set1
1) "a"
2) "c"
3) "d"
4) "b"
5) "e"
127.0.0.1:6379> smembers set2
1) "d"
2) "b"
3) "e"
127.0.0.1:6379> sinter set1 set2  #获取两遍都存在的数据
1) "d"
2) "b"
3) "e"

SUNION

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

不存在的 key 被视为空集。

API：SUNION key [key …]

127.0.0.1:6379> sunion set1 set2 #获取并集
1) "a"
2) "e"
3) "d"
4) "c"
5) "b"

SDIFF

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

不存在的 key 被视为空集。

API：SDIFF key [key …]

127.0.0.1:6379> sdiff set1 set2 #获取差集
1) "a"
2) "c"

ZSet 类型

右边为 key，是字符串类型。左边为 value，由两局部组成：score 和 value score 示意分值，示意 value 在有序汇合中的地位。

汇合与有序汇合的区别

• 都没有反复元素。
• 汇合无序，有序汇合是有序的。
• 汇合中只有 member，有序汇合中有 member+score。

列表与有序汇合的区别

• 列表能够有反复元素，有序汇合没有反复元素。
• 列表有序，有序汇合有序。
• 列表中只有 member, 有序汇合中有 member+score。

特点：

将 Set 中的元素减少一个 权重参数 score, 元素按 score 有序排列，人造排序。

实用场景：

• 1、排行榜。
• 2、带权重的音讯队列。

ZADD

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

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

score 值能够是整数值或双精度浮点数。

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

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

返回被胜利增加的新成员的数量，不包含那些被更新的、曾经存在的成员。

ZREM

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

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

返回被胜利移除的成员的数量，不包含被疏忽的成员。

ZSCORE

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

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

ZINCRBY

为有序集 key 的成员 member 的 score 值加上增量 increment。

能够通过传递一个负数值 increment，让 score 减去相应的值。

当 key 不存在，或 member 不是 key 的成员时，ZINCRBY key increment member 等同于 ZADD key increment member。

当 key 不是有序集类型时，返回一个谬误。

score 值能够是整数值或双精度浮点数。

member 成员的新 score 值，以字符串模式示意。

ZCARD

当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0。

ZRANGE

返回有序集 key 中，指定区间内的成员。

其中成员的地位按 score 值递增 (从小到大) 来排序。

如果须要从大到小能够应用 ZREVRANGE 命令。

下标从 0 开始，stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来解决。

能够通过应用 WITHSCORES 选项，来让成员和它的 score 值一并返回。

API：ZRANGE key start stop [WITHSCORES]

127.0.0.1:6379> zadd zset 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> zrange zset  0 2
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrange zset  0 2 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"

ZRANGEBYSCORE

返回有序集 key 中，所有 score 值介于 min 和 max 之间 (包含等于 min 或 max ) 的成员。有序集成员按 score 值递增 (从小到大) 秩序排列。

可选的 LIMIT 参数指定返回后果的数量及区间(就像 SQL 中的 SELECT LIMIT offset, count )，留神当 offset 很大时，定位 offset 的操作可能须要遍历整个有序集，此过程最坏复杂度为 O(N) 工夫。

能够通过应用 WITHSCORES 选项，来让成员和它的 score 值一并返回。

min 和 max 能够是 -inf 和 +inf，这样一来，你就能够在不晓得有序集的最低和最高 score 值的状况下，应用这类命令。

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

127.0.0.1:6379> ZRANGEBYSCORE zset 10 50 withscores
 1) "a"
 2) "10"
 3) "b"
 4) "20"
 5) "c"
 6) "30"
 7) "d"
 8) "40"
 9) "e"
10) "50"
127.0.0.1:6379> ZRANGEBYSCORE zset -inf +inf
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"

ZCOUNT

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

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

API：ZCOUNT key min max

127.0.0.1:6379> zcount zset 10 30
(integer) 3

ZREMRANGEBYRANK

移除有序集 key 中，指定排名 (rank) 区间内的所有成员。

区间别离以下标参数 start 和 stop 指出，蕴含 start 和 stop 在内。

下标参数 start 和 stop 都以 0 为底，也就是说，以 0 示意有序集第一个成员，以 1 示意有序集第二个成员，以此类推。你也能够应用正数下标，以 -1 示意最初一个成员，-2 示意倒数第二个成员，以此类推。

返回被移除成员的数量。

API：ZREMRANGEBYRANK key start stop

127.0.0.1:6379> zrange zset 0 100 withscores
 1) "a"
 2) "10"
 3) "b"
 4) "20"
 5) "c"
 6) "30"
 7) "d"
 8) "40"
 9) "e"
10) "50"
127.0.0.1:6379> ZREMRANGEBYRANK zset 0 1
(integer) 2
127.0.0.1:6379> zrange zset 0 100 withscores
1) "c"
2) "30"
3) "d"
4) "40"
5) "e"
6) "50"

ZREMRANGEBYSCORE

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

返回被移除成员的数量。

API：ZREMRANGEBYSCORE key min max

127.0.0.1:6379> zremrangebyscore zset 40 50
(integer) 2

ZINTERSTORE

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

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

返回保留到 destination 的后果集的基数。

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

127.0.0.1:6379> zadd test1 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> zadd test2 10 a 20 b 30 c 40 d 50 e
(integer) 5
127.0.0.1:6379> ZINTERSTORE sum_point 2 test1 test2
(integer) 5
127.0.0.1:6379> zrange sum_point  0 -1 withscores
 1) "a"
 2) "20"
 3) "b"
 4) "40"
 5) "c"
 6) "60"
 7) "d"
 8) "80"
 9) "e"
10) "100"

ZUNIONSTORE

计算给定的一个或多个有序集的并集，其中给定 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 的后果集的基数。

127.0.0.1:6379> zrange test3 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
127.0.0.1:6379> zrange test4 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"
7) "d"
8) "40"
127.0.0.1:6379> zunionstore test5 2 test4 test5 weights 1 3
(integer) 4
127.0.0.1:6379> zrange test5 0 -1 withscores
1) "a"
2) "10"
3) "b"
4) "20"
5) "c"
6) "30"
7) "d"
8) "40"

Redis 命令参考