碼上快樂

相關內容    簡體    繁體

Redis詳解

本文轉載自   查看原文   2019-07-07 21:34   459    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"填充
   "\x00\x00\x00\x00\x00Redis!"

 

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.  
          
    2. Redis 會單獨創建(fork)一個子進程來進行持久化,會先將數據寫入到一個臨時文件中,待持久化過程都結束了,
      在用這個臨時文件替換上次持久化好的文件;
      3.  
          
    3. 整個過程中,主進程是不進行任何IO操作的,這就確保了極高的性能;
      4.  
          
    4. 如果需要進行大規模數據的恢復,且對於數據恢復的完整性不是非常敏感,那RDB方式要比AOF方式更加高效;
      5.  
          
    5. RDB 的缺點: 最后一次持久化后的數據可能丟失;
      6.  
          
    6. RDB 保存的是 dump.rdb;
      7.  
          
    7. RDB 是整個內存壓縮過的Snapshot, RDB持久化策略,與快照觸發條件一樣,默認值 
           
         
            
      • 1分鍾內修改了1萬次;
        •  
            
      • 5分鍾內修改了10次;
        •  
            
      • 15分鍾內修改了1次;
        •  
           
       
      8.  
         
     
        
 
        
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.  
          
    2. redis.conf中的配置appendonly no,即該種持久化方式默認為關閉;
      3.  
          
    3. redis.conf中的配置appendfsync=everysec,出廠默認值,異步操作,每秒記錄,若一秒內宕機,有數據丟失; 
           
         
            
      • appendfsync=always: 同步持久化,每次發生數據變更會被立即記錄到磁盤,性能較差但數據完整性比較好;
        •  
           
       
      4.  
         
     
        
 
        
3.2.2 Rewrite
 
        
     
         
       
          
    1. AOF 采用文件追加方式,文件會越來越大,為避免出現此種情況,新增了重寫機制,當AOF文件的大小超過所設定的閾值時,
      Redis就會啟動AOF文件的內容壓縮,只保留可以恢復數據的最小指令集,可以使用命令 bgrewriteaof;
      2.  
          
    2. 重寫原理:AOF文件持續增長而過大時,會fork出一條新進程來將文件重寫(也是先寫臨時文件最后再rename),遍歷新進
      程的內存中數據;重寫aof文件的操作,並沒有讀取舊的aof文件,而是將整個內存中的數據庫內容用命令的方式重寫了一
      個新的aof文件,這點和快照有點類似;
      3.  
          
    3. 觸發機制:Redis會記錄上次重寫時的AOF大小,默認配置是當AOF文件大小是上次rewrite后大小的一倍且文件大於64M時觸發;
      4.  
         
     
        
 
        
3.2.3 AOF 優勢和劣勢
 
        
     
         
  • 優勢: 
          
       
           
    • 同步持久化,appendfsync=always;
      •  
           
    • 每修改同步,appendfsync=everysec;
      •  
          
     
    •  
         
  • 劣勢: 
          
       
           
    • 相同數據集的數據而言,aof文件要遠大於rdb文件,恢復速度慢於rdb;
      •  
           
    • AOF運行效率要慢於rdb,每秒同步策略效率較好,不同步效率和rdb相同;
      •  
          
     
    •  
        
 
        
3.3 RDB 和 AOF
 
        
     
         
       
          
    1. RDB 持久化方式能夠在指定的時間間隔,對數據進行快照存儲;
      2.  
          
    2. AOF 持久化方式記錄每次對服務器寫的操作,當服務器重啟的時候,會重新執行這些命令來恢復原始的數據,AOF 命令
      以redis協議追加保存每次寫的操作到文件末尾,Redis 還能對AOF文件進行后台重寫,使得AOF文件的體積不至於過大;
      3.  
          
    3. 同時開啟兩種持久化方式: 
           
         
            
      • 在這種情況下,當redis重啟的時候,會優先加載AOF文件來恢復原始的數據,因為在通常情況下,AOF文件保存的數
        據集要比RDB文件保存的數據集完整;
        •  
           
       
      4.  
         
     
        
 
        
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.  
         
  2. 容災備份
    3.  
        
 
        
