Redis详解

1. Redis 概述

1. Redis远程字典服务器;
2. Redis 是一个高性能(key/value)分布式内存数据库,基于内存运行并支持持久化的NoSQL数据库;
3. Redis 三个特点:
   • Redis 支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候,可以再次加载进行使用;
   • Redis 不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储;
   • Redis 支持数据的备份,即master-slave模式的数据备份;

     

2. Redis 数据类型

1. String(字符串)
2. Hash(哈希)
3. List(列表)
4. Set（集合）
5. Zset(sorted set: 有序集合)

2.2 Redis 键(key)

set 键名 键值: 向数据库中存储键值对;
例:
    127.0.0.1:6379> set name king
    OK
    127.0.0.1:6379> get name
    "king"

type key: 查看key的类型;
例:
    127.0.0.1:6379> type name
    string

exists 键名: 判断某个key是否存在,存在,返回"1";不存在,返回"0";
例:
    127.0.0.1:6379> exists name
    (integer) 1
    127.0.0.1:6379> exists user
    (integer) 0

expire key 秒: 为指定的key设置过期时间;
例:
    127.0.0.1:6379> expire name 60
    (integer) 1

ttl key: 查看该key,还有多少秒过期,-1表示永不过期, -2表示已过期;
例:

      127.0.0.1:6379> ttl name
      (integer) 22
      127.0.0.1:6379> ttl name
      (integer) 7
      127.0.0.1:6379> ttl name
      (integer) -2

  keys *: 查看当前数据库所有键;

  例:

      127.0.0.1:6379> keys *
      1) "count"
      2) "b"
      3) "c"
      4) "a"

move 键名 数据库(例如2): 将某个键剪切至2号数据库;
例:

      127.0.0.1:6379> move a 2
      (integer) 1
      127.0.0.1:6379> keys *
      1) "count"
      2) "b"
      3) "c"

2.3 Redis 字符串(String)

SET key value [EX seconds] [PX milliseconds] [NX|XX]

   将字符串值 value 关联到 key 。

   如果 key 已经持有其他值， SET 就覆写旧值， 无视类型。

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

可选参数

   从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改：

• EX seconds ： 将键的过期时间设置为 seconds 秒。 执行 SET key value EX seconds 的效果等同于执行 SETEX key seconds value 。
• PX milliseconds ： 将键的过期时间设置为 milliseconds 毫秒。 执行 SET key value PX milliseconds 的效果等同于执行 PSETEX key milliseconds value 。
• NX ： 只在键不存在时， 才对键进行设置操作。 执行 SET key value NX 的效果等同于执行 SETNX key value 。
• XX ： 只在键已经存在时， 才对键进行设置操作。

   注意:

     因为 SET 命令可以通过参数来实现 SETNX 、 SETEX 以及 PSETEX 命令的效果， 所以 Redis 将来的版本可能会移除并废弃 SETNX 、 SETEX 和 PSETEX 这三个命令。

返回值

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

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

代码示例

例:
   1.对不存在的键进行设置

        127.0.0.1:6379> set user zhangsan
        OK
        127.0.0.1:6379> get user
        "zhangsan"

   2.对已存在的键进行设置

       127.0.0.1:6379> set user lisi
       OK
       127.0.0.1:6379> get user
       "lisi"

     3.使用EX选项

       127.0.0.1:6379> set expire_key 'uuwsghd#772' EX 10086
       OK
       127.0.0.1:6379> get expire_key
       "uuwsghd#772"
       127.0.0.1:6379> ttl expire_key
       (integer) 10074

     4.使用PX选项

       127.0.0.1:6379> set px_str_key 'king' PX 123123
       OK
       127.0.0.1:6379> PTTL px_str_key
       (integer) 106987
       127.0.0.1:6379> get px_str_key
       "king"

     5.使用NX选项

       127.0.0.1:6379> SET not-exists-key "value" NX
       OK       #键不存在设置成功
       127.0.0.1:6379> GET not-exists-key
       "value"
       127.0.0.1:6379> SET not-exists-key "new-value" NX
       (nil)    #键已经存在设置失败
       127.0.0.1:6379> GEt not-exists-key
       "value"

   6.使用XX选项

       127.0.0.1:6379> EXISTS exists-key
       (integer) 0
       127.0.0.1:6379> SET exists-key "value" XX
       (nil)    #因为键不存在设置失败
       127.0.0.1:6379> SET exists-key "value"
       OK       #先给键设置一个值
       127.0.0.1:6379> SET exists-key "value" XX
       OK       #设置新值成功
       127.0.0.1:6379> GET exists-key
       "value"

SETNX key value

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

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

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

返回值

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

代码示例

      127.0.0.1:6379> EXISTS job
      (integer) 0    #job不存在
      127.0.0.1:6379> SETNX job "programmer"
      (integer) 1    #设置成功
      127.0.0.1:6379> SETNX job "code-farmer"
      (integer) 0    #覆盖失败
      127.0.0.1:6379> GET job
      "programmer"

SETEX key seconds value

   如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。

   SETEX 命令的效果和以下两个命令的效果类似：

  SET key value
  EXPIRE key seconds  # 设置生存时间

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

返回值

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

代码示例
    在键 key 不存在的情况下执行 SETEX ：
     127.0.0.1:6379> SETEX cache_user_id 60 10086
     OK             #设置值并且设置生存时间
     127.0.0.1:6379> GET cache_user_id
     "10086"
     127.0.0.1:6379> TTL cache_user_id
     (integer) 43   #剩余生存时间
     127.0.0.1:6379> TTL cache_user_id
     (integer) 41   #剩余生存时间

    键 key 已经存在， 使用 SETEX 覆盖旧值：
     127.0.0.1:6379> SET cd "timeless"
     OK
     127.0.0.1:6379> SETEX cd 3000 "goodbye my love"
     OK
     127.0.0.1:6379> GET cd
     "goodbye my love"
     127.0.0.1:6379> TTL cd
     (integer) 2983
     127.0.0.1:6379> TTL cd
     (integer) 2982

PSETEX key milliseconds value

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

返回值

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

代码示例
   127.0.0.1:6379> PSETEX mykey 10000 "Hello"
   OK
   127.0.0.1:6379> PTTL mykey
   (integer) 7768
   127.0.0.1:6379> PTTL mykey
   (integer) 6008
   127.0.0.1:6379> GET mykey
   "Hello"
 

GET key

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

返回值

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

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

代码示例

对不存在的键 key 或是字符串类型的键 key 执行 GET 命令：

   127.0.0.1:6379> GET db
   (nil)
   127.0.0.1:6379> SET db redis
   OK
   127.0.0.1:6379> GET db
   "redis"

对不是字符串类型的键 key 执行 GET 命令：

   127.0.0.1:6379> DEL db
   (integer) 1
   127.0.0.1:6379> LPUSH db redis mongodb mysql
   (integer) 3
   127.0.0.1:6379> GET db
   (error) WRONGTYPE Operation against a key holding the wrong kind of value

GETSET key value

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

返回值

返回给定键 key 的旧值。

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

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

代码示例

   127.0.0.1:6379> GETSET db mongodb   #没有旧值 返回nil
   (nil)
   127.0.0.1:6379> GET db
   "mongodb"
   127.0.0.1:6379> GETSET db redis     #返回旧值 mongodb
   "mongodb"
   127.0.0.1:6379> GET db
   "redis"

STRLEN key

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

返回值

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

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

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

代码示例
获取字符串值的长度：
   127.0.0.1:6379> SET mykey "Hello world"
   OK
   127.0.0.1:6379> STRLEN mykey
   (integer) 11
不存在的键的长度为 0 ：

   127.0.0.1:6379> STRLEN nonexisting
   (integer) 0

APPEND key value

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

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

返回值

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

示例代码
对不存在的 key 执行 APPEND ：
   127.0.0.1:6379> EXISTS myphone         #确保myphone不存在
   (integer) 0
   127.0.0.1:6379> APPEND myphone "nokia" #对不存在的key进行APPEND，等同于 SET myphone "nokia"
   (integer) 5                            #返回字符长度
对已存在的字符串进行 APPEND ：
   127.0.0.1:6379> APPEND myphone " - 1110" #长度从5个字符增加到12个字符
   (integer) 12                             #返回新的字符长度
   127.0.0.1:6379> GET myphone
   "nokia - 1110"

SETRANGE key offset value

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

不存在的键 key 当作空白字符串处理。

SETRANGE 命令会确保字符串足够长以便将 value 设置到指定的偏移量上， 如果键 key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长，但你设置的 offset 是 10 )， 那么原字符和偏移量之间的空白将用零字节(zerobytes, "x00" )进行填充。

注意:

  因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内， 所以用户能够使用的最大偏移量为 2^29-1(536870911) ， 如果你需要使用比这更大的空间， 请使用多个 key 。

返回值

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

代码示例

对非空字符串执行 SETRANGE 命令：

   127.0.0.1:6379> SET greeting "hello world"
   OK
   127.0.0.1:6379> SETRANGE greeting 6 "Redis"
   (integer) 11
   127.0.0.1:6379> GET greeting
   "hello Redis"

