什么是 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 近程磁盘
类型每秒读写次数随机读写提早拜访带宽
内存千万级80ns5GB
SSD 盘350000.1-02ms100~300MB
机械盘100 左右10ms100MB 左右

个性二：长久化

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.gztar -xzf redis-3.0.7.tar.gzln -s redis-3.0.7 rediscd redismake && 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 worldOK127.0.0.1:6379> get hello"world"127.0.0.1:6379> pingPONG127.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 valueEXPIRE key seconds  # 设置生存工夫

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

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

API：SETEX key seconds value

127.0.0.1:6379> setex jack 60 nihaoOK

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) 1127.0.0.1:6379> msetnx jack1 h jack2 e jack3 l #对存在的key设置value(integer) 0127.0.0.1:6379> mget jack1 jack2 jack3  #批量获取key1) "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 a2) "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) 6127.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) 1127.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 myset1) "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 set11) "a"2) "c"3) "d"4) "b"5) "e"127.0.0.1:6379> smembers set21) "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) 5127.0.0.1:6379> zrange zset  0 21) "a"2) "b"3) "c"127.0.0.1:6379> zrange zset  0 2 withscores1) "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 +inf1) "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) 2127.0.0.1:6379> zrange zset 0 100 withscores1) "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) 5127.0.0.1:6379> zadd test2 10 a 20 b 30 c 40 d 50 e(integer) 5127.0.0.1:6379> ZINTERSTORE sum_point 2 test1 test2(integer) 5127.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 withscores1) "a"2) "10"3) "b"4) "20"127.0.0.1:6379> zrange test4 0 -1 withscores1) "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) 4127.0.0.1:6379> zrange test5 0 -1 withscores1) "a"2) "10"3) "b"4) "20"5) "c"6) "30"7) "d"8) "40"

Redis 命令参考