Redis 基礎學習

finecho發表於2019-03-06
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 的各種型別做了一下介紹以及一些操作方法，至於具體的應用以及高階的操作，後面等我學了再放上來，哈哈。

finecho # Lhao

相關文章