Redis 基礎學習

@這是小豪的第十篇文章

最近想解決 一刻社群 中的一個 Issues “增加使用者活躍度統計”，其中的要求就是：利用 redis 位計算演算法實現使用者活躍度計算，突然發現有點不知所以然，雖然之前也用過 redis，但是總的來說自己連它的文件都沒讀過，哈哈，就藉著這個機會把 redis 基礎知識鞏固一下，然後解決 Issue，真棒，哈哈。

啟動

1. 啟動：redis-server.exe redis.windows.conf / redis-server
2. 連線：redis-cli.exe -h 127.0.0.1 -p 6379

redis 命令

1. 啟動客戶端後利用 redis-cli 連線本地服務
2. ping 檢測 redis 服務是否啟動
3. 執行遠端 redis 服務：redis-cli -h host -p port -a password

資料型別

1. string （字串）

2. hash （雜湊）

   • key：value （鍵值對集合），適合儲存物件

3. list （列表）

   • 簡單的字串列表，可以新增元素到列表的頭部和尾部

4. set （集合）

   • string 型別的無序集合
   • 集合是通過雜湊表實現的

5. zset （有序集合）

   • zset 和 set 一樣也是 string 型別元素的集合,且不允許重複的成員
   • 不同的是每個元素都會關聯一個double 型別的分數。redis 正是通過分數來為集合中的成員進行從小到大的排序
   • zset 的成員是唯一的,但分數 (score) 卻可以重複

操作指南

• key 操作

  -- SET KEY_NAME VALUE（設定給定 key 的值。如果 key 已經儲存其他值， SET 就覆寫舊值，且無視型別）
  > set name Lhao
  
  -- GET KEY_NAME （獲取指定 key 的值。如果 key 不存在，返回 nil 。如果key 儲存的值不是字串型別，返回一   個錯誤）
  > get name // 輸出：Lhao
  
  -- DUMP KEY_NAME （序列化 name，輸出序列化之後的值）
  > dump name // 輸出："\x00\x04Lhao\t\x00\xd3JL\xcf\xafsi\x8f"
  
  -- EXISTS KEY_NAME （判斷 key 是否存在）
  > exists name // 輸出：1
  
  -- Expire KEY_NAME TIME_IN_SECONDS (設定有效時間，過期之後則刪除，單位：s , 可對已存在的 key 進行操作)
  > expire name 10 // 輸出：1
  
  -- Expireat KEY_NAME TIME_IN_UNIX_TIMESTAMP (指定過期時間戳)
  > set name Lhao // 上面設定了過期時間，已經沒了 ，哈哈
  > expireat name 1551341040 // 輸出：1
  
  -- KEYS PATTERN (用於查詢所有符合給定模式 pattern 的 key )
  > set name Lhao
  > keys * //（返回所有鍵名）輸出：name
  > set naes haha
  > keys na* // 輸出：name、naes
  
  -- SELECT index (切換到指定的資料庫，資料庫索引號 index 用數字值指定，以 0 作為起始索引值)
  > select 0 
  
  -- MOVE KEY_NAME DESTINATION_DATABASE (將當前資料庫的 key 移動到給定的資料庫 db 當)
  > move name 1 // (移動 name 到 1 資料庫中)
  > exists name // 輸出：0
  > select 1
  > exists name // 輸出：1
  
  > expire name 10
  
  -- TTL KEY_NAME (以秒為單位返回 key 的剩餘過期時間)
  > ttl name // 輸出：8
  
  -- PERSIST KEY_NAME (移除給定 key 的過期時間，使得 key 永不過期)
  > persist name // 輸出：1
  > ttl name // 輸出：-1 （表示不過期）
  
  -- DEL KEY_NAME (刪除已存在的鍵。不存在的 key 會被忽略)
  > del name // 輸出：1
  
  > set name Lhao
  > set age 24
  
  -- RANDOMKEY (從當前資料庫中隨機返回一個 key)
  > randomkey // 輸出：age
  
  -- FLUSHDB (清空當前資料庫中的所有 key)
  > flushdb
  
  > set name Lhao
  
  -- RENAME OLD_KEY_NAME NEW_KEY_NAME (修改 key 的名稱)
  > rename name newname
  > get name // 輸出：nli (不存在)
  > set namecopy wjh
  > rename newname namecopy
  > get namecopy // 輸出：Lhao
  
  > set name Lhao
  
  -- RENAMENX OLD_KEY_NAME NEW_KEY_NAME (用於在新的 key 不存在時修改 key 的名稱)
  > renamenx namecopy name // 輸出：0 (此時修改 key 名不成功)
  
  -- TYPE KEY_NAME (返回 key 所儲存的值的型別)
  > type name // 輸出：string