对空字符串/不存在的键执行 SETRANGE 命令： 

   127.0.0.1:6379> EXISTS empty_string                
   (integer) 0
   127.0.0.1:6379> SETRANGE empty_string 5 "Redis!" #对不存在的键使用SETRANGE 
   (integer) 11
   127.0.0.1:6379> GET empty_string                 #空白处被"x00"填充
   "x00x00x00x00x00Redis!"

 

GETRANGE key start end

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

负数偏移量表示从字符串的末尾开始计数， -1 表示最后一个字符， -2 表示倒数第二个字符， 以此类推。

GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

返回值

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

代码示例

   127.0.0.1:6379> SET greeting "hello, my friend"
   OK
   127.0.0.1:6379> GETRANGE greeting 0 4            #返回索引0-4的字符，包括0和4
   "hello"
   127.0.0.1:6379> GETRANGE greeting -1 -5          #不支持回绕操作
   ""
   127.0.0.1:6379> GETRANGE greeting -3 -1          #负数索引 倒数第3个到倒数第1个
   "end"
   127.0.0.1:6379> GETRANGE greeting 0 -1           #从第一个到最后一个
   "hello, my friend"
   127.0.0.1:6379> GETRANGE greeting 0 1008611      #值域范围不超过实际字符串，超过部分自动被忽略
   "hello, my friend"

 

INCR key

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

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

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

注意:

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

INCR 命令是一个针对字符串的操作。 因为 Redis 并没有专用的整数类型， 所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

返回值

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

代码示例
   127.0.0.1:6379> SET page_view 20
   OK
   127.0.0.1:6379> INCR page_view
   (integer) 21
   127.0.0.1:6379> GET page_view
   "21"
   127.0.0.1:6379> SET page_view 'abc'                    #设置字符串值
   OK
   127.0.0.1:6379> INCR page_view
   (error) ERR value is not an integer or out of range    #值不是数字 返回错误
   127.0.0.1:6379> EXISTS page_num
   (integer) 0
   127.0.0.1:6379> INCR page_num
   (integer) 1
   127.0.0.1:6379> GET page_num
   "1"

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

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






代码示例
键存在，并且值为数字：
   127.0.0.1:6379> SET rank 50
   OK
   127.0.0.1:6379> INCRBY rank 20
   (integer) 70
   127.0.0.1:6379> GET rank
   "70"
键不存在：
   127.0.0.1:6379> EXISTS counter
   (integer) 0
   127.0.0.1:6379> INCRBY counter 30
   (integer) 30
   127.0.0.1:6379> GET counter
   "30"
键存在，但值无法被解释为数字
   127.0.0.1:6379> SET book "long long ago..."
   OK
   127.0.0.1:6379> INCRBY book 200
   (error) ERR value is not an integer or out of range

INCRBYFLOAT key increment
为键 key 储存的值加上浮点数增量 increment 。
如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。
如果命令执行成功， 那么键 key 的值会被更新为执行加法计算之后的新值， 并且新值会以字符串的形式返回给调用者。
无论是键 key 的值还是增量 increment ， 都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示， 但是， 执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存， 也即是， 它们总是由一个数字， 一个（可选的）小数点和一个任意长度的小数部分组成（比如 3.14 、 69.768 ，诸如此类)， 小数部分尾随的 0 会被移除， 如果可能的话， 命令还会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。

注意：
  无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 命令的计算结果最多只保留小数点的后十七位。

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

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

返回值

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

代码示例

   127.0.0.1:6379> GET decimal
   (nil)
   127.0.0.1:6379> INCRBYFLOAT decimal 2.56
   "2.56"
   127.0.0.1:6379> GET decimal
   "2.56"

DECR key

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

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

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

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

返回值

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

代码示例
对储存数字值的键 key 执行 DECR 命令：
   127.0.0.1:6379> SET failure_times 10
   OK
   127.0.0.1:6379> DECR failure_times
   (integer) 9
对不存在的键执行 DECR 命令：
   127.0.0.1:6379> EXISTS count
   (integer) 0
   127.0.0.1:6379> DECR count
   (integer) -1

DECRBY key decrement

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

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

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

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

返回值

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

代码示例
对已经存在的键执行 DECRBY 命令：
   127.0.0.1:6379> SET count 100
   OK
   127.0.0.1:6379> DECRBY count 20
   (integer) 80
   127.0.0.1:6379> GET count
   "80"
对不存在的键执行 DECRBY 命令：
   127.0.0.1:6379> EXISTS pages
   (integer) 0
   127.0.0.1:6379> DECRBY pages 10
   (integer) -10

MSET key value [key value …]
同时为多个键设置值。
如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。
MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。

返回值
MSET 命令总是返回 OK 。






代码示例
同时对多个键进行设置：
   127.0.0.1:6379> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
   OK
   127.0.0.1:6379> MGET date time weather
   1) "2012.3.30"
   2) "11:00 a.m."
   3) "sunny"
覆盖已有的值：
   127.0.0.1:6379> MSET k1 'hello' k2 'world'
   OK
   127.0.0.1:6379> MGET k1 k2
   1) "hello"
   2) "world"
   127.0.0.1:6379> MSET k1 "good" k2 "bye"
   OK
   127.0.0.1:6379> MGET k1 k2
   1) "good"
   2) "bye"
 
MSETNX key value [key value …]
当且仅当所有给定键都不存在时，为所有给定键设置值。
即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

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






代码示例
对不存在的键执行 MSETNX 命令：
   127.0.0.1:6379> MSETNX rmdbs "MySQL" nosql "MongoDB" key-value-store "redis"
   (integer) 1
   127.0.0.1:6379> MGET rmdbs nosql key-value-store
   1) "MySQL"
   2) "MongoDB"
   3) "redis"
对某个已经存在的键进行设置：
   127.0.0.1:6379> MSETNX rmdbs "Sqlite" language "python"  #rmdbs键已经存在，操作失败
   (integer) 0
   127.0.0.1:6379> EXISTS language                          #因为MSETNX命令没有执行成功，所以language键没有被设置
   (integer) 0
   127.0.0.1:6379> GET rmdbs                                #rmdbs键也没有被设置
   "MySQL"
 
MGET key [key …]

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

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

返回值

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

代码示例
   127.0.0.1:6379> SET redis redis.com
   OK
   127.0.0.1:6379> SET mongodb mongodb.org
   OK
   127.0.0.1:6379> MGET redis mongodb
   1) "redis.com"
   2) "mongodb.org"
   127.0.0.1:6379> MGET redis mongodb mysql  #不存在的mysql 返回nil
   1) "redis.com"
   2) "mongodb.org"
   3) (nil)

2.4 Redis 哈希(Hash)

HSET hash field value

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

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

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

返回值

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

代码示例
设置一个新域： 

   127.0.0.1:6379> HSET website google "www.g.cn"
   (integer) 1
   127.0.0.1:6379> HGET website google
   "www.g.cn"

对一个已存在的域进行更新：

   127.0.0.1:6379> HSET website google "www.google.com"
   (integer) 0
   127.0.0.1:6379> HGET website google
   "www.google.com"

HSETNX hash field value

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

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

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

返回值

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

代码示例
域尚未存在， 设置成功：
   127.0.0.1:6379> HSETNX database key-value-store Redis
   (integer) 1
   127.0.0.1:6379> HGET database key-value-store
   "Redis"

域已经存在， 设置未成功， 域原有的值未被改变：

   127.0.0.1:6379> HSETNX database key-value-store Riak
   (integer) 0
   127.0.0.1:6379> HGET database key-value-store
   "Redis"

HGET hash field

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

返回值
HGET 命令在默认情况下返回给定域的值。
如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil 。
代码示例
域存在的情况：
   127.0.0.1:6379> HSET homepage redis redis.com
   (integer) 1
   127.0.0.1:6379> HGET homepage redis
   "redis.com"
域不存在的情况：
   127.0.0.1:6379> HGET site mysql
   (nil)

HEXISTS hash field

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

返回值

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

代码示例
给定域不存在：
   127.0.0.1:6379> HEXISTS phone myphone
   (integer) 0
给定域存在：
   127.0.0.1:6379> HSET phone myphone nokia-1110
   (integer) 1
   127.0.0.1:6379> HEXISTS phone myphone
   (integer) 1

HDEL key field [foeld ...]
删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
注意:
  在Redis2.4以下的版本里， HDEL 每次只能删除单个域，如果你需要在一个原子时间内删除多个域，请将命令包含在 MULTI / EXEC 块内。
返回值:
   被成功移除的域的数量，不包括被忽略的域。
代码示例:
   127.0.0.1:6379> HMSET abbr a apple b banana c cat d dog
   OK
   127.0.0.1:6379> HGETALL abbr
   1) "a"
   2) "apple"
   3) "b"
   4) "banana"
   5) "c"
   6) "cat"
   7) "d"
   8) "dog"
   127.0.0.1:6379> HDEL abbr a
   (integer) 1
   127.0.0.1:6379> HDEL abbr not-exists-field
   (integer) 0
   127.0.0.1:6379> HDEL abbr b c
   (integer) 2
   127.0.0.1:6379> HGETALL abbr
   1) "d"
   2) "dog"

