Key(鍵)
1. DEL
時間復(fù)雜度：
O(N)， N 為被刪除的 key 的數(shù)量。
刪除單個字符串類型的 key ，時間復(fù)雜度為O(1)。
刪除單個列表、集合、有序集合或哈希表類型的 key ，時間復(fù)雜度為O(M)， M 為以上數(shù)據(jù)結(jié)構(gòu)內(nèi)的元素數(shù)量。
# 刪除單個 key
redis> SET name huangz
OK
redis> DEL name
(integer) 1
# 刪除一個不存在的 key
redis> EXISTS phone
(integer) 0
redis> DEL phone # 失敗，沒有 key 被刪除
(integer) 0
# 同時刪除多個 key
redis> SET name "redis"
OK
redis> SET type "key-value store"
OK
redis> SET website "redis.com"
OK
redis> DEL name type website
(integer) 3
2.·EXISTS
時間復(fù)雜度：
O(1)
redis> SET db "redis"
OK
redis> EXISTS db
(integer) 1
redis> DEL db
(integer) 1
redis> EXISTS db
(integer) 0
3. EXPIRE
為給定 key 設(shè)置生存時間，當(dāng) key 過期時(生存時間為 0 )，它會被自動刪除。
PEXPIRE
和 EXPIRE 命令的作用類似，但是它以毫秒為單位設(shè)置key 的生存時間，而不像 EXPIRE 命令那樣，以秒為單位。
EXPIREAT
EXPIREAT 的作用和 EXPIRE 類似，都用于為 key設(shè)置生存時間。
不同在于 EXPIREAT 命令接受的時間參數(shù)是 UNIX 時間戳(unix timestamp)。
PEXPIREAT
它以毫秒為單位設(shè)置 key 的過期 unix 時間戳
redis> SET cache_page "www.google.com"
OK
redis> EXPIRE cache_page 30 # 設(shè)置過期時間為 30 秒
(integer) 1
redis> TTL cache_page # 查看剩余生存時間
(integer) 23
redis> EXPIRE cache_page 30000 # 更新過期時間
(integer) 1
redis> TTL cache_page
(integer) 29996
redis> EXPIREAT cache 1355292000 # 這個 key 將在 2012.12.12 過期
(integer) 1
redis> TTL cache
(integer) 45081860
4.·RENAME
RENAME key newkey
將 key 改名為 newkey 。
當(dāng) key 和 newkey 相同，或者 key 不存在時，返回一個錯誤。
當(dāng)newkey已經(jīng)存在時， RENAME 命令將覆蓋舊值。
# key 存在且 newkey 不存在
redis> SET message "hello world"
OK
redis> RENAME message greeting
OK
redis> EXISTS message # message 不復(fù)存在
(integer) 0
redis> EXISTS greeting # greeting 取而代之
(integer) 1
# 當(dāng) key 不存在時，返回錯誤
redis> RENAME fake_key never_exists
(error) ERR no such key
# newkey 已存在時， RENAME 會覆蓋舊 newkey
redis> SET pc "lenovo"
OK
redis> SET personal_computer "dell"
OK
redis> RENAME pc personal_computer
OK
redis> GET pc
(nil)
redis:1> GET personal_computer # 原來的值 dell 被覆蓋了
"lenovo"
5. SORT
返回或保存給定列表、集合、有序集合 key 中經(jīng)過排序的元素。
排序默認以數(shù)字作為對象，值被解釋為雙精度浮點數(shù)，然后進行比較。
一般 SORT 用法
最簡單的 SORT 使用方法是 SORT key DESC：
- SORT key返回鍵值從小到大排序的結(jié)果。
- SORT key DESC返回鍵值從大到小排序的結(jié)果。
假設(shè) today_cost列表保存了今日的開銷金額， 那么可以用 SORT 命令對它進行排序：
# 開銷金額列表
redis> LPUSH today_cost 30 1.5 10 8
(integer) 4
# 排序
redis> SORT today_cost
1) "1.5"
2) "8"
3) "10"
4) "30"
# 逆序排序
redis 127.0.0.1:6379> SORT today_cost DESC
1) "30"
2) "10"
3) "8"
4) "1.5"
6.`TYPE
TYPE key
返回 key 所儲存的值的類型。
返回值：
none (key不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)
# 字符串
redis> SET weather "sunny"
OK
redis> TYPE weather
string
# 列表
redis> LPUSH book_list "programming in scala"
(integer) 1
redis> TYPE book_list
list
# 集合
redis> SADD pat "dog"
(integer) 1
redis> TYPE pat
set
String(字符串)
1. APPEND
APPEND key value
如果 key 已經(jīng)存在并且是一個字符串， APPEND 命令將value 追加到 key原來的值的末尾。
如果key不存在， APPEND 就簡單地將給定
key設(shè)為value,，就像執(zhí)行 SET key value 一樣。
# 對不存在的 key 執(zhí)行 APPEND
redis> EXISTS myphone # 確保 myphone 不存在
(integer) 0
redis> APPEND myphone "nokia" # 對不存在的 key 進行 APPEND ，等同于 SET myphone "nokia"
(integer) 5 # 字符長度
# 對已存在的字符串進行 APPEND
redis> APPEND myphone " - 1110" # 長度從 5 個字符增加到 12 個字符
(integer) 12
redis> GET myphone
"nokia - 1110"
2. GET
GET key
返回 key 所關(guān)聯(lián)的字符串值。
如果 key 不存在那么返回特殊值 nil 。
假如 key儲存的值不是字符串類型，返回一個錯誤，因為 GET 只能用于處理字符串值。
# 對不存在的 key 或字符串類型 key 進行 GET
redis> GET db
(nil)
redis> SET db redis
OK
redis> GET db
"redis"
# 對不是字符串類型的 key 進行 GET
redis> DEL db
(integer) 1
redis> LPUSH db redis mongodb mysql
(integer) 3
redis> GET db
(error) ERR Operation against a key holding the wrong kind of value
GETRANGE
返回 key 中字符串值的子字符串，字符串的截取范圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內(nèi))。
負數(shù)偏移量表示從字符串最后開始計數(shù)， -1 表示最后一個字符， -2 表示倒數(shù)第二個，以此類推。
redis> SET greeting "hello, my friend"
OK
redis> GETRANGE greeting 0 4 # 返回索引0-4的字符，包括4。
"hello"
redis> GETRANGE greeting -1 -5 # 不支持回繞操作
""
redis> GETRANGE greeting -3 -1 # 負數(shù)索引
"end"
redis> GETRANGE greeting 0 -1 # 從第一個到最后一個
"hello, my friend"
redis> GETRANGE greeting 0 1008611 # 值域范圍不超過實際字符串，超過部分自動被符略
"hello, my friend"
GETSET
GETSET key value
將給定 key 的值設(shè)為 value ，并返回 key 的舊值(old value)。
當(dāng) key 存在但不是字符串類型時，返回一個錯誤。
redis> GETSET db mongodb # 沒有舊值，返回 nil
(nil)
redis> GET db
"mongodb"
redis> GETSET db redis # 返回舊值 mongodb
"mongodb"
redis> GET db
"redis"
MGET
MGET key [key ...]
返回所有(一個或多個)給定 key 的值。
如果給定的 key 里面，有某個 key 不存在，那么這個 key 返回特殊值 nil 。因此，該命令永不失敗。
redis> SET redis redis.com
OK
redis> SET mongodb mongodb.org
OK
redis> MGET redis mongodb
1) "redis.com"
2) "mongodb.org"
redis> MGET redis mongodb mysql # 不存在的 mysql 返回 nil
1) "redis.com"
2) "mongodb.org"
3) (nil)
3.`SET
SET key value [EX seconds] [PX milliseconds] [NX|XX]
將字符串值value關(guān)聯(lián)到 key。
如果key 已經(jīng)持有其他值， SET 就覆寫舊值，無視類型。
對于某個原本帶有生存時間（TTL）的鍵來說， 當(dāng) SET 命令成功在這個鍵上執(zhí)行時， 這個鍵原有的 TTL 將被清除。
可選參數(shù)
從 Redis 2.6.12 版本開始， SET 命令的行為可以通過一系列參數(shù)來修改：
- EX second ：設(shè)置鍵的過期時間為second 秒。SET key value EX second效果等同于 SETEX key second value。
- PX millisecond ：設(shè)置鍵的過期時間為 millisecond 毫秒。SET key value PX millisecond 效果等同于 PSETEX key millisecond value 。
- NX ：只在鍵不存在時，才對鍵進行設(shè)置操作。 SET key value NX 效果等同于 SETNX key value 。
- XX ：只在鍵已經(jīng)存在時，才對鍵進行設(shè)置操作。
# 對不存在的鍵進行設(shè)置
redis 127.0.0.1:6379> SET key "value"
OK
redis 127.0.0.1:6379> GET key
"value"
# 對已存在的鍵進行設(shè)置
redis 127.0.0.1:6379> SET key "new-value"
OK
redis 127.0.0.1:6379> GET key
"new-value"
# 使用 EX 選項
redis 127.0.0.1:6379> SET key-with-expire-time "hello" EX 10086
OK
redis 127.0.0.1:6379> GET key-with-expire-time
"hello"
redis 127.0.0.1:6379> TTL key-with-expire-time
(integer) 10069
# 使用 PX 選項
redis 127.0.0.1:6379> SET key-with-pexpire-time "moto" PX 123321
OK
redis 127.0.0.1:6379> GET key-with-pexpire-time
"moto"
redis 127.0.0.1:6379> PTTL key-with-pexpire-time
(integer) 111939
# 使用 NX 選項
redis 127.0.0.1:6379> SET not-exists-key "value" NX
OK # 鍵不存在，設(shè)置成功
redis 127.0.0.1:6379> GET not-exists-key
"value"
redis 127.0.0.1:6379> SET not-exists-key "new-value" NX
(nil) # 鍵已經(jīng)存在，設(shè)置失敗
redis 127.0.0.1:6379> GEt not-exists-key
"value" # 維持原值不變
# 使用 XX 選項
redis 127.0.0.1:6379> EXISTS exists-key
(integer) 0
redis 127.0.0.1:6379> SET exists-key "value" XX
(nil) # 因為鍵不存在，設(shè)置失敗
redis 127.0.0.1:6379> SET exists-key "value"
OK # 先給鍵設(shè)置一個值
redis 127.0.0.1:6379> SET exists-key "new-value" XX
OK # 設(shè)置新值成功
redis 127.0.0.1:6379> GET exists-key
"new-value"
# NX 或 XX 可以和 EX 或者 PX 組合使用
redis 127.0.0.1:6379> SET key-with-expire-and-NX "hello" EX 10086 NX
OK
redis 127.0.0.1:6379> GET key-with-expire-and-NX
"hello"
redis 127.0.0.1:6379> TTL key-with-expire-and-NX
(integer) 10063
redis 127.0.0.1:6379> SET key-with-pexpire-and-XX "old value"
OK
redis 127.0.0.1:6379> SET key-with-pexpire-and-XX "new value" PX 123321
OK
redis 127.0.0.1:6379> GET key-with-pexpire-and-XX
"new value"
redis 127.0.0.1:6379> PTTL key-with-pexpire-and-XX
(integer) 112999
# EX 和 PX 可以同時出現(xiàn)，但后面給出的選項會覆蓋前面給出的選項
redis 127.0.0.1:6379> SET key "value" EX 1000 PX 5000000
OK
redis 127.0.0.1:6379> TTL key
(integer) 4993 # 這是 PX 參數(shù)設(shè)置的值
redis 127.0.0.1:6379> SET another-key "value" PX 5000000 EX 1000
OK
redis 127.0.0.1:6379> TTL another-key
(integer) 997 # 這是 EX 參數(shù)設(shè)置的值
MSET
MSET key value [key value ...]
同時設(shè)置一個或多個 key-value 對。
MSET
redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK
redis> MGET date time weather
1) "2012.3.30"
2) "11:00 a.m."
3) "sunny"
# MSET 覆蓋舊值例子
redis> SET google "google.hk"
OK
redis> MSET google "google.com"
OK
redis> GET google
"google.com"
4. STRLEN
STRLEN key
返回 key 所儲存的字符串值的長度。
當(dāng) key 儲存的不是字符串值時，返回一個錯誤。
# 獲取字符串的長度
redis> SET mykey "Hello world"
OK
redis> STRLEN mykey
(integer) 11
# 不存在的 key 長度為 0
redis> STRLEN nonexisting
(integer) 0
Hash(哈希表)
1.HSET
HSET key field value
將哈希表 key 中的域 field 的值設(shè)為 value 。
如果 key不存在，一個新的哈希表被創(chuàng)建并進行 HSET 操作。
如果域 field 已經(jīng)存在于哈希表中，舊值將被覆蓋。
redis> HSET website google "www.g.cn" # 設(shè)置一個新域
(integer) 1
redis> HSET website google "www.google.com" # 覆蓋一個舊域
(integer) 0
HMSET
HMSET key field value [field value ...]
同時將多個 field-value (域-值)對設(shè)置到哈希表 key 中。
此命令會覆蓋哈希表中已存在的域。
如果key 不存在，一個空哈希表被創(chuàng)建并執(zhí)行 HMSET 操作。
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK
redis> HGET website google
"www.google.com"
redis> HGET website yahoo
"www.yahoo.com"
HSETNX
將哈希表 key 中的域 field 的值設(shè)置為 value ，當(dāng)且僅當(dāng)域 field 不存在。
若域field 已經(jīng)存在，該操作無效。
如果 key 不存在，一個新哈希表被創(chuàng)建并執(zhí)行 HSETNX 命令。
redis> HSETNX nosql key-value-store redis
(integer) 1
redis> HSETNX nosql key-value-store redis # 操作無效，域 key-value-store 已存在
(integer) 0
2.HGET
HGET key field
返回哈希表 key 中給定域 field 的值。
# 域存在
redis> HSET site redis redis.com
(integer) 1
redis> HGET site redis
"redis.com"
# 域不存在
redis> HGET site mysql
(nil)
HGETALL
HGETALL key
返回哈希表 key 中，所有的域和值。
在返回值里，緊跟每個域名(field name)之后是域的值(value)，所以返回值的長度是哈希表大小的兩倍
redis> HSET people jack "Jack Sparrow"
(integer) 1
redis> HSET people gump "Forrest Gump"
(integer) 1
redis> HGETALL people
1) "jack" # 域
2) "Jack Sparrow" # 值
3) "gump"
4) "Forrest Gump"
3.HEXISTS
HEXISTS key field
查看哈希表 key 中，給定域 field 是否存在。
redis> HEXISTS phone myphone
(integer) 0
redis> HSET phone myphone nokia-1110
(integer) 1
redis> HEXISTS phone myphone
4.HDEL
HDEL key field [field ...]
刪除哈希表 key 中的一個或多個指定域，不存在的域?qū)⒈缓雎浴?/p>
# 測試數(shù)據(jù)
redis> HGETALL abbr
1) "a"
2) "apple"
3) "b"
4) "banana"
5) "c"
6) "cat"
7) "d"
8) "dog"
# 刪除單個域
redis> HDEL abbr a
(integer) 1
# 刪除不存在的域
redis> HDEL abbr not-exists-field
(integer) 0
# 刪除多個域
redis> HDEL abbr b c
(integer) 2
redis> HGETALL abbr
1) "d"
2) "dog"
5.HVALS
HVALS key
返回哈希表 key 中所有域的值。
# 非空哈希表
redis> HMSET website google www.google.com yahoo www.yahoo.com
OK
redis> HVALS website
1) "www.google.com"
2) "www.yahoo.com"
# 空哈希表/不存在的key
redis> EXISTS not_exists
(integer) 0
redis> HVALS not_exists
(empty list or set)
List(列表)
1.LPUSH
LPUSH key value [value ...]
將一個或多個值 value 插入到列表 key 的表頭
如果有多個 value 值，那么各個 value 值按從左到右的順序依次插入到表頭： 比如說，對空列表 mylist 執(zhí)行命令 LPUSH mylist a b c ，列表的值將是 c b a ，這等同于原子性地執(zhí)行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三個命令。
如果key不存在，一個空列表會被創(chuàng)建并執(zhí)行 LPUSH 操作。
當(dāng) key存在但不是列表類型時，返回一個錯誤。
# 加入單個元素
redis> LPUSH languages python
(integer) 1
# 加入重復(fù)元素
redis> LPUSH languages python
(integer) 2
redis> LRANGE languages 0 -1 # 列表允許重復(fù)元素
1) "python"
2) "python"
# 加入多個元素
redis> LPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "c"
2) "b"
3) "a"
LPUSHX
LPUSHX key value
將值 value插入到列表 key的表頭，當(dāng)且僅當(dāng) key存在并且是一個列表。
和 LPUSH 命令相反，當(dāng) key不存在時， LPUSHX 命令什么也不做。
# 對空列表執(zhí)行 LPUSHX
redis> LLEN greet # greet 是一個空列表
(integer) 0
redis> LPUSHX greet "hello" # 嘗試 LPUSHX，失敗，因為列表為空
(integer) 0
# 對非空列表執(zhí)行 LPUSHX
redis> LPUSH greet "hello" # 先用 LPUSH 創(chuàng)建一個有一個元素的列表
(integer) 1
redis> LPUSHX greet "good morning" # 這次 LPUSHX 執(zhí)行成功
(integer) 2
redis> LRANGE greet 0 -1
1) "good morning"
2) "hello"
RPUSH
RPUSH key value [value ...]
將一個或多個值 value 插入到列表 key 的表尾(最右邊)。
如果有多個 value 值，那么各個 value 值按從左到右的順序依次插入到表尾：比如對一個空列表 mylist 執(zhí)行 RPUSH mylist a b c ，得出的結(jié)果列表為 a b c ，等同于執(zhí)行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。
如果 key不存在，一個空列表會被創(chuàng)建并執(zhí)行 RPUSH 操作。
當(dāng) key 存在但不是列表類型時，返回一個錯誤。
# 添加單個元素
redis> RPUSH languages c
(integer) 1
# 添加重復(fù)元素
redis> RPUSH languages c
(integer) 2
redis> LRANGE languages 0 -1 # 列表允許重復(fù)元素
1) "c"
2) "c"
# 添加多個元素
redis> RPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "a"
2) "b"
3) "c"
RPUSHX
RPUSHX key value
將值 value 插入到列表 key 的表尾，當(dāng)且僅當(dāng) key 存在并且是一個列表。
和 RPUSH 命令相反，當(dāng) key 不存在時， RPUSHX 命令什么也不做。
# key不存在
redis> LLEN greet
(integer) 0
redis> RPUSHX greet "hello" # 對不存在的 key 進行 RPUSHX，PUSH 失敗。
(integer) 0
# key 存在且是一個非空列表
redis> RPUSH greet "hi" # 先用 RPUSH 插入一個元素
(integer) 1
redis> RPUSHX greet "hello" # greet 現(xiàn)在是一個列表類型，RPUSHX 操作成功。
(integer) 2
redis> LRANGE greet 0 -1
1) "hi"
2) "hello"
2.LPOP
LPOP key
移除并返回列表 key 的頭元素。
redis> LLEN course
(integer) 0
redis> RPUSH course algorithm001
(integer) 1
redis> RPUSH course c++101
(integer) 2
redis> LPOP course # 移除頭元素
"algorithm001"
RPOP
RPOP key
移除并返回列表 key 的尾元素。
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOP mylist # 返回被彈出的元素
"three"
redis> LRANGE mylist 0 -1 # 列表剩下的元素
1) "one"
2) "two"
3.LSET
LSET key index value
將列表 key 下標(biāo)為 index 的元素的值設(shè)置為 value 。
當(dāng) index 參數(shù)超出范圍，或?qū)σ粋€空列表(key不存在)進行 LSET 時，返回一個錯誤。
關(guān)于列表下標(biāo)的更多信息，請參考 LINDEX 命令。
# 對空列表(key 不存在)進行 LSET
redis> EXISTS list
(integer) 0
redis> LSET list 0 item
(error) ERR no such key
# 對非空列表進行 LSET
redis> LPUSH job "cook food"
(integer) 1
redis> LRANGE job 0 0
1) "cook food"
redis> LSET job 0 "play game"
OK
redis> LRANGE job 0 0
1) "play game"
# index 超出范圍
redis> LLEN list # 列表長度為 1
(integer) 1
redis> LSET list 3 'out of range'
(error) ERR index out of range
4.LINDEX
LINDEX key index
返回列表 key 中，下標(biāo)為 index 的元素。
下標(biāo)(index)參數(shù) start 和 stop 都以 0 為底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。
你也可以使用負數(shù)下標(biāo)，以 -1 表示列表的最后一個元素， -2 表示列表的倒數(shù)第二個元素，以此類推。
如果 key 不是列表類型，返回一個錯誤。
redis> LPUSH mylist "World"
(integer) 1
redis> LPUSH mylist "Hello"
(integer) 2
redis> LINDEX mylist 0
"Hello"
redis> LINDEX mylist -1
"World"
redis> LINDEX mylist 3 # index不在 mylist 的區(qū)間范圍內(nèi)
(nil)
5.LINSERT
LINSERT key BEFORE|AFTER pivot value
將值 value 插入到列表 key 當(dāng)中，位于值 pivot 之前或之后。
當(dāng) pivot 不存在于列表 key 時，不執(zhí)行任何操作。
當(dāng) key 不存在時， key 被視為空列表，不執(zhí)行任何操作。
如果 key 不是列表類型，返回一個錯誤。
redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSH mylist "World"
(integer) 2
redis> LINSERT mylist BEFORE "World" "There"
(integer) 3
redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"
# 對一個非空列表插入，查找一個不存在的 pivot
redis> LINSERT mylist BEFORE "go" "let's"
(integer) -1 # 失敗
# 對一個空列表執(zhí)行 LINSERT 命令
redis> EXISTS fake_list
(integer) 0
redis> LINSERT fake_list BEFORE "nono" "gogogog"
(integer) 0 # 失敗
6.LLEN
LLEN key
返回列表 key 的長度。
如果 key 不存在，則 key 被解釋為一個空列表，返回 0 .
如果 key 不是列表類型，返回一個錯誤。
# 空列表
redis> LLEN job
(integer) 0
# 非空列表
redis> LPUSH job "cook food"
(integer) 1
redis> LPUSH job "have lunch"
(integer) 2
redis> LLEN job
(integer) 2
7.LRANGE
LRANGE key start stop
返回列表 key 中指定區(qū)間內(nèi)的元素，區(qū)間以偏移量 start 和 stop 指定。
下標(biāo)(index)參數(shù) start 和 stop 都以 0 為底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。
你也可以使用負數(shù)下標(biāo)，以 -1 表示列表的最后一個元素， -2 表示列表的倒數(shù)第二個元素，以此類推。
超出范圍的下標(biāo)
超出范圍的下標(biāo)值不會引起錯誤。
如果start下標(biāo)比列表的最大下標(biāo) end ( LLEN減去 1)還要大，那么 LRANGE 返回一個空列表。
如果 stop 下標(biāo)比 end 下標(biāo)還要大，Redis將 stop 的值設(shè)置為 end 。
redis> RPUSH fp-language lisp
(integer) 1
redis> LRANGE fp-language 0 0
1) "lisp"
redis> RPUSH fp-language scheme
(integer) 2
redis> LRANGE fp-language 0 1
1) "lisp"
2) "scheme"
8.LTRIM
LTRIM key start stop
對一個列表進行修剪(trim)，就是說，讓列表只保留指定區(qū)間內(nèi)的元素，不在指定區(qū)間之內(nèi)的元素都將被刪除。
舉個例子，執(zhí)行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三個元素，其余元素全部刪除。
下標(biāo)(index)參數(shù) start 和 stop 都以 0 為底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。
你也可以使用負數(shù)下標(biāo)，以 -1 表示列表的最后一個元素， -2 表示列表的倒數(shù)第二個元素，以此類推。
當(dāng) <tt class="docutils literal" style="background-color: transparent; font-size: 1.1em; font-family: monospace;">key</tt> 不是列表類型時，返回一個錯誤。
LTRIM 命令通常和 LPUSH 命令或 RPUSH 命令配合使用，舉個例子：
LPUSH log newest_log
LTRIM log 0 99
這個例子模擬了一個日志程序，每次將最新日志 newest_log 放到 log 列表中，并且只保留最新的 100 項。注意當(dāng)這樣使用 LTRIM 命令時，時間復(fù)雜度是O(1)，因為平均情況下，每次只有一個元素被移除。
超出范圍的下標(biāo)
超出范圍的下標(biāo)值不會引起錯誤。
如果 start下標(biāo)比列表的最大下標(biāo) end ( LLEN減去 1 )還要大，或者 start>stop， LTRIM 返回一個空列表(因為 LTRIM 已經(jīng)將整個列表清空)。
如果 stop 下標(biāo)比 end 下標(biāo)還要大，Redis將 stop 的值設(shè)置為 end 。
# 情況 1： 常見情況， start 和 stop 都在列表的索引范圍之內(nèi)
redis> LRANGE alpha 0 -1 # alpha 是一個包含 5 個字符串的列表
1) "h"
2) "e"
3) "l"
4) "l"
5) "o"
redis> LTRIM alpha 1 -1 # 刪除 alpha 列表索引為 0 的元素
OK
redis> LRANGE alpha 0 -1 # "h" 被刪除了
1) "e"
2) "l"
3) "l"
4) "o"
# 情況 2： stop 比列表的最大下標(biāo)還要大
redis> LTRIM alpha 1 10086 # 保留 alpha 列表索引 1 至索引 10086 上的元素
OK
redis> LRANGE alpha 0 -1 # 只有索引 0 上的元素 "e" 被刪除了，其他元素還在
1) "l"
2) "l"
3) "o"
# 情況 3： start 和 stop 都比列表的最大下標(biāo)要大，并且 start < stop
redis> LTRIM alpha 10086 123321
OK
redis> LRANGE alpha 0 -1 # 列表被清空
(empty list or set)
# 情況 4： start 和 stop 都比列表的最大下標(biāo)要大，并且 start > stop
redis> RPUSH new-alpha "h" "e" "l" "l" "o" # 重新建立一個新列表
(integer) 5
redis> LRANGE new-alpha 0 -1
1) "h"
2) "e"
3) "l"
4) "l"
5) "o"
redis> LTRIM new-alpha 123321 10086 # 執(zhí)行 LTRIM
OK
redis> LRANGE new-alpha 0 -1 # 同樣被清空
(empty list or set)
Set(集合)
1.SADD
SADD key member [member ...]
將一個或多個 member 元素加入到集合 key 當(dāng)中，已經(jīng)存在于集合的 member 元素將被忽略。
假如 key 不存在，則創(chuàng)建一個只包含 member 元素作成員的集合。
當(dāng) key 不是集合類型時，返回一個錯誤。
# 添加單個元素
redis> SADD bbs "discuz.net"
(integer) 1
# 添加重復(fù)元素
redis> SADD bbs "discuz.net"
(integer) 0
# 添加多個元素
redis> SADD bbs "tianya.cn" "groups.google.com"
(integer) 2
redis> SMEMBERS bbs
1) "discuz.net"
2) "groups.google.com"
3) "tianya.cn"
2.SCARD
SCARD key
返回集合 key 的基數(shù)(集合中元素的數(shù)量)。
redis> SADD tool pc printer phone
(integer) 3
redis> SCARD tool # 非空集合
(integer) 3
redis> DEL tool
(integer) 1
redis> SCARD tool # 空集合
(integer) 0
3.SDIFF
SDIFF key [key ...]
返回一個集合的全部成員，該集合是所有給定集合之間的差集。
不存在的 key 被視為空集。
redis> SMEMBERS peter's_movies
1) "bet man"
2) "start war"
3) "2012"
redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"
redis> SDIFF peter's_movies joe's_movies
1) "bet man"
2) "start war"
SDIFFSTORE
這個命令的作用和 SDIFF 類似，但它將結(jié)果保存到destination集合，而不是簡單地返回結(jié)果集。
如果 destination集合已經(jīng)存在，則將其覆蓋。
destination可以是key本身。
redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"
redis> SMEMBERS peter's_movies
1) "bet man"
2) "start war"
3) "2012"
redis> SDIFFSTORE joe_diff_peter joe's_movies peter's_movies
(integer) 2
redis> SMEMBERS joe_diff_peter
1) "hi, lady"
2) "Fast Five"
4.SINTER
SINTER key [key ...]
返回一個集合的全部成員，該集合是所有給定集合的交集。
不存在的 key 被視為空集。
當(dāng)給定集合當(dāng)中有一個空集時，結(jié)果也為空集(根據(jù)集合運算定律)。
redis> SMEMBERS group_1
1) "LI LEI"
2) "TOM"
3) "JACK"
redis> SMEMBERS group_2
1) "HAN MEIMEI"
2) "JACK"
redis> SINTER group_1 group_2
1) "JACK"
SINTERSTORE
SINTERSTORE destination key [key ...]
這個命令類似于 SINTER 命令，但它將結(jié)果保存到destination 集合，而不是簡單地返回結(jié)果集。
如果destination 集合已經(jīng)存在，則將其覆蓋。
destination可以是key本身。
redis> SMEMBERS songs
1) "good bye joe"
2) "hello,peter"
redis> SMEMBERS my_songs
1) "good bye joe"
2) "falling"
redis> SINTERSTORE song_interset songs my_songs
(integer) 1
redis> SMEMBERS song_interset
1) "good bye joe"
5.SISMEMBER
SISMEMBER key member
判斷 member 元素是否集合 key 的成員。
redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"
redis> SISMEMBER joe's_movies "bet man"
(integer) 0
redis> SISMEMBER joe's_movies "Fast Five"
(integer) 1
SMEMBERS
SMEMBERS key
返回集合 key 中的所有成員。
不存在的 key 被視為空集合。
# key 不存在或集合為空
redis> EXISTS not_exists_key
(integer) 0
redis> SMEMBERS not_exists_key
(empty list or set)
# 非空集合
redis> SADD language Ruby Python Clojure
(integer) 3
redis> SMEMBERS language
1) "Python"
2) "Ruby"
3) "Clojure"
6.SMOVE
SortedSet(有序集合)
SMOVE source destination member
將 member 元素從 source 集合移動到 destination 集合。
SMOVE 是原子性操作。
如果 source集合不存在或不包含指定的 member元素，則 SMOVE 命令不執(zhí)行任何操作，僅返回 0 。否則， member 元素從 source集合中被移除，并添加到 destination集合中去。
當(dāng)destination 集合已經(jīng)包含member 元素時， SMOVE 命令只是簡單地將
source集合中的member元素刪除。
當(dāng) source 或 destination 不是集合類型時，返回一個錯誤。
redis> SMEMBERS songs
1) "Billie Jean"
2) "Believe Me"
redis> SMEMBERS my_songs
(empty list or set)
redis> SMOVE songs my_songs "Believe Me"
(integer) 1
redis> SMEMBERS songs
1) "Billie Jean"
redis> SMEMBERS my_songs
1) "Believe Me"
7.SPOP
SPOP key
移除并返回集合中的一個隨機元素。
如果只想獲取一個隨機元素，但不想該元素從集合中被移除的話，可以使用 SRANDMEMBER 命令。
redis> SMEMBERS db
1) "MySQL"
2) "MongoDB"
3) "Redis"
redis> SPOP db
"Redis"
redis> SMEMBERS db
1) "MySQL"
2) "MongoDB"
redis> SPOP db
"MySQL"
redis> SMEMBERS db
1) "MongoDB"
8.SUNION
SUNION key [key ...]
返回一個集合的全部成員，該集合是所有給定集合的并集。
不存在的 key 被視為空集。
redis> SMEMBERS songs
1) "Billie Jean"
redis> SMEMBERS my_songs
1) "Believe Me"
redis> SUNION songs my_songs
1) "Billie Jean"
2) "Believe Me"
SUNIONSTORE
SUNIONSTORE destination key [key ...]
這個命令類似于 SUNION 命令，但它將結(jié)果保存到 destination 集合，而不是簡單地返回結(jié)果集。
如果 destination已經(jīng)存在，則將其覆蓋。
destination 可以是 key 本身。
redis> SMEMBERS NoSQL
1) "MongoDB"
2) "Redis"
redis> SMEMBERS SQL
1) "sqlite"
2) "MySQL"
redis> SUNIONSTORE db NoSQL SQL
(integer) 4
redis> SMEMBERS db
1) "MySQL"
2) "sqlite"
3) "MongoDB"
4) "Redis"
1.ZADD
ZADD key score member [[score member] [score member] ...]
將一個或多個 member 元素及其 score 值加入到有序集 key 當(dāng)中。
如果某個 member 已經(jīng)是有序集的成員，那么更新這個 member 的 score 值，并通過重新插入這個 member 元素，來保證該 member 在正確的位置上。
<tt class="docutils literal" style="background-color: transparent; font-size: 1.1em; font-family: monospace;">score</tt> 值可以是整數(shù)值或雙精度浮點數(shù)。
如果 key 不存在，則創(chuàng)建一個空的有序集并執(zhí)行 ZADD 操作。
當(dāng) key 存在但不是有序集類型時，返回一個錯誤。
# 添加單個元素
redis> ZADD page_rank 10 google.com
(integer) 1
# 添加多個元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，且 score 值不變
redis> ZADD page_rank 10 google.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES # 沒有改變
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 添加已存在元素，但是改變 score 值
redis> ZADD page_rank 6 bing.com
(integer) 0
redis> ZRANGE page_rank 0 -1 WITHSCORES # bing.com 元素的 score 值被改變
1) "bing.com"
2) "6"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
2.ZCARD
ZCARD key
返回有序集 key 的基數(shù)。
redis > ZADD salary 2000 tom # 添加一個成員
(integer) 1
redis > ZCARD salary
(integer) 1
redis > ZADD salary 5000 jack # 再添加一個成員
(integer) 1
redis > ZCARD salary
(integer) 2
redis > EXISTS non_exists_key # 對不存在的 key 進行 ZCARD 操作
(integer) 0
redis > ZCARD non_exists_key
(integer) 0
3.ZCOUNT
ZCOUNT key min max
返回有序集 key 中， score 值在 min 和 max 之間(默認包括 score 值等于 min 或 max )的成員的數(shù)量。
關(guān)于參數(shù) min和 max 的詳細使用方法，請參考 ZRANGEBYSCORE 命令。
redis> ZRANGE salary 0 -1 WITHSCORES # 測試數(shù)據(jù)
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"
redis> ZCOUNT salary 2000 5000 # 計算薪水在 2000-5000 之間的人數(shù)
(integer) 3
redis> ZCOUNT salary 3000 5000 # 計算薪水在 3000-5000 之間的人數(shù)
(integer) 2
4.ZRANGE
ZRANGE key start stop [WITHSCORES]
返回有序集 key 中，指定區(qū)間內(nèi)的成員。
其中成員的位置按score 值遞增(從小到大)來排序。
具有相同 score 值的成員按字典序(lexicographical order )來排列。
如果你需要成員按score值遞減(從大到小)來排列，請使用 ZREVRANGE 命令。
下標(biāo)參數(shù) start 和 stop 都以 0 為底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。
你也可以使用負數(shù)下標(biāo)，以 -1 表示最后一個成員， -2 表示倒數(shù)第二個成員，以此類推。
超出范圍的下標(biāo)并不會引起錯誤。
比如說，當(dāng) start的值比有序集的最大下標(biāo)還要大，或是 start > stop 時， ZRANGE 命令只是簡單地返回一個空列表。
另一方面，假如stop參數(shù)的值比有序集的最大下標(biāo)還要大，那么 Redis 將stop 當(dāng)作最大下標(biāo)來處理。
可以通過使用 WITHSCORES 選項，來讓成員和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。
客戶端庫可能會返回一些更復(fù)雜的數(shù)據(jù)類型，比如數(shù)組、元組等。
redis > ZRANGE salary 0 -1 WITHSCORES # 顯示整個有序集成員
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"
redis > ZRANGE salary 1 2 WITHSCORES # 顯示有序集下標(biāo)區(qū)間 1 至 2 的成員
1) "tom"
2) "5000"
3) "boss"
4) "10086"
redis > ZRANGE salary 0 200000 WITHSCORES # 測試 end 下標(biāo)超出最大下標(biāo)時的情況
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"
redis > ZRANGE salary 200000 3000000 WITHSCORES # 測試當(dāng)給定區(qū)間不存在于有序集時的情況
(empty list or set)
5.ZREM
ZREM key member [member ...]
移除有序集 key 中的一個或多個成員，不存在的成員將被忽略。
當(dāng) key 存在但不是有序集類型時，返回一個錯誤。
# 測試數(shù)據(jù)
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
# 移除單個元素
redis> ZREM page_rank google.com
(integer) 1
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
# 移除多個元素
redis> ZREM page_rank baidu.com bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)
# 移除不存在元素
redis> ZREM page_rank non-exists-element
(integer) 0
6.ZUNIONSTORE
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
計算給定的一個或多個有序集的并集，其中給定 key 的數(shù)量必須以 numkeys 參數(shù)指定，并將該并集(結(jié)果集)儲存到 destination 。
默認情況下，結(jié)果集中某個成員的 score 值是所有給定集下該成員 score 值之 和 。
WEIGHTS
使用 WEIGHTS 選項，你可以為 每個 給定有序集 分別 指定一個乘法因子(multiplication factor)，每個給定有序集的所有成員的 score 值在傳遞給聚合函數(shù)(aggregation function)之前都要先乘以該有序集的因子。
如果沒有指定 WEIGHTS 選項，乘法因子默認設(shè)置為 1 。
AGGREGATE
使用 AGGREGATE 選項，你可以指定并集的結(jié)果集的聚合方式。
默認使用的參數(shù) SUM ，可以將所有集合中某個成員的 score 值之 和 作為結(jié)果集中該成員的 score 值；使用參數(shù) MIN ，可以將所有集合中某個成員的 最小 score 值作為結(jié)果集中該成員的 score 值；而參數(shù) MAX 則是將所有集合中某個成員的 最大 score 值作為結(jié)果集中該成員的 score 值。
redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"
redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3 # 公司決定加薪。。。除了程序員。。。
(integer) 6
redis> 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"
7.ZINTERSTORE
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
計算給定的一個或多個有序集的交集，其中給定 key 的數(shù)量必須以 numkeys 參數(shù)指定，并將該交集(結(jié)果集)儲存到 destination 。
默認情況下，結(jié)果集中某個成員的 score 值是所有給定集下該成員 score 值之和.
關(guān)于 WEIGHTS和 AGGREGATE選項的描述，參見 ZUNIONSTORE 命令。
redis > ZADD mid_test 70 "Li Lei"
(integer) 1
redis > ZADD mid_test 70 "Han Meimei"
(integer) 1
redis > ZADD mid_test 99.5 "Tom"
(integer) 1
redis > ZADD fin_test 88 "Li Lei"
(integer) 1
redis > ZADD fin_test 75 "Han Meimei"
(integer) 1
redis > ZADD fin_test 99.5 "Tom"
(integer) 1
redis > ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3
redis > ZRANGE sum_point 0 -1 WITHSCORES # 顯示有序集內(nèi)所有成員及其 score 值
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"