• 字串 操作

  知乎：setbit\getbit 用法

  > flushdb
  
  > set title "my name is Lhao"
  > get title // 輸出：my name is Lhao
  
  -- GETRANGE KEY_NAME start end （用於獲取儲存在指定 key 中字串的子字串。字串的擷取範圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)）
  > getrange title 0 4 // 輸出：my na
  
  -- GETSET KEY_NAME VALUE (用於設定指定 key 的值，並返回 key 的舊值)
  > getset title "new title" // 輸出：my name is Lhao
  > get title // 輸出：new title
  
  -- MGET KEY1 KEY2 .. KEYN (返回所有(一個或多個)給定 key 的值。 如果給定的 key 裡面，有某個 key 不存在，那麼這個 key 返回特殊值 nil )
  > mget title name 
  // 輸出：
   1) (nil)
   2) "new title"
  
  -- SETEX KEY_NAME TIMEOUT VALUE (為指定的 key 設定值及其過期時間。如果 key 已經存在， SETEX 命令將會替換舊的值)
  > setex name 60 liuhao
  
  > del name
  
  -- SETNX KEY_NAME VALUE（SET if Not eXists） 命令在指定的 key 不存在時，為 key 設定指定的值
  > setnx name Lhao // 輸出：1
  > setnx title Lhao // 輸出：0
  
  -- SETRANGE KEY_NAME OFFSET VALUE （用指定的字串覆蓋給定 key 所儲存的字串值，覆蓋的位置從偏移量 offset 開始）
  > setrange name 3 Lhao // 輸出：7
  > get name // 輸出：LhaLhao
  
  -- STRLEN KEY_NAME (用於獲取指定 key 所儲存的字串值的長度。當 key 儲存的不是字串值時，返回一個錯誤)
  > strlen name // 輸出：7
  
  -- 用於同時設定一個或多個 key-value 對 (MSET key1 value1 key2 value2 .. keyN valueN )
  > mset name Lhao age 24 // 輸出：ok
  > mget name age 
  // 輸出：
   1) "Lhao"
   2) "24"
  
  -- MSETNX key1 value1 key2 value2 .. keyN valueN （用於所有給定 key 都不存在時，同時設定一個或多個 key-value 對）
  > msetnx name Lhao age 24 // 輸出：0
  > msetnx name Lhao25 sex men //輸出：0
  > get sex // 輸出：nli
  
  -- INCR KEY_NAME 
  // 將 key 中儲存的數字值增一。
  // 如果 key 不存在，那麼 key 的值會先被初始化為 0 ，然後再執行 INCR 操作。
  // 如果值包含錯誤的型別，或字串型別的值不能表示為數字，那麼返回一個錯誤。
  // 本操作的值限制在 64 位(bit)有符號數字表示之內。
  > incr name // 輸出：(error) ERR value is not an integer or out of range
  > incr money // 輸出：1
  
  -- DECRBY KEY_NAME DECREMENT_AMOUNT (將 key 中儲存的數字加上指定的增量值)
  > incrby money 80 // 輸出：81
  
  -- DECR KEY_NAME （將 key 中儲存的數字值減一）
  > decr money // 輸出：80
  
  -- DECRBY KEY_NAME DECREMENT_AMOUNT （將 key 所儲存的值減去指定的減量值）
  > decrby money 10 // 輸出：70
  
  -- APPEND KEY_NAME NEW_VALUE
  // 為指定的 key 追加值。
  // 如果 key 已經存在並且是一個字串， APPEND 命令將 value 追加到 key 原來的值的末尾。
  // 如果 key 不存在， APPEND 就簡單地將給定 key 設為 value ，就像執行 SET key value 一樣。
  > append name " love" //  輸出：8
  > get name // 輸出：Lhaolove