HLEN key
返回哈希表 key 中域的数量。
返回值:
哈希表中域的数量。
当 key 不存在时，返回 0 。
 

代码示例:
   127.0.0.1:6379> HSET db redis redis.com
   (integer) 1
   127.0.0.1:6379> HSET db mysql mysql.com
   (integer) 1
   127.0.0.1:6379> HLEN db
   (integer) 2
   127.0.0.1:6379> HSET db mongodb mongodb.org
   (integer) 1
   127.0.0.1:6379> HLEN db
   (integer) 3




 

HSTRLEN key field
返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）。
如果给定的键或者域不存在， 那么命令返回 0 。
返回值:
一个整数。
代码示例:
   127.0.0.1:6379> HMSET myhash f1 "HelloWorld" f2 "99" f3 "-256"
   OK
   127.0.0.1:6379> HSTRLEN myhash f1
   (integer) 10
   127.0.0.1:6379> HSTRLEN myhash f2
   (integer) 2
   127.0.0.1:6379> HSTRLEN myhash f3
   (integer) 4

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




代码示例:
   #increment 为正数
   127.0.0.1:6379> HEXISTS counter page_view
   (integer) 0
   127.0.0.1:6379> HINCRBY counter page_view 200
   (integer) 200
   127.0.0.1:6379> HGET counter page_view
   "200"
   #increment 为负数

   127.0.0.1:6379> HGET counter page_view
   "200"
   127.0.0.1:6379> HINCRBY counter page_view -50
   (integer) 150
   127.0.0.1:6379> HGET counter page_view
   "150"

 #尝试对字符串值的域执行 HINCRBY 命令

   127.0.0.1:6379> HSET myhash string hello,world  #设定一个字符串值
   (integer) 1
   127.0.0.1:6379> HGET myhash string
   "hello,world"
   127.0.0.1:6379> HINCRBY myhash string 1         #命令执行失败 报错
   (error) ERR hash value is not an integer
   127.0.0.1:6379> HGET myhash string              #原值不变
   "hello,world"

HINCRBYFLOAT key field increment

为哈希表 key 中的域 field 加上浮点数增量 increment 。

如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。

如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。

当以下任意一个条件发生时，返回一个错误：

• 域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
• 域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number)

返回值:

执行加法操作之后 field 域的值。

代码示例:

   #值和增量都是普通小数

   127.0.0.1:6379> HSET mykey field 10.50
   (integer) 1
   127.0.0.1:6379> HINCRBYFLOAT mykey field 0.1
   "10.6"

 #值和增量都是指数小数

   127.0.0.1:6379> HSET mykey field 5.0e3
   (integer) 0
   127.0.0.1:6379> HINCRBYFLOAT mykey field 2.0e2
   "5200"

 #对不存在的键执行 HINCRBYFLOAT

   127.0.0.1:6379> EXISTS price
   (integer) 0
   127.0.0.1:6379> HINCRBYFLOAT price milk 3.5
   "3.5"
   127.0.0.1:6379> HGETALL price
   1) "milk"
   2) "3.5"

 #对不存在的域执行 HINCRBYFLOAT

   127.0.0.1:6379> HGETALL price
   1) "milk"
   2) "3.5"
   127.0.0.1:6379> HINCRBYFLOAT price coffee 4.5  #新增coffee域
   "4.5"
   127.0.0.1:6379> HGETALL price
   1) "milk"
   2) "3.5"
   3) "coffee"
   4) "4.5"

HMSET key field value [field value …]

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

此命令会覆盖哈希表中已存在的域。

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

返回值:

如果命令执行成功，返回 OK 。

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

代码示例:
   127.0.0.1:6379> HMSET website google www.google.com yahoo www.yahoo.com
   OK
   127.0.0.1:6379> HGET website google
   "www.google.com"
   127.0.0.1:6379> HGET website yahoo
   "www.yahoo.com"

   127.0.0.1:6379> type book
   string

   127.0.0.1:6379> HMSET book OS linux lang PHP
   (error) WRONGTYPE Operation against a key holding the wrong kind of value

HMGET key field [field …]

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

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

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

返回值:

一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

代码示例:

   127.0.0.1:6379> HMSET pet dog "doudou" cat "nounou" #一次设置多个域
   OK
   127.0.0.1:6379> HMGET pet dog cat fake_pet          #返回值的顺序和传入参数的顺序一致
   1) "doudou"
   2) "nounou"
   3) (nil)                                            #不存在的域返回nil值

HKEYS key

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

返回值:

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

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

 

代码示例:
   #哈希表非空
   127.0.0.1:6379> HMSET website google www.google.com yahoo www.yahoo.com
   OK
   127.0.0.1:6379> HKEYS website
   1) "google"
   2) "yahoo"

   #哈希表 / key 不存在

   127.0.0.1:6379> EXISTS fake_key
   (integer) 0
   127.0.0.1:6379> HKEYS fake_key
   (empty list or set)

HVALS key

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

返回值:

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

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

代码示例:

   #非空哈希表

   127.0.0.1:6379> HMSET website google www.google.com yahoo www.yahoo.com
   OK
   127.0.0.1:6379> HVALS website
   1) "www.google.com"
   2) "www.yahoo.com"

   #空哈希表 / 不存在的key

   127.0.0.1:6379> EXISTS not_exists
   (integer) 0
   127.0.0.1:6379> HVALS not_exists
   (empty list or set)

HGETALL key

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

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

返回值:

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

若 key 不存在，返回空列表。

代码示例:
   127.0.0.1:6379> HSET people jack "Jack Sparrow"
   (integer) 1
   127.0.0.1:6379> HSET people gump "Forrest Gump"
   (integer) 1
   127.0.0.1:6379> HGETALL people
   1) "jack"          #值
   2) "Jack Sparrow"  #域
   3) "gump"
   4) "Forrest Gump"

HSCAN key cursor [MATCH pattern] [COUNT count]

SCAN命令是一个基于游标的迭代器, 这意味着命令每次被调用都需要使用上一次这个调用返回的游标作为该次调用的游标参数，以此来延续之前的迭代过程, 当SCAN命令的游标参数被设置为 0 时， 服务器将开始一次新的迭代， 而当服务器向用户返回值为 0 的游标时， 表示迭代已结束，HSCAN同SCAN命令相同。

代码示例:

   127.0.0.1:6379> HMSET pms stock 12 freeze 10 stock:1 11 stock:2 12 stock:3 13 stock:freeze:1 111
   OK
   127.0.0.1:6379> hgetall pms
   1) "stock"
   2) "12"
   3) "freeze"
   4) "10"
   5) "stock:1"
   6) "11"
   7) "stock:2"
   8) "12"
   9) "stock:3"
   10) "13"
   11) "stock:freeze:1"
   12) "111"

   #模糊查看pms下包含stock:的所有键
   127.0.0.1:6379> HSCAN pms 0 MATCH stock:* COUNT 100
   1) "0"
   2) 1) "stock:1"
      2) "11"
      3) "stock:2"
      4) "12"
      5) "stock:3"
      6) "13"
      7) "stock:freeze:1"
      8) "111"

   #模糊查看pms下包含stock的所有键
   127.0.0.1:6379> HSCAN pms 0 MATCH stock* COUNT 100
   1) "0"
   2) 1) "stock"
      2) "12"
      3) "stock:1"
      4) "11"
      5) "stock:2"
      6) "12"
      7) "stock:3"
      8) "13"
      9) "stock:freeze:1"
      10) "111"

   #模糊查看pms下包含stock:freeze的所有键
   127.0.0.1:6379> HSCAN pms 0 MATCH stock:freeze* COUNT 100
   1) "0"
   2) 1) "stock:freeze:1"
      2) "111"

2.5 Redis 列表(List)

LPUSH key value [value …]

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

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

比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。

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

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

注意:

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

返回值

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

代码示例

   #添加单个元素

   127.0.0.1:6379> LPUSH languages python
   (integer) 1

   #添加重复元素
   127.0.0.1:6379> LPUSH languages python
   (integer) 2
   127.0.0.1:6379> LRANGE languages 0 -1
   1) "python"
   2) "python"

   #添加多个元素

   127.0.0.1:6379> LPUSH mylist a b c
   (integer) 3
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "c"
   2) "b"
   3) "a"

LPUSHX key value

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

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

返回值

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

代码示例

   #对空列表执行

   127.0.0.1:6379> LLEN greet                     #greet是一个空列表
   (integer) 0
   127.0.0.1:6379> LPUSHX greet "hello"           #尝试LPUSHX失败，因为列表为空
   (integer) 0

   #对非空列表执行LPUSHX
   127.0.0.1:6379> LPUSH greet "hello"            #先用LPUSH创建一个有一个元素的列表
   (integer) 1
   127.0.0.1:6379> LPUSHX greet "good morning"    #这次LPUSHX执行成功
   (integer) 2
   127.0.0.1:6379> LRANGE greet 0 -1
   1) "good morning"
   2) "hello"

RPUSH key value [value …]

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

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