6.3 使用方法
 
        
     
         
       
          
    1. 配從(庫)不配主(庫);
      2.  
          
    2. 從庫配置: slaveof 主庫IP 主庫端口 
           
         
            
      • 每次與master斷開之后,都需要重新連接,除非配置進redis.conf文件;
        •  
            
      • info replication: 查看當前庫的狀態;
        •  
           
       
      3.  
          
    3. 修改配置文件 
           
         
            
      • 拷貝多個 redis.conf 文件;
        •  
            
      • 設置 daemonize yes, Pid 文件名字, 指定端口, Log文件的名字, Dump.rbd名字;
        •  
           
       
      4.  
          
    4. 常用3招 
           
         
            
      • 一主二從(一個Master,兩個Slave)
        •  
            
      • 薪火相傳 
             
           
              
        • 上一個Slave可以是下一個Slave的Master,Slave同樣可以接收其他Slaves的連接和同步請求,那么,該
          Slave就是下一個Slave的Master,這樣,可以有效減輕master的寫壓力;
          •  
              
        • 中途變更轉向:會清除之前的數據,重新建立拷貝最新的; slaveof 新主庫IP 新主庫端口;
          •  
             
         
        •  
            
      • 反客為主 
             
           
              
        • slaveof no one
          •  
              
        • 使當前數據庫停止與其他數據庫的同步,轉成主數據庫;
          •  
             
         
        •  
           
       
      5.  
          
    5. 復制原理 
           
         
            
      • slave 成功連接到master后,會發送一個sync命令;
        •  
            
      • Master 接到命令,啟動后台的存盤進程,同時,收集所有接收到的用於修改數據集命令,在后台進程執行完畢之后,
        master 將傳送整個數據文件到slave,以完成一次完全同步;
        •  
            
      • 全量復制:slave 服務在接收到數據庫文件數據后,將其存盤並加載到內存中;
        •  
            
      • 增量復制:Master繼續將新的所有收集到的修改命令依次傳給slave,完成同步;
        •  
            
      • 但是,只要是重新連接master,一次完全同步(全量復制)將被自動執行;
        •  
            
      • 復制的缺點:復制的延時;由於所有的寫操作都是先在Master上操作,然后同步更新到Slave上,所以從Master同步
        到slave機器有一定的延遲,當系統很繁忙的時候,延遲問題會更加嚴重,Slave機器數量的增加也會使這個問題更加嚴重;
        •  
           
       
      6.  
          
    6. 哨兵模式(Sentinel) 
           
         
            
      • "反客為主"的自動版,能夠后台監控主機是否故障,如果發生故障,根據投票數自動將從庫轉換為主庫;
        •  
            
      • 使用步驟 
              
        •  
            
      • 一個sentinel能同時監控多個Master;
        •  
           
       
      7.  
         
     
        
 
       
 
        
       
 
        
 
 
       
 
        
       
 
       
 
      
 
      
 
      
 
     
 
     
 
      
 
      
 
        
       
免責聲明！
 
       
本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。
 
      
 
      

      
 
     
 
    
 
     
    
 
     
 
      猜您在找 
        Redis詳解  
        Redis 詳解  
        Redis詳解  
        Redis++：redis配置詳解  
        Redis詳解（一）------ redis的簡介與安裝  
        【Redis】Redis學習（三） Redis 主從模式詳解  
        【Redis】Redis學習（四） Redis Sentinel模式詳解  
        【Redis】Redis學習（五） Redis cluster模式詳解  
        redis緩存使用詳解  
        Redis協議詳解  
      
 
      
 
     
 
    
 
   
 
  
 
  

    
  
 
  
 
   
 
   
 
   
 
    粵ICP備18138465號  
    © 2018-2025 CODEPRJ.COM