• 雜湊 操作

  > flushdb
  
  -- HSET KEY_NAME FIELD VALUE (用於為雜湊表中的欄位賦值;如果雜湊表不存在，一個新的雜湊表被建立並進行 HSET 操作;如果欄位已經存在於雜湊表中，舊值將被覆蓋)
  > hset user name Lhao // 輸出：1
  
  -- HGET KEY_NAME FIELD_NAME (用於返回雜湊表中指定欄位的值)
  > hget user name // 輸出：Lhao
  
  > hset user name wjh // 輸出：0
  > hget user name // 輸出：wjh
  
  -- HMSET KEY_NAME FIELD1 VALUE1 ...FIELDN VALUEN (用於同時將多個 field-value (欄位-值)對設定到雜湊表中)
  > hmset user name Lhao age 24 // 輸出：ok
  > hmget user name age
  // 輸出：
   1) "Lhao"
   2) "24"
  
  -- HDEL KEY_NAME FIELD1.. FIELDN（用於刪除雜湊表 key 中的一個或多個指定欄位，不存在的欄位將被忽略）
  > hdel user name // 輸出：1
  
  -- HEXISTS KEY_NAME FIELD_NAME (用於檢視雜湊表的指定欄位是否存在)
  > hexists user name // 輸出：0
  
  -- HGETALL KEY_NAME (用於返回雜湊表中，所有的欄位和值;在返回值裡，緊跟每個欄位名(field name)之後是欄位的值(value)，所以返回值的長度是雜湊表大小的兩倍)
  > hgetall user
  // 輸出：
   1) "age"
   2) "24"
  
  -- HINCRBY KEY_NAME FIELD_NAME INCR_BY_NUMBER（用於為雜湊表中的欄位值加上指定增量值）
  > hincrby user age 1 // 輸出：25
  
  -- HKEYS key (用於獲取雜湊表中的所有域（field）)
  > hkeys user
  // 輸出：
  1) "age"
  
  -- HLEN KEY_NAME （用於獲取雜湊表中欄位的數量）
  > hlen user //  輸出：1
  
  -- HSETNX KEY_NAME FIELD VALUE（用於為雜湊表中不存在的的欄位賦值）
  > hsetnx user name hao // 輸出：1
  > hsetnx user age 24 // 輸出：0
  
  -- HVALS KEY_NAME FIELD VALUE（返回雜湊表所有域(field)的值）
  > hvals user 
  // 輸出：
  1) "25"
  2) "Lhao"