比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a、 RPUSH mylist b 、 RPUSH mylist c 。

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

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

注意：

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

返回值
执行 RPUSH 操作后，表的长度。
代码示例
   #添加单个元素
   127.0.0.1:6379> RPUSH languages c
   (integer) 1
   #添加重复元素
   127.0.0.1:6379> RPUSH languages c
   (integer) 2
   127.0.0.1:6379> LRANGE languages 0 -1   #列表允许重复元素
   1) "c"
   2) "c"
   #添加多个元素
   127.0.0.1:6379> RPUSH mylist a b c
   (integer) 3
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "a"
   2) "b"
   3) "c"

LPOP key
移除并返回列表 key 的头元素。
返回值
列表的头元素。 当 key 不存在时，返回 nil 。
代码示例
   127.0.0.1:6379> LLEN course
   (integer) 0
   127.0.0.1:6379> RPUSH course algorithm001
   (integer) 1
   127.0.0.1:6379> RPUSH course c++101
   (integer) 2
   127.0.0.1:6379> LRANGE course 0 -1
   1) "algorithm001"
   2) "c++101"
   127.0.0.1:6379> LPOP course
   "algorithm001"
   127.0.0.1:6379> LRANGE course 0 -1
   1) "c++101"

 

RPOP key
移除并返回列表 key 的尾元素。
返回值
列表的尾元素。 当 key 不存在时，返回 nil 。
代码示例
   127.0.0.1:6379> RPUSH mylist "one"
   (integer) 1
   127.0.0.1:6379> RPUSH mylist "two"
   (integer) 2
   127.0.0.1:6379> RPUSH mylist "three"
   (integer) 3
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "one"
   2) "two"
   3) "three"
   127.0.0.1:6379> RPOP mylist
   "three"
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "one"
   2) "two"

RPOPLPUSH source destination
命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。



例子:
 你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。
如果 source 不存在，值 nil 被返回，并且不执行其他动作。
如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。
返回值
被弹出的元素。
代码示例
   #source 和 destination 不同
   127.0.0.1:6379> RPUSH alpha a
   (integer) 1
   127.0.0.1:6379> RPUSH alpha b
   (integer) 2
   127.0.0.1:6379> RPUSH alpha c
   (integer) 3
   127.0.0.1:6379> RPUSH alpha d
   (integer) 4
   127.0.0.1:6379> LRANGE alpha 0 -1           #查看所有元素
   1) "a"
   2) "b"
   3) "c"
   4) "d"
   127.0.0.1:6379> RPOPLPUSH alpha reciver     #执行一次RPOPLPUSH看看
   "d"
   127.0.0.1:6379> LRANGE alpha 0 -1
   1) "a"
   2) "b"
   3) "c"
   127.0.0.1:6379> LRANGE reciver 0 -1
   1) "d"
   127.0.0.1:6379> RPOPLPUSH alpha reciver     #再执行一次RPOPLPUSH看看
   "c"
   127.0.0.1:6379> LRANGE alpha 0 -1
   1) "a"
   2) "b"
   127.0.0.1:6379> LRANGE reciver 0 -1
   1) "c"
   2) "d"
   #source 和 destination 相同
   127.0.0.1:6379> RPUSH number 1
   (integer) 1
   127.0.0.1:6379> RPUSH number 2
   (integer) 2
   127.0.0.1:6379> RPUSH number 3
   (integer) 3
   127.0.0.1:6379> RPUSH number 4
   (integer) 4
   127.0.0.1:6379> LRANGE number 0 -1
   1) "1"
   2) "2"
   3) "3"
   4) "4"
   127.0.0.1:6379> RPOPLPUSH number number
   "4"
   127.0.0.1:6379> LRANGE number 0 -1       #4被旋转到了表头
   1) "4"
   2) "1"
   3) "2"
   4) "3"
   127.0.0.1:6379> RPOPLPUSH number number
   "3"
   127.0.0.1:6379> LRANGE number 0 -1       #3被旋转到了表头
   1) "3"
   2) "4"
   3) "1"
   4) "2"

LREM key count value
根据参数 count 的值，移除列表中与参数 value 相等的元素。
count 的值可以是以下几种：

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



返回值
被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时，LREM 命令总是返回 0 。
代码示例
   127.0.0.1:6379> LPUSH greet "morning"
   (integer) 1
   127.0.0.1:6379> LPUSH greet "hello"
   (integer) 2
   127.0.0.1:6379> LPUSH greet "morning"
   (integer) 3
   127.0.0.1:6379> LPUSH greet "hello"
   (integer) 4
   127.0.0.1:6379> LPUSH greet "morning"
   (integer) 5
   127.0.0.1:6379> LRANGE greet 0 4
   1) "morning"
   2) "hello"
   3) "morning"
   4) "hello"
   5) "morning"
   127.0.0.1:6379> LREM greet 2 morning
   (integer) 2
   127.0.0.1:6379> LLEN greet
   (integer) 3
   127.0.0.1:6379> LRANGE greet 0 2
   1) "hello"
   2) "hello"
   3) "morning"
   127.0.0.1:6379> LREM greet -1 morning
   (integer) 1
   127.0.0.1:6379> LLEN greet
   (integer) 2
   127.0.0.1:6379> LRANGE greet 0 1
   1) "hello"
   2) "hello"
   127.0.0.1:6379> LREM greet 0 hello
   (integer) 2
   127.0.0.1:6379> LLEN greet
   (integer) 0

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

返回值
列表 key 的长度。



代码示例
   #空列表
   127.0.0.1:6379> LLEN job
   (integer) 0


   #非空列表
   127.0.0.1:6379> LPUSH job "cook food"
   (integer) 1
   127.0.0.1:6379> LPUSH job "have lunch"
   (integer) 2
   127.0.0.1:6379> LLEN job
   (integer) 2

LINDEX key index
返回列表 key 中，下标为 index 的元素。
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
如果 key 不是列表类型，返回一个错误。
返回值
列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。
代码示例
   127.0.0.1:6379> LPUSH mylist "World"
   (integer) 1
   127.0.0.1:6379> LPUSH mylist "Hello"
   (integer) 2
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "Hello"
   2) "World"
   127.0.0.1:6379> LINDEX mylist 0
   "Hello"
   127.0.0.1:6379> LINDEX mylist -1
   "World"
   127.0.0.1:6379> LINDEX mylist 3
   (nil)

 
LINSERT key BEFORE|AFTER pivot value
将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
当 pivot 不存在于列表 key 时，不执行任何操作。
当 key 不存在时， key 被视为空列表，不执行任何操作。
如果 key 不是列表类型，返回一个错误。

返回值
如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0 。
代码示例
   127.0.0.1:6379> RPUSH mylist "Hello"
   (integer) 1
   127.0.0.1:6379> RPUSH mylist "World"
   (integer) 2
   127.0.0.1:6379> LINSERT mylist BEFORE "World" "There"
   (integer) 3
   127.0.0.1:6379> LRANGE mylist 0 -1
   1) "Hello"
   2) "There"
   3) "World"
   #对一个非空列表插入，查找一个不存在的pivot
   127.0.0.1:6379> LINSERT mylist BEFORE "go" "let's"
   (integer) -1                                          #失败
   #对一个空列表执行LINSERT
   127.0.0.1:6379> EXISTS fake_list
   (integer) 0
   127.0.0.1:6379> LINSERT fake_list BEFORE "nono" "gogogog"
   (integer) 0                                          #失败

LSET key index value
将列表 key 下标为 index 的元素的值设置为 value 。
当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
返回值
操作成功返回 ok ，否则返回错误信息。
代码示例
   #对空列表(key 不存在)执行LSET
   127.0.0.1:6379> EXISTS list
   (integer) 0
   127.0.0.1:6379> LSET list 0 item
   (error) ERR no such key
   #对非空列表执行LSET
   127.0.0.1:6379> LPUSH job "cook food"
   (integer) 1
   127.0.0.1:6379> LRANGE job 0 0
   1) "cook food"
   127.0.0.1:6379> LSET job 0 "play game"
   OK
   127.0.0.1:6379> LRANGE job 0 0
   1) "play game"
   #index超出范围
   127.0.0.1:6379> LLEN job
   (integer) 1
   127.0.0.1:6379> LSET list 3 'out of range'
   (error) ERR no such key

LRANGE key start stop
返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

超出范围的下标
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。


返回值
一个列表，包含指定区间内的元素。
代码示例
   127.0.0.1:6379> RPUSH fp-language lisp
   (integer) 1
   127.0.0.1:6379> LRANGE fp-language 0 0
   1) "lisp"
   127.0.0.1:6379> RPUSH fp-language scheme
   (integer) 2
   127.0.0.1:6379> LRANGE fp-language 0 1
   1) "lisp"
   2) "scheme"
   #start大于end
   127.0.0.1:6379> LLEN fp-language
   (integer) 2
   127.0.0.1:6379> LRANGE fp-language 10 15
   (empty list or set)
   #stop 大于 end
   127.0.0.1:6379> LRANGE fp-language 0 8
   1) "lisp"
   2) "scheme"

LTRIM key start stop
对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1表示列表的第二个元素，以此类推。
你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
当 key 不是列表类型时，返回一个错误。

超出范围的下标
超出范围的下标值不会引起错误。
如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。
如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。



返回值
命令执行成功时，返回 ok 。



代码示例
   #情况1：start和stop都在列表的索引范围之内
   127.0.0.1:6379> RPUSH alpha h e l l o
   (integer) 5
   127.0.0.1:6379> LRANGE alpha 0 -1      #alpha是一个包含5个字符串的列表
   1) "h"
   2) "e"
   3) "l"
   4) "l"
   5) "o"
   127.0.0.1:6379> LTRIM alpha 1 -1       #删除alpha列表索引为0的元素
   OK
   127.0.0.1:6379> LRANGE alpha 0 -1      #'h'被删除了
   1) "e"
   2) "l"
   3) "l"
   4) "o"
 
   #情况2：stop比列表的最大下标还要大

   127.0.0.1:6379> LTRIM alpha 1 10086   #保留alpha列表索引 1 至索引10086 上得元素
   OK
   127.0.0.1:6379> LRANGE alpha 0 -1     #只有索引0上的元素'e' 被删除了，其他元素还在
   1) "l"
   2) "l"
   3) "o"

   #情况3：start比stop都比列表的最大下标还大，并且 start < stop

   127.0.0.1:6379> LTRIM alpha 10086 123321   
   OK
   127.0.0.1:6379> LRANGE alpha 0 -1         #列表被清空
   (empty list or set)


   #情况4: start比stop都比列表的最大下标还大，并且 start > stop 

   127.0.0.1:6379> RPUSH new-alpha "h" "e" "l" "l" "o"
   (integer) 5
   127.0.0.1:6379> LRANGE new-alpha 0 -1
   1) "h"
   2) "e"
   3) "l"
   4) "l"
   5) "o"
   127.0.0.1:6379> LTRIM new-alpha 123321 10086
   OK
   127.0.0.1:6379> LRANGE new-alpha 0 -1     #同样被清空
   (empty list or set)


 

BLPOP key [key …] timeout
BLPOP 是列表的阻塞式(blocking)弹出原语。
它是 LPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。
返回值
如果列表为空，返回一个 nil 。 否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。

非阻塞行为
当 BLPOP  被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
当存在多个给定 key 时， BLPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。
假设现在有 job 、 command 和 request 三个列表，其中 job 不存在， command 和 request 都持有非空列表。考虑以下命令：
BLPOP job command request 0
BLPOP 保证返回的元素来自 command ，因为它是按”查找 job -> 查找 command -> 查找 request“这样的顺序，第一个找到的非空列表。
代码示例
   127.0.0.1:6379> DEL job command request              #确保key都被删除
   (integer) 1
   127.0.0.1:6379> LPUSH command "update system..."     #为command列表增加一个值
   (integer) 1
   127.0.0.1:6379> LPUSH request "visit page"           #为request列表增加一个值
   (integer) 1
   127.0.0.1:6379> BLPOP job command request 0          #job列表为空被跳过，紧接着command列表的第一个元素被弹出
   1) "command"                                         #弹出元素所属的列表
   2) "update system..."                                #弹出元素所属的值
阻塞行为
如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。
超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。
代码示例
   127.0.0.1:6379> DEL job command        #确保两个key都不存在
   (integer) 0
   127.0.0.1:6379> BLPOP job command 300  #因为key都不存在，所以操作会被阻塞，直到另一客户端对job或command列表进行LPUSH或RPUSH操作
   1) "job"                               #这里被PUSH的是job
   2) "do my home work"                   #被弹出的值
   (28.34s)                               #等待的秒数
   #等待超时的情况
   127.0.0.1:6379> BLPOP job command 5
   (nil)
   (5.03s)                                #等待的秒数
相同的key被多个客户端同时阻塞
相同的 key 可以被多个客户端同时阻塞。
不同的客户端被放进一个队列中，按『先阻塞先服务』(first-BLPOP，first-served)的顺序为 key执行 BLPOP 命令。


在MULTI/EXEC事务中的BLPOP
BLPOP 可以用于流水线(pipline,批量地发送多个命令并读入多个回复)，但把它用在 MULTI / EXEC 块当中没有意义。因为这要求整个服务器被阻塞以保证块执行时的原子性，该行为阻止了其他客户端执行 LPUSH 或 RPUSH 命令。
因此，一个被包裹在 MULTI / EXEC 块内的 BLPOP 命令，行为表现得就像 LPOP key  一样，对空列表返回 nil ，对非空列表弹出列表元素，不进行任何阻塞操作。
代码示例
   #对非空列表进行操作
   127.0.0.1:6379> RPUSH job programming
   (integer) 1
   127.0.0.1:6379> MULTI
   OK
   127.0.0.1:6379> BLPOP job 30
   QUEUED
   127.0.0.1:6379> EXEC                  #不阻塞立即返回
   1) 1) "job"
      2) "programming"

   #对空列表进行操作

   127.0.0.1:6379> LLEN job
   (integer) 0
   127.0.0.1:6379> MULTI
   OK
   127.0.0.1:6379> BLPOP job 30
   QUEUED
   127.0.0.1:6379> EXEC
   1) (nil)                             #不阻塞立即返回

 



BRPOP key [key …] timeout





BRPOP 是列表的阻塞式(blocking)弹出原语。
它是 RPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
返回值

假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
代码示例
   127.0.0.1:6379> LLEN course
   (integer) 1
   127.0.0.1:6379> RPUSH course algorithm001
   (integer) 2
   127.0.0.1:6379> RPUSH course c++101
   (integer) 3
   127.0.0.1:6379> BRPOP course 30
   1) "course"                                #被弹出元素所属的列表键
   2) "c++101"                                #被弹出元素

BRPOPLPUSH source destination timeout
BRPOPLPUSH 是  RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。
当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。
超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

返回值
假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。 反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。
代码示例
   #非空列表
   127.0.0.1:6379> BRPOPLPUSH msg reciver 500
   "hello moto"
   (126.86s)
   127.0.0.1:6379> LRANGE reciver 0 -1
   1) "hello moto"


   #空列表

   127.0.0.1:6379> BRPOPLPUSH msg reciver 1
   (nil)
   (1.10s)

2.6 Redis 集合(Set)

SADD key member [member …]

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

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

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

注意:

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

返回值

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

代码示例

   #添加单个元素

   127.0.0.1:6379> SADD bbs "discuz.net"
   (integer) 1

   #添加重复元素
   127.0.0.1:6379> SADD bbs "discuz.net"
   (integer) 0

   #添加多个元素
   127.0.0.1:6379> SADD bbs "tianya.cn" "groups.google.com"
   (integer) 2
   127.0.0.1:6379> SMEMBERS bbs
   1) "tianya.cn"
   2) "groups.google.com"
   3) "discuz.net"

SISMEMBER key member

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

返回值

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

代码示例
   127.0.0.1:6379> SMEMBERS bbs
   1) "tianya.cn"
   2) "groups.google.com"
   3) "discuz.net"
   127.0.0.1:6379> SISMEMBER bbs 'baidu.com'
   (integer) 0
   127.0.0.1:6379> SISMEMBER bbs 'discuz.net'
   (integer) 1

SPOP key

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

如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER key [count] 命令。

返回值

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

代码示例

   127.0.0.1:6379> SADD db MySQL MongoDB Redis
   (integer) 3
   127.0.0.1:6379> SMEMBERS db
   1) "MongoDB"
   2) "Redis"
   3) "MySQL"
   127.0.0.1:6379> SPOP db
   "Redis"
   127.0.0.1:6379> SMEMBERS db
   1) "MongoDB"
   2) "MySQL"
   127.0.0.1:6379> SPOP db
   "MySQL"
   127.0.0.1:6379> SMEMBERS db
   1) "MongoDB"

SRANDMEMBER key [count]

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

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

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

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

返回值

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

代码示例

   #添加元素

   127.0.0.1:6379> SADD fruit apple banana cherry
   (integer) 3

   #只给定key参数，随机返回一个元素

   127.0.0.1:6379> SRANDMEMBER fruit
   "banana"

   127.0.0.1:6379> SRANDMEMBER fruit
   "apple"

   #给定count参数为3，返回3个随机元素，每个随机元素都不相同

   127.0.0.1:6379> SRANDMEMBER fruit 3
   1) "apple"
   2) "cherry"
   3) "banana"

   #给定count参数为-3，返回3个随机元素，元素可能会重复出现多次

   127.0.0.1:6379> SRANDMEMBER fruit -3
   1) "banana"
   2) "apple"
   3) "banana"

   127.0.0.1:6379> SRANDMEMBER fruit -3
   1) "apple"
   2) "banana"
   3) "banana"

   #如果count是整数且大于整个集合基数，那么返回整个集合

   127.0.0.1:6379> SRANDMEMBER fruit 10
   1) "apple"
   2) "cherry"
   3) "banana"

   #如果count是负数且count的绝对值大于整个集合的基数，那么返回数组的长度为count的绝对值

   127.0.0.1:6379> SRANDMEMBER fruit -10
   1) "banana"
   2) "cherry"
   3) "banana"
   4) "apple"
   5) "apple"
   6) "apple"
   7) "banana"
   8) "apple"
   9) "banana"
   10) "banana"

   #SRANDMEMBER并不会修改集合内容

   127.0.0.1:6379> SMEMBERS fruit
   1) "cherry"
   2) "apple"
   3) "banana"

   #集合为空时，返回nil或者空数组

   127.0.0.1:6379> SRANDMEMBER not-exists
   (nil)
   127.0.0.1:6379> SRANDMEMBER not-eixsts 10
   (empty list or set)