• 列表 操作

  > flushdb
  
  -- LPUSH KEY_NAME VALUE1.. VALUEN （將一個或多個值插入到列表頭部。 如果 key 不存在，一個空列表會被建立並執行 LPUSH 操作。 當 key 存在但不是列表型別時，返回一個錯誤。）
  > lpush users Lhao wjh // 輸出：2
  
  -- LRANGE KEY_NAME START END (返回列表中指定區間內的元素，區間以偏移量 START 和 END 指定。 其中 0 表示列表的第一個元素， 1 表示列表的第二個元素，以此類推。 你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推)
  > lrange users 0 0 // 輸出：wjh
  > lrange users 0 -1 // 輸出：wjh、Lhao 
  
  -- BLPOP LIST1 LIST2 .. LISTN TIMEOUT （移出並獲取列表的第一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止）
  > blpop users 10 
  // 輸出：
  1) "users"
  2) "wjh"
  > lrange users 0 -1 // 輸出：Lhao
  
  -- BRPOPLPUSH LIST1 ANOTHER_LIST TIMEOUT （從列表中彈出第一個值，將彈出的元素插入到另外一個列表中並返回它； 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。）
  > brpoplpush users users_two 10 // 輸出：Lhao
  > lrange users 0 -1 // 輸出：(empty list or set)
  > lrange users_two 0 -1 // 輸出：Lhao
  
  > lpush users wjh Lhao
  
  -- LINDEX KEY_NAME INDEX_POSITION (用於通過索引獲取列表中的元素。你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。)
  > lindex users 0 // 輸出：lhao
  > lindex users -1 // 輸出：wjh
  
  > del users
  
  -- RPUSH KEY_NAME VALUE1..VALUEN (用於將一個或多個值插入到列表的尾部(最右邊);如果列表不存在，一個空列表會被建立並執行 RPUSH 操作。 當列表存在但不是列表型別時，返回一個錯誤)
  > rpush users Lhao wjh
  > lrange 0 -1 // 輸出：Lhao wjh
  
  -- LINSERT key BEFORE|AFTER pivot value (用於在列表的元素前或者後插入元素。當指定元素不存在於列表中時，不執行任何操作;當列表不存在時，被視為空列表，不執行任何操作;如果 key 不是列表型別，返回一個錯誤)
  > linsert users before wjh love // 輸出：3
  > lrange 0 -1 // 輸出：Lhao love wjh
  
  -- LLEN KEY_NAME (用於返回列表的長度。 如果列表 key 不存在，則 key 被解釋為一個空列表，返回 0 。 如果 key 不是列表型別，返回一個錯誤)
  > llen users // 輸出：3
  
  -- Lpop KEY_NAME (用於移除並返回列表的第一個元素)
  > lpop users // 輸出：Lhao
  > lrange users 0 -1 // 輸出：love wjh
  
  -- LPUSHX KEY_NAME VALUE1.. VALUEN (將一個值插入到已存在的列表頭部，列表不存在時操作無效)
  > lpushx users Lhao // 輸出：3
  > lrange users 0 -1 // 輸出：Lhao love wjh
  > lpushx user you // 輸出：0
  > lpush users Lhao Lhao // 輸出：5
  > lrange users 0 -1 // 輸出：Lhao Lhao Lhao love wjh
  
  -- LREM KEY_NAME COUNT VALUE
  // 根據引數 COUNT 的值，移除列表中與引數 VALUE 相等的元素
  // count > 0 : 從表頭開始向表尾搜尋，移除與 VALUE 相等的元素，數量為 COUNT 。
  // count < 0 : 從表尾開始向表頭搜尋，移除與 VALUE 相等的元素，數量為 COUNT 的絕對值。
  // count = 0 : 移除表中所有與 VALUE 相等的值。
  
  > lrem users 2 Lhao // 輸出：2
  > lrange users 0 -1 // 輸出：Lhao love wjh 
  
  -- LSET KEY_NAME INDEX VALUE (通過索引來設定元素的值;當索引引數超出範圍，或對一個空列表進行 LSET 時，返回一個錯誤)
  > lset users 0 liuhao // 輸出：ok
  > lrange users 0 -1 // 輸出：liuhao love wjh
  
  > lpush fruit apple cherry strawbrerry
  
  -- LTRIM KEY_NAME START STOP (對一個列表進行修剪(trim)，就是說，讓列表只保留指定 區間內的元素，不在指定區間之內的元素都將被刪除;下標 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。 你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。)
  > ltrim fruit 1 -1 // 輸出：ok
  > lrange fruit 0 -1 // 輸出：cherry apple
  
  -- RPOP KEY_NAME （用於移除列表的最後一個元素，返回值為移除的元素）
  > rpop fruit // 輸出：apple
  > lrange fruit 0 -1 // 輸出：cherry
  
  > lpush fruit apple cherry // 輸出：3
  
  -- RPOPLPUSH SOURCE_KEY_NAME DESTINATION_KEY_NAME （用於移除列表的最後一個元素，並將該元素新增到另一個列表並返回）
  > rpoplpush fruit users // 輸出：cherry
  > lrange users 0 -1 // 輸出：cherry、apple