SREM key member [member …]

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

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

注意:

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

返回值

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

代码示例
   #添加测试数据
   127.0.0.1:6379> SADD languages c python ruby php java
   (integer) 5
   #删除单个元素
   127.0.0.1:6379> SREM languages ruby
   (integer) 1
   127.0.0.1:6379> SMEMBERS languages
   1) "php"
   2) "c"
   3) "python"
   4) "java"
   #删除不存在的元素
   127.0.0.1:6379> SREM languages non-exists-language
   (integer) 0
   #删除多个元素
   127.0.0.1:6379> SREM languages c python java
   (integer) 3
   127.0.0.1:6379> SMEMBERS languages
   1) "php"

SMOVE source destination member

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

SMOVE 是原子性操作。

如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。

当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

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

返回值

如果 member 元素被成功移除，返回 1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

代码示例

   127.0.0.1:6379> SADD songs "Billie Jean" "Believe Me"
   (integer) 2
   127.0.0.1:6379> SMEMBERS my_songs
   (empty list or set)
   127.0.0.1:6379> SMOVE songs my_songs "Believe Me"
   (integer) 1
   127.0.0.1:6379> SMEMBERS songs
   1) "Billie Jean"
   127.0.0.1:6379> SMEMBERS my_songs
   1) "Believe Me"

SCARD key

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

返回值

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

代码示例

   127.0.0.1:6379> SADD tool pc printer phone
   (integer) 3
   127.0.0.1:6379> SCARD tool
   (integer) 3
   127.0.0.1:6379> SPOP tool
   "phone"
   127.0.0.1:6379> SCARD tool
   (integer) 2
   127.0.0.1:6379> DEL tool
   (integer) 1
   127.0.0.1:6379> SCARD tool
   (integer) 0

SMEMBERS key

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

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

返回值

集合中的所有成员。

代码示例

   #key 不存在

   127.0.0.1:6379> EXISTS not_exists_key
   (integer) 0

   #key集合为空
   127.0.0.1:6379> SMEMBERS not_exists_key
   (empty list or set)

   #非空集合
   127.0.0.1:6379> SADD language Ruby Python Clojure
   (integer) 3
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"

SSCAN key cursor [MATCH pattern] [COUNT count]

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

SINTER key [key …]

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

不存在的 key 被视为空集。

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

返回值

交集成员的列表。

代码示例

   127.0.0.1:6379> SADD lang-1 Php Java Python
   (integer) 3
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SINTER language lang-1
   1) "Python"
   127.0.0.1:6379> SINTER language lang-2
   (empty list or set)
   127.0.0.1:6379> SINTER  lang-2 language
   (empty list or set)

SINTERSTORE destination key [key …]

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

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

destination 可以是 key 本身。

返回值

结果集中的成员数量。

代码示例

   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SINTERSTORE new-lang lang-1  language
   (integer) 1
   127.0.0.1:6379> SINTERSTORE new-lang lang-1 not-exists-language    #不存在的集合执行SINTERSTORE
   (integer) 0
   127.0.0.1:6379> SMEMBERS language                                  #不影响原始数据
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1                                    #不影响原始数据
   1) "Java"
   2) "Php"
   3) "Python"

 

SUNION key [key …]
返回一个集合的全部成员，该集合是所有给定集合的并集。
不存在的 key 被视为空集。

返回值
并集成员的列表。


代码示例
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SUNION language lang-1
   1) "Ruby"
   2) "Python"
   3) "Clojure"
   4) "Java"
   5) "Php"
   127.0.0.1:6379> SUNION  lang-1 language
   1) "Php"
   2) "Python"
   3) "Java"
   4) "Clojure"
   5) "Ruby"

SUNIONSTORE destination key [key …]

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

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

destination 可以是 key 本身。

返回值

结果集中的元素数量。

代码示例
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SUNIONSTORE new-lang language lang-1
   (integer) 5
   127.0.0.1:6379> SMEMBERS new-lang
   1) "Ruby"
   2) "Python"
   3) "Clojure"
   4) "Java"
   5) "Php"
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"

SDIFF key [key …]
返回一个集合的全部成员，该集合是所有给定集合之间的差集。
不存在的 key 被视为空集。

返回值
一个包含差集成员的列表。


代码示例
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SDIFF language lang-1
   1) "Clojure"
   2) "Ruby"

SDIFFSTORE destination key [key …]
这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
如果 destination 集合已经存在，则将其覆盖。
destination 可以是 key 本身。

返回值
结果集中的元素数量。


代码示例
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"
   127.0.0.1:6379> SDIFFSTORE new-lang language lang-1
   (integer) 2
   127.0.0.1:6379> SMEMBERS new-lang
   1) "Clojure"
   2) "Ruby"
   127.0.0.1:6379> SMEMBERS language
   1) "Clojure"
   2) "Ruby"
   3) "Python"
   127.0.0.1:6379> SMEMBERS lang-1
   1) "Java"
   2) "Php"
   3) "Python"

2.7 Redis 有序集合(Zset,sorted set)

ZADD key score member [[score member] [score member] …]

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

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

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

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

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

注意:

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

返回值

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

代码示例

   #添加单个元素

   127.0.0.1:6379> ZADD page_rank 10 google.com
   (integer) 1

   #添加多个元素
   127.0.0.1:6379> ZADD page_rank 9 baidu.com 8 bing.com
   (integer) 2

   #显示整个有序集合成员
   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"

 #添加已存在元素且score值不变

   127.0.0.1:6379> ZADD page_rank 10 google.com
   (integer) 0
   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"

 #添加已存在元素改变score值

   127.0.0.1:6379> ZADD page_rank 6 bing.com
   (integer) 0
   127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
   1) "bing.com"
   2) "6"
   3) "baidu.com"
   4) "9"
   5) "google.com"
   6) "10"

ZSCORE key member

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

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

返回值

member 成员的 score 值，以字符串形式表示。

代码示例
   127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
   1) "bing.com"
   2) "6"
   3) "baidu.com"
   4) "9"
   5) "google.com"
   6) "10"
   127.0.0.1:6379> ZSCORE page_rank bing.com
   "6"

ZINCRBY key increment member

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

可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。

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

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

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

返回值

member 成员的新 score 值，以字符串形式表示。

代码示例

   127.0.0.1:6379> ZSCORE salary tom
   "2000"
   127.0.0.1:6379> ZINCRBY salary 2000 tom
   "4000"

   127.0.0.1:6379> ZINCRBY salary -500 tom
   "3500"
   127.0.0.1:6379> ZSCORE salary tom
   "3500"

   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "3500"

   127.0.0.1:6379> ZINCRBY salary 500 jack
   "500"
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "jack"
   2) "500"
   3) "tom"
   4) "3500"

ZCARD key

返回有序集 key 的成员数量。

返回值

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

代码示例
   127.0.0.1:6379> ZADD salary 2000 tom     #添加一个成员
   (integer) 1
   127.0.0.1:6379> ZCARD salary
   (integer) 1
   127.0.0.1:6379> ZADD salary 5000 jack    #再添加一个成员
   (integer) 1
   127.0.0.1:6379> ZCARD salary             #显示有两个成员
   (integer) 2
   127.0.0.1:6379> EXISTS non_exists_key    #对不存在的key进行ZCARD
   (integer) 0
   127.0.0.1:6379> ZCARD non_exists_key
   (integer) 0

ZCOUNT key min max
返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
返回值
score 值在 min 和 max 之间的成员的数量。
代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   127.0.0.1:6379> ZCOUNT salary 2000 5000
   (integer) 2
   127.0.0.1:6379> ZCOUNT salary 3000 5000
   (integer) 1

ZRANGE key start stop [WITHSCORES]
返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递增(从小到大)来排序。
具有相同 score 值的成员按字典序来排列。
如果你需要成员按 score 值递减(从大到小)来排列，请参考 ZREVRANGE 命令。
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 
你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时，ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。

返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。


代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "boss"
   6) "10086"
   127.0.0.1:6379> ZRANGE salary 1 2 WITHSCORES
   1) "jack"
   2) "5000"
   3) "boss"
   4) "10086"
   127.0.0.1:6379> ZRANGE salary 0 200000 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "boss"
   6) "10086"
   127.0.0.1:6379> ZRANGE salary 200000 3000000 WITHSCORES
   (empty list or set)

ZREVRANGE key start stop [WITHSCORES]
返回有序集 key 中，指定区间内的成员。
其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序排列。
除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

返回值
指定区间内，带有 score 值(可选)的有序集成员的列表。


代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "boss"
   6) "10086"
   127.0.0.1:6379> ZREVRANGE salary 0 -1 WITHSCORES
   1) "boss"
   2) "10086"
   3) "jack"
   4) "5000"
   5) "tom"
   6) "2000"

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

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

具有相同 score 值的成员按字典序来排列(该属性是有序集提供的，不需要额外的计算)。

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

可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。 该选项自 Redis 2.0 版本起可用。

区间及无限

min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score值的情况下，使用 ZRANGEBYSCORE 这类命令。

默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

举个例子：

ZRANGEBYSCORE zset (1 5   #返回所有符合条件 1 < score <= 5 的成员

ZRANGEBYSCORE zset (5 (10 #返回所有符合条件 5 < score < 10 的成员

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例

   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf                 #显示整个有序集  -inf 负无穷 +inf正无穷
   1) "tom"
   2) "jack"
   3) "peter"
   127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf WITHSCORES      #显示整个有序集及成员的score值
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZRANGEBYSCORE salary -inf 5000 WITHSCORES      #显示工资<=5000的成员
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   127.0.0.1:6379> ZRANGEBYSCORE salary (5000 400000              #显示工资>5000 且 <= 40000的成员
   1) "peter"

ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

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

具有相同 score 值的成员按字典序的逆序排列。

除了成员按 score 值递减的次序排列这一点外， ZRERVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

返回值

指定区间内，带有 score 值(可选)的有序集成员的列表。

代码示例
   127.0.0.1:6379> ZREVRANGEBYSCORE salary +inf -inf       #逆序排列所有成员
   1) "peter"
   2) "jack"
   3) "tom"
   127.0.0.1:6379> ZREVRANGEBYSCORE salary 10000 2000      #逆序排列薪水介于 10000 ~ 2000之间的成员
   1) "jack"
   2) "tom"
   127.0.0.1:6379> ZREVRANGEBYSCORE salary 1000 20000      #空集合
   (empty list or set)

ZRANK key member

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

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

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

返回值

如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES  #显示所有成员及其score值
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZRANK salary peter             #显示peter的薪水排第三
   (integer) 2

ZREVRANK key member
返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
排名以 0 为底，也就是说， score 值最大的成员排名为 0 。
使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。

返回值
如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。


代码示例

   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES   #显示所有成员及其score值
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZREVRANK salary peter           #peter的工资排第一
   (integer) 0
   127.0.0.1:6379> ZREVRANK salary tom             #tom的工资排第三
   (integer) 2

ZREM key member [member …]
移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
当 key 存在但不是有序集类型时，返回一个错误。
注意:

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

返回值
被成功移除的成员的数量，不包括被忽略的成员。
代码示例
   127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES    #显示所有成员及其score值
   1) "bing.com"
   2) "6"
   3) "baidu.com"
   4) "9"
   5) "google.com"
   6) "10"
   127.0.0.1:6379> ZREM page_rank google.com           #删除一个元素
   (integer) 1
   127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
   1) "bing.com"
   2) "6"
   3) "baidu.com"
   4) "9"
   127.0.0.1:6379> ZREM page_rank baidu.com bing.com   #删除多个元素
   (integer) 2
   127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES
   (empty list or set)
   127.0.0.1:6379> ZREM page_rank non-exists-element   #删除不存在的元素
   (integer) 0

ZREMRANGEBYRANK key start stop
移除有序集 key 中，指定排名(rank)区间内的所有成员。
区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

返回值
被移除成员的数量。


代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES      #显示所有成员及其score值
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZREMRANGEBYRANK salary 0 1        #删除下标 0~1区间内的成员
   (integer) 2
   127.0.0.1:6379> ZRANGE salary 0 -1  WITHSCORES     #只剩下一个成员了
   1) "peter"
   2) "12000"

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

返回值
被移除成员的数量。


代码示例
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZREMRANGEBYSCORE salary 1500 3500
   (integer) 1
   127.0.0.1:6379> ZRANGE salary 0 -1  WITHSCORES
   1) "jack"
   2) "5000"
   3) "peter"
   4) "12000"






 

ZRANGEBYLEX key min max [LIMIT offset count]
当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
如果有序集合里面的成员带有不同的分值， 那么命令返回的结果是未指定的（unspecified）。
命令会使用 C 语言的 memcmp() 函数， 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。
可选的 LIMIT offset count 参数用于获取指定范围内的匹配元素 （就像 SQL 中的 SELECT LIMIT offset count 语句）。 需要注意的一点是， 如果 offset 参数的值非常大的话， 那么命令在返回结果之前， 需要先遍历至 offset 所指定的位置， 这个操作会为命令加上最多 O(N) 复杂度。

如何指定范围区间
合法的 min 和 max 参数必须包含 ( 或者 [ ， 其中 ( 表示开区间（指定的值不会被包含在范围之内）， 而 [ 则表示闭区间（指定的值会被包含在范围之内）。
特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限。 因此， 向一个所有成员的分值都相同的有序集合发送命令 ZRANGEBYLEX <zset> - + ， 命令将返回有序集合中的所有元素。


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


代码示例
   #添加测试数据
   127.0.0.1:6379> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
   (integer) 7
   #查找 -负无限到c（包含c）的元素
   127.0.0.1:6379> ZRANGEBYLEX myzset - [c
   1) "a"
   2) "b"
   3) "c"
   #查找 -负无限到c（不包含c）的元素
   127.0.0.1:6379> ZRANGEBYLEX myzset - (c
   1) "a"
   2) "b"
   #查找 aaa（包含aaa）到g (不包含g)的元素
   127.0.0.1:6379> ZRANGEBYLEX myzset [aaa (g
   1) "b"
   2) "c"
   3) "d"
   4) "e"
   5) "f"

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

返回值
整数回复：指定范围内的元素数量。


代码示例
   127.0.0.1:6379> ZRANGE myzset 0 -1 WITHSCORES
   1) "a"
   2) "0"
   3) "b"
   4) "0"
   5) "c"
   6) "0"
   7) "d"
   8) "0"
   9) "e"
   10) "0"
   11) "f"
   12) "0"
   13) "g"
   14) "0"
   127.0.0.1:6379> ZLEXCOUNT myzset - +
   (integer) 7
   127.0.0.1:6379> ZLEXCOUNT myzset [b [f
   (integer) 5

ZREMRANGEBYLEX key min max
对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。
这个命令的 min 参数和 max 参数的意义和 ZRANGEBYLEX 命令的 min 参数和 max 参数的意义一样。
返回值
整数回复：被移除的元素数量。
代码示例
   127.0.0.1:6379> ZADD myzset_1 0 aaaa 0 b 0 c 0 d 0 e
   (integer) 5
   127.0.0.1:6379> ZADD myzset_1 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
   (integer) 5
   127.0.0.1:6379> ZRANGE myzset_1 0 -1
   1) "ALPHA"
   2) "aaaa"
   3) "alpha"
   4) "b"
   5) "c"
   6) "d"
   7) "e"
   8) "foo"
   9) "zap"
   10) "zip"
   127.0.0.1:6379> ZREMRANGEBYLEX myzset_1 [alpha [omega
   (integer) 6
   127.0.0.1:6379> ZRANGE myzset_1 0 -1
   1) "ALPHA"
   2) "aaaa"
   3) "zap"
   4) "zip"

ZSCAN key cursor [MATCH pattern] [COUNT count]
命令用于迭代有序集合中的元素（包括元素成员和元素分值）。

ZUNIONSTORE destination numkeys key [key …] [WEIGHTS weight [weight …]] [AGGREGATE SUM|MIN|MAX]
计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和 。
WEIGHTS
使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子，每个给定有序集的所有成员的 score 值在传递给聚合函数之前都要先乘以该有序集的因子。
如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
AGGREGATE
使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。
默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之和 作为结果集中该成员的 score 值；
使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；
而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
返回值
保存到 destination 的结果集的基数。
代码示例
   127.0.0.1:6379> ZRANGE programmer 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   127.0.0.1:6379> ZRANGE manager 0 -1 WITHSCORES
   1) "herry"
   2) "5000"
   3) "mary"
   4) "6000"
   5) "bob"
   6) "21000"
   127.0.0.1:6379> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3     #公司决定加薪 除了程序员
   (integer) 6
   127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES
   1) "tom"
   2) "2000"
   3) "jack"
   4) "5000"
   5) "peter"
   6) "12000"
   7) "herry"
   8) "15000"
   9) "mary"
   10) "18000"
   11) "bob"
   12) "63000"

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


计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
关于 WEIGHTS 和 AGGREGATE 选项的描述，参见 ZUNIONSTORE 命令。

返回值
保存到 destination 的结果集的基数。