• 集合 操作

  > flushdb
  
  -- SADD KEY_NAME VALUE1..VALUEN（將一個或多個成員元素加入到集合中，已經存在於集合的成員元素將被忽略；假如集合 key 不存在，則建立一個只包含新增的元素作成員的集合；當集合 key 不是集合型別時，返回一個錯誤。）
  > sadd users wjh Lhao // 輸出：2
  > sadd users wjh // 輸出：0 
  
  -- SMEMBERS key （返回集合中的所有的成員。 不存在的集合 key 被視為空集合）
  > smembers users // 輸出：wjh Lhao
  
  -- SCARD KEY_NAME (返回集合中元素的數量)
  > scard users // 輸出：2 
  
  > sadd usersTwo abing laoxia 
  > smembers usersTwo // 輸出：abing laoxia
  
  -- SDIFF FIRST_KEY OTHER_KEY1..OTHER_KEYN (返回給定集合之間的差集。不存在的集合 key 將視為空集；差集的結果來自前面的 FIRST_KEY ,而不是後面的 OTHER_KEY1，也不是整個 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集)
  > sdiff users usersTwo // 輸出：wjh Lhao
  > sadd usersTwo Lhao
  > sdiff users usersTwo // 輸出：wjh
  
  -- SDIFFSTORE DESTINATION_KEY KEY1..KEYN (將給定集合之間的差集儲存在指定的集合中。如果指定的集合 key 已存在，則會被覆蓋)
  > sdiffstore usersThree users usersTwo // 輸出：1
  > smembers usersThree // 輸出：wjh
  
  > del users usersTwo usersThree
  
  > sadd users wjh Lhao
  > sadd usersTwo Lhao abing laoxia
  
  -- SINTER KEY KEY1..KEYN (返回給定所有給定集合的交集。 不存在的集合 key 被視為空集。 當給定集合當中有一個空集時，結果也為空集(根據集合運算定律))
  > sinter users usersTwo // 輸出：Lhao
  
  -- SINTERSTORE DESTINATION_KEY KEY KEY1..KEYN (將給定集合之間的交集儲存在指定的集合中。如果指定的集合已經存在，則將其覆蓋)
  > sinterstore usersThree users usersTwo 
  > smembers usersThree // 輸出：Lhao
  
  -- SISMEMBER KEY VALUE (判斷成員元素是否是集合的成員)
  > sismember users Lhao // 輸出：1
  
  > sadd fruits apple cherry
  > sadd fruitsTwo strawbrerry
  
  -- SMOVE SOURCE DESTINATION MEMBER
  // 將指定成員 member 元素從 source 集合移動到 destination 集合。
  // SMOVE 是原子性操作。
  // 如果 source 集合不存在或不包含指定的 member 元素，則 SMOVE 命令不執行任何操作，僅返回 0 。否則， member 元素從 source 集合中被移除，並新增到 destination 集合中去。
  // 當 destination 集合已經包含 member 元素時， SMOVE 命令只是簡單地將 source 集合中的 member 元素刪除。
  // 當 source 或 destination 不是集合型別時，返回一個錯誤。
  > smove fruitsTwo fruits strawbrerry  // 輸出：1
  > smembers fruits // 輸出：cherry、apple、strawbrerry
  
  -- SPOP key [count] (移除集合中的指定 key 的一個或多個隨機元素，移除後會返回移除的元素)
  > spop fruits // 輸出：cherry
  > smembers druits // 輸出：strawbrerry、apple
  
  -- SRANDMEMBER KEY [count] （返回集合中一個或多個隨機數）
  > srandmember fruit // 輸出：apple 
  
  -- SREM KEY MEMBER1..MEMBERN （移除集合中的一個或多個成員元素，不存在的成員元素會被忽略）
  > srem fruits apple // 輸出：1
  > smembers fruits // 輸出：strawbrerry
  
  -- SUNION KEY KEY1..KEYN (返回給定集合的並集。不存在的集合 key 被視為空集)
  > flushdb
  > sadd fruits apple cherry 
  > sadd fruitsTwo apple strawberry
  > sunion fruits fruitsTwo // 輸出：cherry、strawberry、apple
  
  -- SUNIONSTORE DESTINATION KEY KEY1..KEYN （將給定集合的並集儲存在指定的集合 destination 中。如果 destination 已經存在，則將其覆蓋）
  > sunionstore fruitsThree fruits fruitsTwo
  > smembers fruitsThree // 輸出：cherry、strawberry、apple
  
  -- SSCAN key cursor [MATCH pattern] [COUNT count] （用於迭代集合中鍵的元素）
  > sscan fruitsThree 0 match a* // (
  輸出：1) "0"
       2) 1) "apple"
  )

*#### 有序集合 操作

 > flushdb

 -- ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN
    // 用於將一個或多個成員元素及其分數值加入到有序集當中。
    // 如果某個成員已經是有序集的成員，那麼更新這個成員的分數值，並通過重新插入這個成員元素，來保證該成員在正確的位置上。
    // 分數值可以是整數值或雙精度浮點數。
    // 如果有序集合 key 不存在，則建立一個空的有序集並執行 ZADD 操作。
    // 當 key 存在但不是有序集型別時，返回一個錯誤。
 > zadd myzset 1 "one" // 輸出：1
 > zadd myzset 1 "uno"
 > zadd myzset 2 "two" 3 "three"

 -- ZRANGE key start stop [WITHSCORES]
    // 返回有序集中，指定區間內的成員。
    // 其中成員的位置按分數值遞增(從小到大)來排序。
    // 具有相同分數值的成員按字典序(lexicographical order )來排列。
    // 如果你需要成員按值遞減(從大到小)來排列，請使用 ZREVRANGE 命令。
    // 下標引數 start 和 stop 都以 0 為底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。
    // 你也可以使用負數下標，以 -1 表示最後一個成員， -2 表示倒數第二個成員，以此類推
 > zrange myzset 0 -1 WITHSCORES
 // 輸出：
     1) "one"
     2) "1"
     3) "uno"
     4) "1"
     5) "two"
     6) "2"
     7) "three"
     8) "3"

 -- ZCARD KEY_NAME （用於計算集合中元素的數量）
 > zcard myzset // 輸出：4

 -- ZCOUNT key min max (用於計算有序集合中指定分數區間的成員數量)
 > zcount myzset 1 3 // 輸出：4

 -- ZINCRBY key increment member (對有序集合中指定成員的分數加上增量 increment)
 > zincrby myzset 2 "one" // 輸出：3
 > zrange myzset 0 -1 WITHSCORES
 // 輸出：
     1) "uno"
     2) "1"
     3) "two"
     4) "2"
     5) "one"
     6) "3"
     7) "three"
     8) "3"

 > zadd mid_test 70 Lhao 70 wjh
 > zadd fin_test 80 Lhao 78 wjh

 -- ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] （計算給定的一個或多個有序集的交集，其中給定 key 的數量必須以 numkeys 引數指定，並將該交集(結果集)儲存到 destination 。）
 > zinterstore sum_point 2 mid_test fin_test
 > zrange sum_point 0 -1 WITHSCORES
 // 輸出：
     1) "wjh"
     2) "148"
     3) "Lhao"
     4) "150"

 -- ZLEXCOUNT KEY MIN MAX （計算有序集合中指定字典區間內成員數量）
 > zadd newzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
 > zlexcount newzset - + // 輸出：7
 > zlexcount newzset [b [f // 輸出：5

 -- ZRANGEBYLEX key min max [LIMIT offset count] (通過字典區間返回有序集合的成員)
 > zrangebylex newzset - [c
 // 輸出：
     1) "b"
     2) "a"
     3) "c"
 > zrangebylex newzset - (c
  // 輸出：
     1) "b"
     2) "a"
 > zrangebylex newzset [aaa (g
  // 輸出：
     1) "b"
     2) "a"
     3) "c"
     4) "d"
     5) "e"
     6) "f"

 > zadd salary 2500 jack 5000 tom 12000 peter

 -- ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
    // 返回有序集合中指定分數區間的成員列表。有序整合員按分數值遞增(從小到大)次序排列。
    // 具有相同分數值的成員按字典序來排列(該屬性是有序集提供的，不需要額外的計算)。
    // 預設情況下，區間的取值使用閉區間 (小於等於或大於等於)，你也可以通過給引數前增加 ( 符號來使用可選的開區間 (小於或大於)
 > zrangebyscore salary -inf +inf #顯示整個有序集
 // 輸出：
     1) "jack"
     2) "tom"
     3) "peter"
 > zrangebyscore salary -inf +inf WITHSCORES # 顯示整個有序集及成員的 score 值
 // 輸出：
     1) "jack"
     2) "2500"
     3) "tom"
     4) "5000"
     5) "peter"
     6) "12000"
 > zrangebyscore salary -inf 5000 WITHSCORES # 顯示工資 <=5000 的所有成員
 // 輸出：
     1) "jack"
     2) "2500"
     3) "tom"
     4) "5000"
 > zrangebyscore salary (5000 400000 # 顯示工資大於 5000 小於等於 400000 的成員
 // 輸出：
    1) "peter"

 -- ZRANK key member （返回有序集中指定成員的排名。其中有序整合員按分數值遞增(從小到大)順序排列）
 > zrank salary tom // 輸出：1 （ # tom 的薪水排名，第二）

 -- ZREM key member [member ...] (用於移除有序集中的一個或多個成員，不存在的成員將被忽略;當 key 存在但不是有序集型別時，返回一個錯誤)
 > zrem salary tom // 輸出：1
 > zrangebyscore salary -inf +inf WITHSCORES
 // 輸出：
     1) "jack"
     2) "2500"
     3) "peter"
     4) "12000"

 > zadd myzset 0 aaaa 0 b 0 c 0 d 0 e 0 foo 0 zap 0 zip 0 ALPHA 0 alpha

 -- ZREMRANGEBYLEX key min max（用於移除有序集合中給定的字典區間的所有成員）
 > zremrangebylex myzset [alpha [omega // 輸出：6
 > zrange myzset 0 -1
 // 輸出：
     1) "ALPHA"
     2) "aaaa"
     3) "zap"
     4) "zip"

 > zadd salary 5000 tom

 -- ZREMRANGEBYRANK key start stop（用於移除有序集中，指定排名(rank)區間內的所有成員）
 > zremrangebyrank salary 0 1 // 輸出：2
 > zrange salary 0 -1 WITHSCORES 
 // 輸出：
     1) "peter"
     2) "12000"

 > zadd salary 2500 jack 5000 tom

 -- ZREMRANGEBYSCORE key min max (用於移除有序集中，指定分數（score）區間內的所有成員)
 > zremrangebyscore salary 1500 3500 // 輸出：1
 > zrange salary 0 -1 WITHSCORES
 // 輸出：
     1) "tom"
     2) "5000"
     3) "peter"
     4) "12000"

 > zadd salary 2500 jack

 -- ZREVRANGE key start stop [WITHSCORES]（返回有序集中，指定區間內的成員；其中成員的位置按分數值遞減(從大到小)來排列。具有相同分數值的成員按字典序的逆序(reverse lexicographical order)排列；除了成員按分數值遞減的次序排列這一點外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一樣）
 > zrevrange salary 0 -1 WITHSCORES
 // 輸出：
     1) "peter"
     2) "12000"
     3) "tom"
     4) "5000"
     5) "jack"
     6) "2500"

 -- ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]（返回有序集中指定分數區間內的所有的成員。有序整合員按分數值遞減(從大到小)的次序排列）
 > zrevrangebyscore salary +inf -inf # 逆序排列所有成員
 //輸出：
     1) "peter"
     2) "tom"
     3) "jack"
 > zrevrangebyscore salary 10000 200 # 逆序排列薪水介於 10000 和 2000 之間的成員
 // 輸出：
     1) "tom"
     2) "jack"

 -- ZREVRANK key member（返回有序集中成員的排名。其中有序整合員按分數值遞減(從大到小)排序；排名以 0 為底，也就是說， 分數值最大的成員排名為 0 ；使用 ZRANK 命令可以獲得成員按分數值遞增(從小到大)排列的排名）
 > zrevrank salary peter // 輸出：0
 > zrevrank salary tom // 輸出：1

 -- ZSCORE key member (返回有序集中，成員的分數值。 如果成員元素不是有序集 key 的成員，或 key 不存在，返回 nil )
 > zscore salary peter // 輸出：12000

 > zadd programmer 2000 peter 3500 jack 5000 tom
 > zadd manager 2000 herry 3500 mary 4000 bob

 -- ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]（計算給定的一個或多個有序集的並集，其中給定 key 的數量必須以 numkeys 引數指定，並將該並集(結果集)儲存到 destination；預設情況下，結果集中某個成員的分數值是所有給定集下該成員分數值之和）

 > zunionstore salary 2 programmer manager WEIGHTS 1 3 # # 公司決定加薪。。。除了程式設計師。。。
 > zrange salary 0 -1 WITHSCORES
 // 輸出：
      1) "peter"
      2) "2000"
      3) "jack"
      4) "3500"
      5) "tom"
      6) "5000"
      7) "herry"
      8) "6000"
      9) "mary"
     10) "10500"
     11) "bob"
     12) "12000"

結束語

這裡只是簡單的對 redis 的各種型別做了一下介紹以及一些操作方法，至於具體的應用以及高階的操作，後面等我學了再放上來，哈哈。