代码示例

   127.0.0.1:6379> ZRANGE mid_test 0 -1 WITHSCORES
   1) "Han Meimei"
   2) "70"
   3) "Li Lei"
   4) "70"
   5) "Tom"
   6) "99.5"
   127.0.0.1:6379> ZRANGE fin_test 0 -1 WITHSCORES
   1) "Han Meimei"
   2) "75"
   3) "Li Lei"
   4) "88"
   5) "Tom"
   6) "99.5"
   127.0.0.1:6379> ZINTERSTORE sum_point 2 mid_test fin_test   #两个集合进行求和
   (integer) 3
   127.0.0.1:6379> ZRANGE sum_point 0 -1 WITHSCORES
   1) "Han Meimei"
   2) "145"
   3) "Li Lei"
   4) "158"
   5) "Tom"
   6) "199"

3. Redis 的持久化

• RDB(Redis DataBase)
• AOF(Append Only File)

3.1 RDB(Redis DataBase)

3.1.1 RDB 概述

1. RDB: 在指定的时间间隔内,将内存中的数据集快照(snapshot)写入磁盘,它恢复时,是将快照文件直接读到内存里;
2. Redis 会单独创建(fork)一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,
   在用这个临时文件替换上次持久化好的文件;
3. 整个过程中,主进程是不进行任何IO操作的,这就确保了极高的性能;
4. 如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加高效;
5. RDB 的缺点: 最后一次持久化后的数据可能丢失;
6. RDB 保存的是 dump.rdb;
7. RDB 是整个内存压缩过的Snapshot, RDB持久化策略,与快照触发条件一样,默认值
   • 1分钟内修改了1万次;
   • 5分钟内修改了10次;
   • 15分钟内修改了1次;

3.1.2 Fork

• Fork的作用: 是复制一个与当前进程一样的进程;新进程的所有数据(变量,环境变量,程序计数器等)数值都和原进程
  一致,但是是一个全新的进程,并作为原进程的子进程;

3.1.3 触发RDB快照的方式(三种)

• 配置文件中默认的快照配置,冷拷贝以后重新使用(即备份文件和要恢复备份的机器不是同一台);
• save或bgsave命令,立刻生成dump.rbd文件;
  • save时,只管保存,其他不管,全部阻塞;
  • bgsave:Redis 会在后台异步执行快照操作,快照的同时还可以响应客户端请求;可以通过lastsave命令
    获取最后一次成功执行快照的时间;
• 执行flushall命令,也会产生dump.rdb文件,但里面是空的,无意义;

3.1.4 恢复备份文件

• 将备份文件(dump.rdb)移动到redis安装目录并启动服务即可;

3.1.5 RDB优缺点

• 优势:
  • 适合大规模的数据恢复;
  • 对数据完整型和一致性要求不高;
• 劣势
  • 在一定间隔时间做一次备份,所以如果redis意外down掉的话,就会丢失最后一次快照后的所有修改;
  • Fork 的适合,内存中的数据被克隆了一份,大致2倍的膨胀性需要考虑;

3.2 AOF(Append Only File)

3.2.1 AOF 概述

1. 以日志的形式来记录每个写操作,将Redis执行过的所有写指令记录下来(读操作不记录),只需追加文件但不可以改写文
   件, redis启动之初会读取该文件,重新构建数据,换言之,redis重启的话,就根据日志文件的内容将写指令从前到后执行一
   次以完成数据的恢复工作;
2. redis.conf中的配置appendonly no,即该种持久化方式默认为关闭;
3. redis.conf中的配置appendfsync=everysec,出厂默认值,异步操作,每秒记录,若一秒内宕机,有数据丢失;
   • appendfsync=always: 同步持久化,每次发生数据变更会被立即记录到磁盘,性能较差但数据完整性比较好;

3.2.2 Rewrite

1. AOF 采用文件追加方式,文件会越来越大,为避免出现此种情况,新增了重写机制,当AOF文件的大小超过所设定的阈值时,
   Redis就会启动AOF文件的内容压缩,只保留可以恢复数据的最小指令集,可以使用命令 bgrewriteaof;
2. 重写原理:AOF文件持续增长而过大时,会fork出一条新进程来将文件重写(也是先写临时文件最后再rename),遍历新进
   程的内存中数据;重写aof文件的操作,并没有读取旧的aof文件,而是将整个内存中的数据库内容用命令的方式重写了一
   个新的aof文件,这点和快照有点类似;
3. 触发机制:Redis会记录上次重写时的AOF大小,默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发;

3.2.3 AOF 优势和劣势

• 优势:
  • 同步持久化,appendfsync=always;
  • 每修改同步,appendfsync=everysec;
• 劣势:
  • 相同数据集的数据而言,aof文件要远大于rdb文件,恢复速度慢于rdb;
  • AOF运行效率要慢于rdb,每秒同步策略效率较好,不同步效率和rdb相同;

3.3 RDB 和 AOF

1. RDB 持久化方式能够在指定的时间间隔,对数据进行快照存储;
2. AOF 持久化方式记录每次对服务器写的操作,当服务器重启的时候,会重新执行这些命令来恢复原始的数据,AOF 命令
   以redis协议追加保存每次写的操作到文件末尾,Redis 还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大;
3. 同时开启两种持久化方式:
   • 在这种情况下,当redis重启的时候,会优先加载AOF文件来恢复原始的数据,因为在通常情况下,AOF文件保存的数
     据集要比RDB文件保存的数据集完整;

4. Redis 的事务

4.1 事务
     事务本质上是一组命令的集合;一个事务中的所有命令都会序列化,按顺序地串行化执行而不会被其他命令插入,不许加塞;

4.2 常用命令
      MULTI: 标记一个事务块的开始;
      EXEC: 执行所有事务块内的命令;
      DISCARD: 取消事务,放弃执行事务块内的所有命令;
      WATCH: 监控一个(或多个)key,如果在事务执行之前,这个(或这些)key被其他命令所改动,那么事务将被打断;
      UNWATCH: 取消WATCH命令对所有key的监视;

4.3 事务的执行情况:
     正常执行
     放弃事务
     全体连坐:不管命令正确错误,都不执行;
     冤头债主:错误的命令不执行,正确的命令执行;
     watch监控

4.4 Redis 事务的三阶段
     开启: 以MULTI开始一个事务;
     入队: 将多个命令入队到事务中,接到这些命令并不会立即执行,而是放到等待执行的事务队列里面;
     执行: 以EXEC命令触发事务;

4.5 Redis 事务的三个特性
    单独的隔离操作:事务中的所有命令都会序列化,按顺序地执行;事务在执行的过程中,不会被其他客户端发送来的命令请求所打断;
    没有隔离级别的概念:队列中的命令,在没有提交之前不会实际的被执行,因为事务提交前任何指令都不会被实际执行,
    也就不存在"事务内的查询要看到事务里的更新,在事务外查询不能看到"这个让人万分头痛的问题;
    不保证原子性:redis同一个事务中,如果有一条命令执行失败,其他的命令仍然会被执行,没有回滚;

5. Redis 的发布/订阅

• Redis 的发布/订阅:进程间的一种信息通信模式,发送者(pub)发送消息,订阅者(sub)接收消息;

6. Redis 主从复制(Master/Slave)

6.1 概述

• 主从复制: 主机数据更新后,根据配置和策略,自动同步到备机的master/slave机制,Master以写为主,Slave以读为主;

6.2 应用

1. 读写分离
2. 容灾备份

6.3 使用方法

1. 配从(库)不配主(库);
2. 从库配置: slaveof 主库IP 主库端口
   • 每次与master断开之后,都需要重新连接,除非配置进redis.conf文件;
   • info replication: 查看当前库的状态;
3. 修改配置文件
   • 拷贝多个 redis.conf 文件;
   • 设置 daemonize yes, Pid 文件名字, 指定端口, Log文件的名字, Dump.rbd名字;
4. 常用3招
   • 一主二从(一个Master,两个Slave)
   • 薪火相传
     • 上一个Slave可以是下一个Slave的Master,Slave同样可以接收其他Slaves的连接和同步请求,那么,该
       Slave就是下一个Slave的Master,这样,可以有效减轻master的写压力;
     • 中途变更转向:会清除之前的数据,重新建立拷贝最新的; slaveof 新主库IP 新主库端口;
   • 反客为主
     • slaveof no one
     • 使当前数据库停止与其他数据库的同步,转成主数据库;
5. 复制原理
   • slave 成功连接到master后,会发送一个sync命令;
   • Master 接到命令,启动后台的存盘进程,同时,收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后,
     master 将传送整个数据文件到slave,以完成一次完全同步;
   • 全量复制:slave 服务在接收到数据库文件数据后,将其存盘并加载到内存中;
   • 增量复制:Master继续将新的所有收集到的修改命令依次传给slave,完成同步;
   • 但是,只要是重新连接master,一次完全同步(全量复制)将被自动执行;
   • 复制的缺点:复制的延时;由于所有的写操作都是先在Master上操作,然后同步更新到Slave上,所以从Master同步
     到slave机器有一定的延迟,当系统很繁忙的时候,延迟问题会更加严重,Slave机器数量的增加也会使这个问题更加严重;
6. 哨兵模式(Sentinel)
   • "反客为主"的自动版,能够后台监控主机是否故障,如果发生故障,根据投票数自动将从库转换为主库;
   • 使用步骤
     • 配置 sentinel.conf, 具体参考地址
       
   • 一个sentinel能同时监控多个Master;