總結redis第二部分(redis經常使用命令、高級命令特性以及與java代碼的結合)

時間  2020-01-10
標籤 總結 redis 第二 部分 經常 使用 命令 高級 特性 以及 java 代碼 結合 欄目 Redis 简体版
原文   原文鏈接

 

6、redis多數據類型介紹(經常使用命令)

六、1前提操做

#若是前面的redis環境沒搭好，那麼能夠先暫時在
「http://try.redis.io/」中實踐redis命令部分。
 
#爲了測試方便，把redis登陸密碼暫時撤銷
 
#redis一共分爲五種基本數據類型:String,Hash,List,Set,ZSet
#全部命令均可以到「http://www.redis.cn/commands.html」  去搜索到。
#首先因爲redis是一個基於key-value鍵值對的持久化數據庫存儲系統，因此要先定義key值的規範，最好堅持使用一種模式，例如:」object-type:id:field」就是個不錯的主意，像」user:1000:password」，再好比在字段上加一個點」comment:1234:reply.to」。
 
#檢查redis是否啓動
[root@redis conf]# lsof -i:6379
COMMAND    PIDUSER   FD   TYPE DEVICE SIZE/OFF NODE NAME
redis-ser 6616 root   4u  IPv6  21770     0t0  TCP *:6379 (LISTEN)
redis-ser 6616 root   5u  IPv4  21772     0t0  TCP *:6379 (LISTEN)
好比：
[root@redis conf]# redis-cli set user:01:passwd 1000
OK
[root@redis conf]# redis-cli get user:01:passwd
"1000"
#上述操做跟下述操做是一致的：
[root@redis conf]# redis-cli
127.0.0.1:6379> set user:01:passwd 1000
OK
127.0.0.1:6379> get user:01:passwd
"1000"
 
#這只是一個操做示例，看不懂接着往下學習便可。
 
#查找命令使用技巧
127.0.0.1:6379>help(加一個英文空格,按tab鍵)
#會自動出現下述內容
127.0.0.1:6379>help @string
#可修改@後的命令查看須要使用的命令操做


 

 

六、2字符串類型(string)

六、二、1簡介

  String類型是包含不少種類型的特殊類型，而且是二進制安全的。好比序列化的對象進行存儲，好比一張圖片進行二進制存儲，好比一個簡單的字符串，數值等等。html

   String類型是最簡單的redis類型。若是隻使用這種類型，redis就是一個可持久化的memcached服務器(注:memcached的數據僅保存在內存中，服務器重啓後，數據將丟失。)java

  一般用set和get能夠來設置和獲取字符串的值。值能夠是任何種類的字符串（包括二進制數據），例如你能夠在一個鍵下保存一副jpeg圖片，值的長度不能超過1GB。linux

 

六、二、2操做

六、二、二、1第一部分
set
#設置值，獲取值
#set將鍵key設定爲指定的字符串值。若是key已經保存了一個值，那麼這個操做會直接覆蓋原來的值，而且忽略原始類型。當set命令執行成功以後，以前設置的過時時間都將失效。
#get返回key的value。若是key不存在，返回特殊值nil。若是key的value不是string，就返回錯誤，由於GET只處理string類型的values。
127.0.0.1:6379> set name nameval
OK
127.0.0.1:6379> get name
"nameval"
 
#注意一個問題，當set時，key值後面的value包含空格，那麼要把整個value用引號包起來，否則set不能正確識別。
127.0.0.1:6379> set name name1 val1
(error) ERR syntax error
127.0.0.1:6379> set name 'name1 val1'
OK
127.0.0.1:6379> get name
"name1 val1"
127.0.0.1:6379> set name "name2 val2"
OK
127.0.0.1:6379> get name
"name2 val2"


 

 

del
#刪除值
#若是刪除的key不存在，則直接忽略。返回值指被刪除的keys的數量。
#時間複雜度(參考百度百科):O(N)將要被刪除的key的數量，當刪除的key是字符串之外的複雜數據時，好比list,set,zset,hash刪除這個key的時間複雜度是O(1)。
127.0.0.1:6379> del name
(integer) 1
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> keys *
(empty list or set)
#刪除一個不存在的key
127.0.0.1:6379> del test
(integer) 0


 

setnx
#setnx
#將key設置爲value，若是key不存在，這種狀況下等同於set命令。當key存在時，什麼也不作。
127.0.0.1:6379> setnx name nameval
(integer) 1#若是key被設置了返回1
127.0.0.1:6379> setnx name nameval
(integer) 0#若是key已經存在了返回0
127.0.0.1:6379> get name
"nameval"


 

setex
#setex
#設置key對應字符串value，而且設置key在給定的seconds時間以後超時過時。這個命令等效於下述兩個命令:
set testkey value
expire testkey seconds
#setex是原子的，也能夠把上述兩個命令放在MULTI/EXEC塊中執行的方式重現。相比連續執行上面兩個命令，它更快，由於當redis當作緩存使用時，這個操做更加經常使用。
127.0.0.1:6379> setex name 5 namevalue
OK
127.0.0.1:6379> get name
"namevalue"
127.0.0.1:6379> get name
(nil)


 

setrange
#setrange
#這個命令的做用是覆蓋key對應的string的一部分，從指定的offset開始，覆蓋value的長度。若是offset比當前key對應string還長，那麼這個string後面就補0以達到offset。不存在的keys被認爲是空字符串，因此這個命令能夠確保key有一個足夠大的字符串，能在offset處設置value。
#我的理解：開始位置是0，從第幾位開始替換到最後，不足的補零。
127.0.0.1:6379> set name testname@name.com
OK
127.0.0.1:6379> get name
"testname@name.com"
127.0.0.1:6379> SETRANGE name 9 test.com
(integer) 17
127.0.0.1:6379> get name
"testname@test.com"
127.0.0.1:6379> setrange name 17 other
(integer) 22
127.0.0.1:6379> get name
"testname@test.comother"
#補零操做
127.0.0.1:6379> setrange name 30 meiyou
(integer) 36
127.0.0.1:6379> get name
"testname@test.comother\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00meiyou"
#不存在的key
127.0.0.1:6379> setrange name2 10 other
(integer) 15
127.0.0.1:6379> get name2
"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00other"


 

getrange
#getrange
#返回key對應的字符串value的子串，自個子串是由start和end位移決定的（二者都在string內）。能夠用負的位移來表示從string尾部開始數的下標。因此-1就是最後一個字符，-2就是倒數第二個，以此類推。這個函數超出範圍的請求時，都把結果限制在string內。
127.0.0.1:6379> set name "this is a string"
OK
127.0.0.1:6379> GETRANGE name 0 3
"this"
127.0.0.1:6379> getrange name -3 -1
"ing"
127.0.0.1:6379> getrange name 0 -1
"this is a string"
127.0.0.1:6379> getrange name 10 100
"string"


 

 

六、二、二、2第二部分
incr
#incr
#對存儲在指定key的數值執行原子的加1操做。
#若是指定的key不存在，那麼在執行incr操做以前，會先把它的值設定爲0.
#若是指定的key中存儲的值不是字符串類型或者存儲的字符串類型不能表示爲一個整數，那麼執行這個命令時服務器會返回一個錯誤（(error) ERR value is not an integer or out of range）。
#這個操做僅限於64位的有符號整型數據。
#注意：因爲redis並無一個明確的類型來表示整型數據，因此這個操做是一個字符串操做。執行這個操做的時候，key對應存儲的字符串被解析爲10進制的64位有符號整型數據。
#事實上，redis內部採用整數形式來存儲對應的整數值，因此對該類字符串值其實是用整數保存，也就不存在存儲整數的字符串表示所帶來的額外消耗。
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set age1 10
OK
127.0.0.1:6379> incr age1
(integer) 11
127.0.0.1:6379> get age1
"11"
127.0.0.1:6379> incr age2
(integer) 1
127.0.0.1:6379> get age2
"1"
127.0.0.1:6379> keys *
1) "age2"
2) "age1"
 
#incr的原子操做是說即便多個客戶端對同一個key發出incr命令，也決不會致使競爭的狀況，例如以下狀況永遠不可能發生：客戶端1和客戶端2同時讀出10，他們倆都對其加到11，而後將新值設置爲11，最終值必定爲12.read-increment-set操做完成時，其餘客戶端不會在同一時間執行任何命令。
#對字符串，get和set命令，它爲key設置新值並返回原值。用處是，例如：你的系統每當有新用戶訪問時就用incr命令操做一個redis key。你但願每小時對這個信息收集一次，那麼就能夠get和set這個key，讀取原值並賦值爲0。


 

decr
#decr
#對key對應的數字作減一操做。若是key不存在，那麼在操做以前，這個key對應的值會被設定爲0。若是key有一個錯誤類型的value或者是一個不能表示成數字的字符串，就返回錯誤。這個操做最大支持在64位有符號的整型數字。
127.0.0.1:6379> get age1
"11"
127.0.0.1:6379> decr age1
(integer) 10
127.0.0.1:6379> get age1
"10"
127.0.0.1:6379> decr age4
(integer) -1
127.0.0.1:6379> get age4
"-1"


 

incrby
#incrby
#將key進行遞增。若是key不存在，操做以前，key就會被置爲0.若是key的value類型錯誤或者是個不能表示成數字的字符串，就返回錯誤。這個操做最多支持64位有符號的×××數字。
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set age 10
OK
127.0.0.1:6379> get age
"10"
127.0.0.1:6379> incrby age 5
(integer) 15
127.0.0.1:6379> get age
"15"
127.0.0.1:6379> incrby age2 2
(integer) 2
127.0.0.1:6379> get age2
"2"
decrby
#decrby
#將key對應的數字遞減。若是key不存在，操做以前，key就會被置爲0.若是key的value類型錯誤或者是個不能表示成數字的字符串，就返回錯誤。這個操做最多支持64位有符號的×××數字。
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set age 10
OK
127.0.0.1:6379> decrby age 5
(integer) 5
127.0.0.1:6379> get age
"5"
127.0.0.1:6379> decrby age2 5
(integer) -5
127.0.0.1:6379> get age2
"-5"


 

mset
#mset
#對應給定的keys到他們對應的values上。Mset會用新的value替代已經存在的value，就像普通的set命令同樣。若是你不想覆蓋已經存在的values，那麼須要參考msetnx.
#mset是原子性的，因此全部給定的keys是一次性set的。客戶端不可能看到這種一部分keys被更新而另外的沒有改變的狀況。
#其返回值老是OK，由於mset不會失敗。
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> mset age1 age1val age2 age2val age3age3val
OK
127.0.0.1:6379> keys *
1) "age2"
2) "age1"
3) "age3"


 

mget
#mget
#返回全部指定的key的value。對於每一個不對應string或者不存在的key，都返回特殊值nil。整所以如此，這個操做歷來不會失敗。
127.0.0.1:6379> keys *
1) "age2"
2) "age1"
3) "age3"
127.0.0.1:6379> mget age1 age2 age3 age4
1) "age1val"
2) "age2val"
3) "age3val"
4) (nil)


 

 

msetnx
#msetnx
#對應給定的keys到他們相應的values上。只要有一個values已經存在，MSETNX一個操做都不會執行。因爲這種特性，MSETNX能夠實現要麼全部的操做都成功，要麼一個都不執行，這個能夠用來設置不一樣的key，來表示一個惟一的對象的不一樣字段。MSETNX是原子的，因此全部給定的keys是一次性set的。客戶端不可能看到這種一部分keys被更新而另外的沒有改變的狀況。
#返回值，1若是全部的key被set，0若是沒有key被set（至少其中有一個key是存在的。）
127.0.0.1:6379> keys *
1) "age2"
2) "age1"
3) "age3"
127.0.0.1:6379> mget age1 age2 age3
1) "age1val"
2) "age2val"
3) "age3val"
127.0.0.1:6379> msetnx age1 age11val age2 age22val
(integer) 0
127.0.0.1:6379> mget age1 age2
1) "age1val"
2) "age2val"
127.0.0.1:6379> msetnx age1 age11val age2 age22valage4 age4val
(integer) 0
127.0.0.1:6379> mget age1 age2 age4
1) "age1val"
2) "age2val"
3) (nil)
127.0.0.1:6379> msetnx age4 age4val age5 age5val
(integer) 1
127.0.0.1:6379> mget age4 age5
1) "age4val"
2) "age5val"


 

 

六、3列表類型(list)

六、三、1簡介

    List類型是一個鏈表結構的集合，其主要功能有push，pop，獲取元素等。更詳細的說，list類型是一個雙端鏈表結構，咱們能夠經過相關操做進行集合的頭部或者尾部添加刪除元素，list的設計很是簡單精巧，既能夠做爲棧（後進先出），又能夠做爲隊列（先進先出），知足絕大多數要求。git

    通常意義上講，列表就是有序元素的序列：10，20,1,2,3就是一個列表。但用數組實現的list和用linkedlist實現的list，在屬性方面大不相同。redis

    Redis list基於linkedlist實現，這意味着即便在一個list中有數百萬個元素，在頭部或尾部添加一個元素的操做，其時間複雜度也是常數級別的。用lpush命令在十個元素的list頭部添加新元素和在千萬元素list頭部添加新元素的速度相同。數據庫

    可是，在數組實現的list中利用索引訪問元素的速度極快，而一樣的操做在linkedlist實現的list上沒有那麼快。編程

    Redislist用linkedlist實現的緣由是：對於數據庫系統來講，相當重要的特性是：能很是快的在很大的列表上添加元素，另外一個重要因素是，redislist能在常數時間取得常數長度。api

    List可別用來實現聊天系統，還能夠做爲不一樣進程間傳遞消息的隊列。關鍵是，你能夠每次都以原先添加的順序訪問數據。這不須要任何SQL ORDER BY操做，將會很是快，也會很容易擴展到百萬級別元素的規模。數組

    例如在評級系統中，好比社會化新聞網站reddit.com，你能夠把每一個新提交的連接添加到一個list，用lrange可簡單的對結果分頁。緩存

    在博客引擎實現中，你可爲每篇日誌設置一個list，在該list中推入進博客評論等。

    向redis list壓入ID而不是實際的數據。

 

六、三、2操做

六、三、二、1第一部分
lpush

#棧部分

#lpush(從頭部添加元素，先進後出-棧)

#將全部指定的值插入到存於key的列表的頭部。若是key不存在，那麼在進行push操做前會建立一個空列表。若是key對應的值不是一個list的話，那麼會返回一個錯誤。可使用一個命令把多個元素push進入列表，只需在命令末尾加上多個指定的參數。元素是從最左端的到最右端的、一個接一個的被插入到list的頭部。因此對於這個命令例子:lpush list a b c ，返回的列表是c爲第一個元素，b爲第二個元素，a爲第三個元素。返回值爲在push操做後的list長度。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> lpush list1 val1
(integer) 1
127.0.0.1:6379> lpush list1 val2
(integer) 2
127.0.0.1:6379> lpush list1 val3
(integer) 3
127.0.0.1:6379> keys *
1) "list1"
127.0.0.1:6379> lrange list1 0 -1(表示從頭取到末尾)
1) "val3"
2) "val2"
3) "val1"
127.0.0.1:6379> lpush list2 val1 val2 val3
(integer) 3
127.0.0.1:6379> lrange list2 0 -1
1) "val3"
2) "val2"
3) "val1"


 

rpush

#隊列部分(從尾部加入元素，先進先出-隊列)

#向存於key的列表的尾部插入全部指定的值。若是key不存在，那麼會建立一個空的列表而後再進行push操做。當key保存的不是一個列表，那麼會返回一個錯誤。可使用一個命令把多個元素打入隊列。元素是從左到右一個接一個從列表尾部插入。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> rpush list1 val1 val2 val3
(integer) 3
127.0.0.1:6379> lrange list1 0 -1
1) "val1"
2) "val2"
3) "val3"
127.0.0.1:6379> rpush list2 val1 
(integer) 1
127.0.0.1:6379> rpush list2 val12
(integer) 2
127.0.0.1:6379> rpush list2 val3
(integer) 3
127.0.0.1:6379> lrange list2 0 -1
1) "val1"
2) "val12"
3) "val3"


 

lrange

#lrange(格式:lrange key start stop)

#返回存儲在key的列表裏指定範圍內的元素。Start和end偏移量都是基於0的下標，即list的第一個元素下標是0(list的開頭)，第二個元素是下標1，以此類推。偏移量也能夠是負數，表示偏移量是從list尾部開始計數。例如，-1表示列表的最後一個元素，-2是倒數第二個，以此類推。

#在不一樣的編程語言裏，關於求範圍函數的一致性：須要注意的是，若是你有一個list，裏面的元素是0到100，那麼lrange list 0 10這個命令會返回11個元素，即最右邊的那個元素也會包含在內。在你使用的編程語言裏，這一點多是也可能不是跟那些求範圍有關的函數都是一致的。

#超過範圍的下標：當下標超過list範圍的時候不會產生error。若是start比list尾部下標大的時候，會返回一個空列表。若是stop比list的實際尾部大的時候，redis會當它是list的最後一個元素的下標。

127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val3"
4) "list1val2"
5) "list1val1"
127.0.0.1:6379> lrange list1 -3 -1
1) "list1val3"
2) "list1val2"
3) "list1val1"
127.0.0.1:6379> lrange list1 0 -3
1) "list1val5"
2) "list1val4"
3) "list1val3"
127.0.0.1:6379> lrange list1 0 3
1) "list1val5"
2) "list1val4"
3) "list1val3"
4) "list1val2"
127.0.0.1:6379> lrange list1 0 10
1) "list1val5"
2) "list1val4"
3) "list1val3"
4) "list1val2"
5) "list1val1"


 

 

linsert

#linsert(格式:linsert key before|after pivot value)

#把value插入存於key的列表中在基準值pivot的前面或後面。

#當key不存在時，這個list會被看作是空list，任何操做都不會發生。

#在key存在，但保存的不是一個list的時候，會返回error

#返回值爲通過插入操做後的list長度，或者當pivot值找不到的時候返回-1.

127.0.0.1:6379> keys *
1) "list1"
127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val3"
4) "list1val2"
5) "list1val1"
127.0.0.1:6379> linsert list1 before list1val3 list1val31
(integer) 6
127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val31"
4) "list1val3"
5) "list1val2"
6) "list1val1"
127.0.0.1:6379> linsert list1 after list1val3list1val32
(integer) 7
127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val31"
4) "list1val3"
5) "list1val32"
6) "list1val2"
7) "list1val1"
127.0.0.1:6379> linsert list1 before testval values
(integer) -1
127.0.0.1:6379> linsert list2 before testval values
(integer) 0
127.0.0.1:6379> lrange list2 0 -1
(empty list or set)


 

 

#知識延伸，

關於棧與隊列的知識點，在本身博客中有寫到

「http://ylcodes01.blog.51cto.com/5607366/1867337」

 

Linkedlist是雙向鏈表，插入快，查詢慢，具體描述參考Java編程思想第四版。

雙向鏈表的操做能夠查考java中「Queue的dequeue方法」，它能夠操做鏈表的頭部和尾部。

 

 

六、三、二、2第二部分

 

lset

#lset(將指定下標的元素替換掉)

#設置index位置的list元素的值爲value。當index超出範圍時會返回一個value。

127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val31"
4) "list1val3"
5) "list1val32"
6) "list1val2"
7) "list1val1"
127.0.0.1:6379> lset list1 7 list1val7
(error) ERR index out of range
127.0.0.1:6379> lset list1 6 list1val6
OK
127.0.0.1:6379> lrange list1 -1 -1
1) "list1val6"
127.0.0.1:6379> lrange list1 0 -1
1) "list1val5"
2) "list1val4"
3) "list1val31"
4) "list1val3"
5) "list1val32"
6) "list1val2"
7) "list1val6"


 

lrem

#lrem(刪除元素，返回刪除的個數)

#從存於key的列表裏移除前count次出現的值爲value的元素。這個count參數經過如下幾種方式影響這個操做：

Count>0:從頭往尾移除值爲value的元素。

（我的理解是從頭至尾刪除前幾count個爲value的元素。）

Count<0:< span="">從尾往頭移除值爲value的元素。

（我的理解是從尾往頭刪除前幾count個爲value的元素。）

Count=0:移除全部值爲value的元素。

（我的理解是刪除全部爲value的元素。）

好比，lrem list -2 「hello」，會從存於list的列表裏移除最後兩個出現的hello，須要注意的是，若是list裏沒有存在key就會被當作空list處理，因此當key不存在的時候，這個命令返回0.

#返回值爲被移除的元素個數。

 

127.0.0.1:6379> lrange list 0 -1
 1)"list1"
 2)"list1"
 3)"list2"
 4)"list3"
 5)"list4"
 6)"list5"
 7)"list6"
 8)"list7"
 9)"list8"
10) "list1"
11) "list1"
12) "list2"
13) "list3"
14) "list4"
15) "list2"
16) "list2"
17) "list5"
18) "list2"
19) "list2"
20) "list6"
21) "list7"
22) "list7"
23) "list8"
127.0.0.1:6379> lrem list 2 list2
(integer) 2
127.0.0.1:6379> lrange list 0 -1
 1)"list1"
 2)"list1"
 3)"list3"
 4)"list4"
 5)"list5"
 6)"list6"
 7)"list7"
 8)"list8"
 9)"list1"
10) "list1"
11) "list3"
12) "list4"
13) "list2"
14) "list2"
15) "list5"
16) "list2"
17) "list2"
18) "list6"
19) "list7"
20) "list7"
21) "list8"
 
127.0.0.1:6379> lrem list -3 list2
(integer) 3
127.0.0.1:6379> lrange list 0 -1
 1)"list1"
 2)"list1"
 3)"list3"
 4)"list4"
 5)"list5"
 6)"list6"
 7)"list7"
 8)"list8"
 9)"list1"
10) "list1"
11) "list3"
12) "list4"
13) "list2"
14) "list5"
15) "list6"
16) "list7"
17) "list7"
18) "list8"
 
127.0.0.1:6379> lrem list 0 list7
(integer) 3
127.0.0.1:6379> lrange list 0 -1
 1)"list1"
 2)"list1"
 3)"list3"
 4)"list4"
 5)"list5"
 6)"list6"
 7)"list8"
 8)"list1"
 9)"list1"
10) "list3"
11) "list4"
12) "list2"
13) "list5"
14) "list6"
15) "list8"


 

 

六、三、二、3第三部分

 

ltrim

#ltrim

#修剪(trim)一個已經存在的list，這樣list就會只包含指定範圍的指定元素start和stop都是從0開始計數的，這裏的0是列表裏的第一個元素（表頭），1是第二個元素，以此類推。

#例如:ltrim foobar 0 2將會對存儲在foobar的列表進行修剪，只保留列表裏的前三個元素。

#start和end也能夠用負數來表示與表尾的偏移量，好比-1表示列表裏的最後一個元素，-2表示列表裏的倒數第二個元素，以此類推。

#超過範圍的下標並不會產生錯誤:若是start超過列表尾部，或者start>end，結果會是列表變成空表（即該key會被移除）。若是end超過列表尾部，redis會將其當作列表的最後一個元素。

#ltrim的一個常見用法是和lpush/rpush一塊兒使用，例如:

LPUSH mylist someelement

LTRIM mylist 0 99

#這一對命令會將一個新的元素push進列表裏，並保證該列表不會增加到超過100個元素。這個是頗有用的，好比當用redis來存儲日誌，須要特別注意的是，當用這種方式來使用ltrim的時候，操做複雜度是O(1)，由於平均狀況下，每次只有一個元素會被移除 。

 

127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> lrange list 0 -1
1) "list1"
2) "list2"
3) "list3"
4) "list4"
5) "list5"
6) "list6"
7) "list7"
8) "list8"
 
127.0.0.1:6379> ltrim list 10 9
OK
127.0.0.1:6379> lrange list 0 -1
(empty list or set)
127.0.0.1:6379> rpush list list1 list2 list3 list4list5 list6 list7 list8
(integer) 8
127.0.0.1:6379> lrange list 0 -1
1) "list1"
2) "list2"
3) "list3"
4) "list4"
5) "list5"
6) "list6"
7) "list7"
8) "list8"
 
127.0.0.1:6379> ltrim list -3 -1
OK
127.0.0.1:6379> lrange list 0 -1
1) "list6"
2) "list7"
3) "list8"
 
127.0.0.1:6379> lrange list 0 -1
1) "list1"
2) "list2"
3) "list3"
4) "list4"
5) "list5"
6) "list6"
7) "list7"
8) "list8"
9) "list9"
127.0.0.1:6379> ltrim list 1 5
OK
127.0.0.1:6379> lrange list 0 -1
1) "list2"
2) "list3"
3) "list4"
4) "list5"
5) "list6"
 
127.0.0.1:6379> ltrim list 4 10
OK
127.0.0.1:6379> lrange list 0 -1
1) "list6"


 

 

lpop

#lpop(從list的頭部刪除元素，並返回刪除元素)

#移除而且返回key對應list的第一個元素

#返回值:返回第一個元素的值，或者當key不存在時返回nil

127.0.0.1:6379> lrange list 0 -1
1) "list1"
2) "list2"
3) "list3"
4) "list4"
5) "list5"
6) "list6"
7) "list7"
8) "list8"
9) "list9"
127.0.0.1:6379> lpop list
"list1"
127.0.0.1:6379> lrange list 0 -1
1) "list2"
2) "list3"
3) "list4"
4) "list5"
5) "list6"
6) "list7"
7) "list8"
8) "list9"
127.0.0.1:6379> del list
(integer) 1
127.0.0.1:6379> lpop list 
(nil)


 

rpop

#rpop(從list的尾部刪除元素，並返回刪除元素)

#移除並返回存於key的list的最後一個元素

#返回值:最後一個元素的值，或者當key不存在時返回nil

127.0.0.1:6379> rpop list 
"list9"
127.0.0.1:6379> lrange list 0 -1
1) "list2"
2) "list3"
3) "list4"
4) "list5"
5) "list6"
6) "list7"
7) "list8"
127.0.0.1:6379> rpop list
(nil)


 

六、三、二、4第四部分

 

rpoplpush

#rpoplpush(格式: RPOPLPUSH source destination)

#原子性的返回並移除存儲在source列表的最後一個元素(列表尾部元素)，並把該元素放入存儲在destination的列表的第一個元素位置(列表頭部)。

例如：假設 source 存儲着列表 a,b,c，destination存儲着列表 x,y,z。 執行RPOPLPUSH 獲得的結果是 source 保存着列表a,b ，而 destination 保存着列表c,x,y,z。

#若是source不存在，那麼會返回nil值，而且不會執行任何操做。若是source和destination是一樣的，那麼這個操做等同於移除列表最後一個元素而且把該元素放在列表頭部，因此這個命令也能夠當作是一個旋轉列表的命令。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> rpush list1 list1val1 list1val2list1val3
(integer) 3
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
3) "list1val3"
127.0.0.1:6379> rpush list2 list2val1 list2val2list2val3
(integer) 3
127.0.0.1:6379> lrange list2 0 -1
1) "list2val1"
2) "list2val2"
3) "list2val3"
127.0.0.1:6379> rpoplpush list1 list2
"list1val3"
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
127.0.0.1:6379> lrange list2 0 -1
1) "list1val3"
2) "list2val1"
3) "list2val2"
4) "list2val3"
127.0.0.1:6379> del list1
(integer) 1
127.0.0.1:6379> rpoplpush list1 list2
(nil)
127.0.0.1:6379> del list2
(integer) 1
127.0.0.1:6379> rpoplpush list1 list2
(nil)
127.0.0.1:6379> rpush list1 list1val1 list1val2list1val3
(integer) 3
127.0.0.1:6379> rpoplpush list1 list2
"list1val3"
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
127.0.0.1:6379> lrange list2 0 -1
1) "list1val3"


 

lindex

#lindex(返回名稱爲key的list中index位置的元素)

#返回列表裏的元素索引index存儲在key裏面。下標是從0開始索引的，因此0是表示第一個元素，1表示第二個元素，並以此類推。負數索引用於指定從列表尾部開始索引的元素。在這種方法下，-1表示最後一個元素，-2表示倒數第二個元素，並依次往前推。當key的位置不是一個列表的時候，會返回一個error。

#返回值：請求的對應元素，或者當index超過範圍的時候返回nil。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> rpush list1 list1val1 list1val2list1val3
(integer) 3
127.0.0.1:6379>
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
3) "list1val3"
127.0.0.1:6379> lindex list1 1
"list1val2"
127.0.0.1:6379> lindex list1 -1
"list1val3"
127.0.0.1:6379> lindex list1 -3
"list1val1"
127.0.0.1:6379> lindex list1 -4
(nil)
127.0.0.1:6379> lindex list1 5
(nil)
127.0.0.1:6379> lindex list2 5
(nil)
127.0.0.1:6379> keys *
1) "list1"
127.0.0.1:6379> lindex list2 test
(nil)


 

llen

#llen(返回元素的個數)

#返回存儲在key裏的list長度。若是key不存在，那麼就被看作是空list，而且返回長度爲0.當存儲在key裏的值不是一個list的話，會返回error 。

127.0.0.1:6379> keys *
1) "list1"
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
3) "list1val3"
127.0.0.1:6379> llen list1
(integer) 3
127.0.0.1:6379> llen list2
(integer) 0


 

 

六、4set無序集合和zset有序集合

六、四、1簡介

set集合是string類型的無需集合，set是經過hashtable實現的，其元素是二進制安全的字符串。Set集合不容許重複元素。

集合特別適合表現對象之間的關係。例如用redis集合能夠很容易實現標籤功能。

 

六、四、2操做

六、四、二、1set無序集合部分
六、四、二、一、1第一部分

 

sadd

#sadd

#添加一個或多個指定的member元素到集合的key中，指定的一個或者多個元素member若是已經在集合key中存在則忽略，若是集合key不存在，則新建集合key，並添加member元素到集合key中。若是key的類型不是集合則返回錯誤。

#返回值:返回新成功添加到集合裏元素的數量，不包括已經存在於集合中的元素。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> sadd set1 set1val1
(integer) 1
127.0.0.1:6379> sadd set1 set1val2 set1val3
(integer) 2
127.0.0.1:6379> smembers set1
1) "set1val3"
2) "set1val2"
3) "set1val1"
127.0.0.1:6379> rpush list1 list1val1 list1val2
(integer) 2
127.0.0.1:6379> lrange list1 0 -1
1) "list1val1"
2) "list1val2"
127.0.0.1:6379> sadd list1 testval
(error) WRONGTYPE Operation against a key holding thewrong kind of value
127.0.0.1:6379> smembers list1
(error) WRONGTYPE Operation against a key holding thewrong kind of value
127.0.0.1:6379>


 

smembers

#smembers
#返回key集合全部的元素
127.0.0.1:6379> smembers set1
1) "set1val3"
2) "set1val2"
3) "set1val1"


 

srem

#srem

#在key集合中移除指定的元素，若是指定的元素不是key集合中的元素則忽略，若是key集合不存在則被視爲一個空的集合，該命令返回0.若是key的類型不是一個集合，則返回錯誤。

#返回值：從集合中移除元素的個數，不包括不存在的成員。

127.0.0.1:6379> smembers set1
1) "set1val3"
2) "set1val2"
3) "set1val1"
127.0.0.1:6379> srem set1 set1val2
(integer) 1
127.0.0.1:6379> smembers set1
1) "set1val3"
2) "set1val1"
127.0.0.1:6379> srem set1 set1val1 set1val3
(integer) 2
127.0.0.1:6379> smembers set1
(empty list or set)
127.0.0.1:6379> sadd set2 set2val1
(integer) 1
127.0.0.1:6379> srem set2 testval
(integer) 0
127.0.0.1:6379> srem set3 testval
(integer) 0


 

spop

#spop

#隨機返回被刪除的key

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> sadd set1 set1val1 set1val2 set1val3set1val4 set1val5
(integer) 5
127.0.0.1:6379> smembers set1
1) "set1val4"
2) "set1val3"
3) "set1val2"
4) "set1val1"
5) "set1val5"
127.0.0.1:6379> spop set1
"set1val4"
127.0.0.1:6379> smembers set1
1) "set1val1"
2) "set1val2"
3) "set1val3"
4) "set1val5"
127.0.0.1:6379> spop set2
(nil)
127.0.0.1:6379> rpush list1 list1val1
(integer) 1
127.0.0.1:6379> spop list1
(error) WRONGTYPE Operation against a key holding thewrong kind of value


 

 

sdfii

#sdiff(返回兩個集合的不一樣元素，哪一個集合在前面，就以哪一個集合爲準)

#返回一個集合與給定集合的差集的元素。不存在的key認爲是空集

#返回值爲結果集的元素

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> sadd set1 a b c
(integer) 3
127.0.0.1:6379> sadd set2 c d e
(integer) 3
127.0.0.1:6379> smembers set1 set2
(error) ERR wrong number of arguments for 'smembers'command
127.0.0.1:6379> smembers set1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> sdiff set1 set2
1) "a"
2) "b"
127.0.0.1:6379> sdiff set1 set3
1) "a"
2) "c"
3) "b"
127.0.0.1:6379> sdiff set3 set1
(empty list or set)
127.0.0.1:6379> sdiff set3 set4
(empty list or set)
127.0.0.1:6379> rpush list1 list1val1 list1val2
(integer) 2
127.0.0.1:6379> sdiff set1 list1
(error) WRONGTYPE Operation against a key holding thewrong kind of value
127.0.0.1:6379> sdiff list1 set4
(error) WRONGTYPE Operation against a key holding thewrong kind of value


 

sdfiistore

#sdiffstore

#將返回的不一樣元素存儲到另一個集合裏(下面例子以set1爲準，參考上述sdiff)

127.0.0.1:6379> keys *
1) "set2"
2) "set1"
127.0.0.1:6379> smembers set1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> sdiffstore set3 set1 set2
(integer) 2
127.0.0.1:6379> smembers set3
1) "a"
2) "b"
127.0.0.1:6379> sdiffstore set4 set2 set1
(integer) 2
127.0.0.1:6379> smembers set4
1) "e"
2) "d"
127.0.0.1:6379> sdiffstore set5 set6 set7
(integer) 0
127.0.0.1:6379> keys *
1) "set4"
2) "set3"
3) "set2"
4) "set1"


 

 

六、四、二、一、2第二部分

 

sinter

#sinter

#返回指定的全部集合的成員的交集。若是key不存在則被認爲是一個空的集合，當給定的集合爲空的時候，結果也爲空(一個集合爲空，結果一直爲空)

127.0.0.1:6379> keys *
1) "set2"
2) "set1"
127.0.0.1:6379> smembers set1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> sinter set1 set2
1) "c"
127.0.0.1:6379> sinter set2 set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> sinter set2 set1
1) "c"
127.0.0.1:6379> sinter set1 set3
(empty list or set)
127.0.0.1:6379> sinter set3 set1
(empty list or set)
127.0.0.1:6379> sinter set3 set4
(empty list or set)


 

sinterstore

#sinterstore

#把兩個集合的結果集結果保存到一個新的集合中。若是這個新的集合是已經存在的，那麼這個新的集合則會被重寫。

#返回值爲結果集中成員的個數。

127.0.0.1:6379> keys *
1) "set2"
2) "set1"
127.0.0.1:6379> sinterstore set3 set1 set2
(integer) 1
127.0.0.1:6379> smembers set3
1) "c"
127.0.0.1:6379> sadd set4 a b d
(integer) 3
127.0.0.1:6379> sinterstore set3 set1 set4
(integer) 2
127.0.0.1:6379> smembers set3
1) "a"
2) "b"
127.0.0.1:6379> sinterstore set3 set1 set5
(integer) 0


 

sunion

#sunion

#返回給定的多個集合的並集中的全部成員，不存在的key能夠認爲是空的集合。

#返回值爲並集的成員列表。

127.0.0.1:6379> keys *
1) "set4"
2) "set2"
3) "set1"
127.0.0.1:6379> smembers set1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> smembers set4
1) "a"
2) "d"
3) "b"
127.0.0.1:6379> sunion set1 set2 set4
1) "e"
2) "d"
3) "b"
4) "c"
5) "a"
127.0.0.1:6379> smembers set3
(empty list or set)
127.0.0.1:6379> sunion set1 set2 set3
1) "b"
2) "e"
3) "d"
4) "c"
5) "a"


 

sunionstore

#sunionstore

#將集合結果集存儲在新的集合中，若是新的集合已經存在，那麼會覆蓋這個新的集合。

#返回值爲結果集中元素的個數。

127.0.0.1:6379> keys *
1) "set4"
2) "set2"
3) "set1"
127.0.0.1:6379> del set4
(integer) 1
127.0.0.1:6379> sunionstore set3 set1 set2
(integer) 5
127.0.0.1:6379> smembers set3
1) "b"
2) "e"
3) "d"
4) "c"
5) "a"
127.0.0.1:6379> sunionstore set3 set1 set4
(integer) 3
127.0.0.1:6379> smembers set3
1) "a"
2) "c"
3) "b"
127.0.0.1:6379> sunionstore set3 set3 set3
(integer) 3
127.0.0.1:6379> sunionstore set3 set4 set5
(integer) 0


 

 

六、四、二、一、3第三部分

 

smove

#smove(把A的set集合中的一個元素移動到B的set集合中)

#將member從source集合移動到destination集合中. 對於其餘的客戶端,在特定的時間元素將會做爲source或者destination集合的成員出現.

若是source 集合不存在或者不包含指定的元素,這smove命令不執行任何操做而且返回0.不然對象將會從source集合中移除，並添加到destination集合中去，若是destination集合已經存在該元素，則smove命令僅將該元素充source集合中移除. 若是source和destination不是集合類型,則返回錯誤.

#返回值:若是該元素成功移除,返回1.若是該元素不是 source集合成員,無任何操做,則返回0.

 

127.0.0.1:6379> keys *
1) "set2"
2) "set1"
127.0.0.1:6379> smembers set1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers set2
1) "e"
2) "c"
3) "d"
127.0.0.1:6379> smove set1 set2 a
(integer) 1
127.0.0.1:6379> smembers set1
1) "c"
2) "b"
127.0.0.1:6379> smembers set2
1) "a"
2) "e"
3) "c"
4) "d"
127.0.0.1:6379> smove set1 set2 testval
(integer) 0
127.0.0.1:6379> smove set3 set1 testval
(integer) 0


 

scard

#scard(查看集合中元素的個數)

#返回集合存儲的key的基數(集合元素的數量)

#返回值:集合的基數(元素的數量),若是key不存在，則返回0.

127.0.0.1:6379> smembers set1
1) "c"
2) "b"
127.0.0.1:6379> scard set1
(integer) 2
127.0.0.1:6379> scard set3
(integer) 0


 

sismember

#sismember

#返回成員 member 是不是存儲的集合 key的成員.

#返回值:

若是member元素是集合key的成員，則返回1

若是member元素不是key的成員，或者集合key不存在，則返回0

127.0.0.1:6379> smembers set1
1) "c"
2) "b"
127.0.0.1:6379> sismember set1 a
(integer) 0
127.0.0.1:6379> sismember set3 testval
(integer) 0


 

srandmember

#srandmember

#僅提供key參數,那麼隨機返回key集合中的一個元素.

Redis 2.6開始, 能夠接受 count 參數,若是count是整數且小於元素的個數，返回含有 count 個不一樣的元素的數組,若是count是個整數且大於集合中元素的個數時,僅返回整個集合的全部元素,當count是負數,則會返回一個包含count的絕對值的個數元素的數組，若是count的絕對值大於元素的個數,則返回的結果集裏會出現一個元素出現屢次的狀況.

僅提供key參數時,該命令做用相似於SPOP命令, 不一樣的是SPOP命令會將被選擇的隨機元素從集合中移除, 而SRANDMEMBER僅僅是返回該隨記元素,而不作任何操做.

#返回值

bulk-string-reply: 不使用count 參數的狀況下該命令返回隨機的元素,若是key不存在則返回nil.

array-reply: 使用count參數,則返回一個隨機的元素數組,若是key不存在則返回一個空的數組.

127.0.0.1:6379> smembers set1
1) "c"
2) "b"
127.0.0.1:6379> srandmember set1
"b"
127.0.0.1:6379> srandmember set1
"c"
127.0.0.1:6379> srandmember set1 1
1) "b"
127.0.0.1:6379> srandmember set1 3
1) "c"
2) "b"
127.0.0.1:6379> srandmember set1 -3
1) "c"
2) "b"
3) "b"
127.0.0.1:6379> srandmember set1 -5
1) "b"
2) "b"
3) "b"
4) "b"
5) "c"
127.0.0.1:6379> srandmember set1 -2
1) "c"
2) "b"
127.0.0.1:6379> srandmember set1 -2
1) "c"
2) "c"
127.0.0.1:6379> srandmember set1 -1
1) "c"
127.0.0.1:6379> srandmember set1 -1
1) "b"


 

六、四、二、2zset有序集合部分

  Zset是有序集合，能夠作數據排行，跟solr和luecence用。Rank是作排序(過濾玩再排序，好比用戶訪問最多的)的，可是跟搜索/過濾不一樣。Rank，好比在每隔多長時間在內存中計算100W條數據中找到匹配度最高的。

六、四、二、二、1第一部分

 

zadd

#zadd

#將全部指定成員添加到鍵爲key有序集合（sorted set）裏面。 添加時能夠指定多個分數/成員（score/member）對。 若是指定添加的成員已是有序集合裏面的成員，則會更新改爲員的分數（scrore）並更新到正確的排序位置。

#若是key不存在，將會建立一個新的有序集合（sorted set）並將分數/成員（score/member）對添加到有序集合，就像原來存在一個空的有序集合同樣。若是key存在，可是類型不是有序集合，將會返回一個錯誤應答。

#分數值是一個雙精度的浮點型數字字符串。+inf和-inf都是有效值。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> zadd zset1 1 one
(integer) 1
#同一位置插入不一樣的數據會新增
127.0.0.1:6379> zadd zset1 1 uno
(integer) 1
127.0.0.1:6379> zadd zset1 2 two 3 three
(integer) 2
127.0.0.1:6379> zadd zset1 -1 -1one
(integer) 1
127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "one"
 4) "1"
 5) "uno"
 6) "1"
 7) "two"
 8) "2"
 9)"three"
#同一位置插入相同的值不會新增
10) "3"127.0.0.1:6379> zadd set1 2 two
(integer) 1
127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "one"
 4) "1"
 5) "uno"
 6) "1"
 7) "two"
 8) "2"
 9)"three"
10) "3"
127.0.0.1:6379> zadd zset1 4 two
(integer) 0
#不一樣位置插入相同的值，那麼會變更位置，原位置數據被刪除
127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "one"
 4) "1"
 5) "uno"
 6) "1"
 7)"three"
 8) "3"
 9) "two"
10) "4"


 

zrange

#zrange

#根據指定的index返回成員列表

127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "one"
 4) "1"
 5) "uno"
 6) "1"
 7) "two"
 8) "2"
 9)"three"
10) "3"
127.0.0.1:6379> zrange zset1 0 3 withscores
1) "-1one"
2) "-1"
3) "one"
4) "1"
5) "uno"
6) "1"
7) "two"
8) "2"
127.0.0.1:6379> zrange zset1 1 10 withscores
1) "one"
2) "1"
3) "uno"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"
127.0.0.1:6379> zrange zset1 -3 -1 withscores
1) "uno"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"
#下述是否加withscores的區別
127.0.0.1:6379> zrange set1 0 -1
1) "1val"
2) "6val"
3) "2val"
4) "7val"
5) "8val"
127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"


 

 

六、四、二、二、2第二部分

 

zrem

#zrem(從排序的集合中刪除一個或多個成員)

#當key存在，可是其不是有序集合類型，就返回一個錯誤

#返回值爲從有序集合中刪除的成員個數，不包括不存在的成員。

127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "one"
 4) "1"
 5) "uno"
 6) "1"
 7)"three"
 8) "3"
 9) "two"
10) "4"
127.0.0.1:6379> zrem zset1 three 
(integer) 1
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "-1one"
2) "-1"
3) "one"
4) "1"
5) "uno"
6) "1"
7) "two"
8) "4"
127.0.0.1:6379> zrem zset1 one two
(integer) 2
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "-1one"
2) "-1"
3) "uno"
4) "1"


 

zincrby

#zincrby

#爲有序集key的成員member的score值加上增量increment。若是key中不存在member，就在key中添加一個member，score是increment（就好像它以前的score是0.0）。若是key不存在，就建立一個只含有指定member成員的有序集合。

當key不是有序集類型時，返回一個錯誤。

score值必須是字符串表示的整數值或雙精度浮點數，而且能接受double精度的浮點數。也有可能給一個負數來減小score的值。

#返回值: member成員的新score值，以字符串形式表示。

127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "-1one"
2) "-1"
3) "uno"
4) "1"
127.0.0.1:6379> zincrby zset1 3 uno
"4"
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "-1one"
2) "-1"
3) "uno"
4) "4"
127.0.0.1:6379> zrange zset2 0 -1 withscores
(empty list or set)
127.0.0.1:6379> zincrby zset2 2 one
"2"
127.0.0.1:6379> zrange zset2 0 -1 withscores
1) "one"
2) "2"


 

zrangebyscore

#zrangebyscore(找到指定區間範圍的數據進行返回)

#若是M是常量（好比，用limit老是請求前10個元素），你能夠認爲是O(log(N))。

返回key的有序集合中的分數在min和max之間的全部元素（包括分數等於max或者min的元素）。元素被認爲是從低分到高分排序的。

具備相同分數的元素按字典序排列（這個根據redis對有序集合實現的狀況而定，並不須要進一步計算）。

可選的LIMIT參數指定返回結果的數量及區間（相似SQL中SELECT LIMIT offset, count）。注意，若是offset太大，定位offset就可能遍歷整個有序集合，這會增長O(N)的複雜度。

可選參數WITHSCORES會返回元素和其分數，而不僅是元素。這個選項在redis2.0以後的版本均可用。

#返回值: 指定分數範圍的元素列表(也能夠返回他們的分數)。

 

#注意下述的數值範圍是根據指定數值下標取的值，而不是根據序號，注意跟list的不一樣。

127.0.0.1:6379> zrange zset1 0 -1 withscores
 1)"-1one"
 2) "-1"
 3) "two"
 4) "2"
 5)"three"
 6) "3"
 7) "uno"
 8) "4"
 9)"five"
10) "5"
11) "six"
12) "6"
13) "nine"
14) "9"
127.0.0.1:6379> zrangebyscore zset1 1 3
1) "two"
2) "three"
127.0.0.1:6379> zrangebyscore zset1 0 -1
(empty list or set)
127.0.0.1:6379> zrangebyscore zset1 0 6
1) "two"
2) "three"
3) "uno"
4) "five"
5) "six"
127.0.0.1:6379> zrangebyscore zset1 0 8
1) "two"
2) "three"
3) "uno"
4) "five"
5) "six"
127.0.0.1:6379> zrangebyscore zset1 5 9
1) "five"
2) "six"
3) "nine"
127.0.0.1:6379> zrangebyscore zset1 5 10
1) "five"
2) "six"
3) "nine"
127.0.0.1:6379> zrangebyscore zset1 -1 -1
1) "-1one"


 

zremrangebyrank

# zremrangebyrank

#移除有序集key中，指定排名(rank)區間內的全部成員。下標參數start和stop都以0爲底，0處是分數最小的那個元素。這些索引也但是負數，表示位移從最高分處開始數。例如，-1是分數最高的元素，-2是分數第二高的，依次類推。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"0val"
 2) "0"
 3)"1val"
 4) "1"
 5)"2val"
 6) "2"
 7)"3val"
 8) "3"
 9)"4val"
10) "4"
11) "5val"
12) "5"
127.0.0.1:6379> zremrangebyrank set1 -1 1
(integer) 0
127.0.0.1:6379> zremrangebyrank set1 0 3
(integer) 4
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "4val"
2) "4"
3) "5val"
4) "5"
127.0.0.1:6379> zremrangebyrank set1 1 1
(integer) 1
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "4val"
2) "4"
127.0.0.1:6379> del set1
(integer) 1
127.0.0.1:6379> zadd set1 0 0val 1 1val 2 2val 3 3val4 4val 5 5val 
(integer) 6
127.0.0.1:6379> zremrangebyrank set1 1 3
(integer) 3
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "4val"
4) "4"
5) "5val"
6) "5"


 

zremrangebyscore

# zremrangebyscore(刪除指定序號)

#移除有序集key中，全部score值介於min和max之間(包括等於min或max)的成員。 自版本2.1.6開始，score值等於min或max的成員也能夠不包括在內

#返回值: 刪除的元素的個數。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"0val"
 2) "0"
 3)"1val"
 4) "1"
 5)"2val"
 6) "2"
 7)"3val"
 8) "3"
 9)"4val"
10) "4"
11) "7val"
12) "7"
13) "8val"
14) "8"
127.0.0.1:6379> zremrangebyscore set1 2 4
(integer) 3
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "1val"
4) "1"
5) "7val"
6) "7"
7) "8val"
8) "8"
127.0.0.1:6379> zremrangebyscore set1 3 4
(integer) 0
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "1val"
4) "1"
5) "7val"
6) "7"
7) "8val"
8) "8"
127.0.0.1:6379> zremrangebyscore set1 7 10
(integer) 2
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "1val"
4) "1"


 

 

六、四、二、二、3第三部分

 

zrank

#zrank(肯定在排序集合成員的索引，從小到大排序，升序排序以後再找索引，注意，一個是順序號，一個是索引，zrank返回的索引，與zrevrank相反)

#返回有序集key中成員member的排名。其中有序集成員按score值遞增(從小到大)順序排列。排名以0爲底，也就是說，score值最小的成員排名爲0。

使用ZREVRANK命令能夠得到成員按score值遞減(從大到小)排列的排名。

返回值:若是member是有序集key的成員，返回integer-reply：member的排名。

若是member不是有序集key的成員，返回bulk-string-reply:nil。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zrank set1 2val
(integer) 2
127.0.0.1:6379> zrank set1 otherval
(nil)


 

zrevrank

# zrevrank(返回排序索引，從大到小排序，降序排序以後再找索引。與zrank相反。)

#返回有序集key中成員member的排名，其中有序集成員按score值從大到小排列。排名以0爲底，也就是說，score值最大的成員排名爲0。

使用ZRANK命令能夠得到成員按score值遞增(從小到大)排列的排名。

返回值

若是member是有序集key的成員，返回integer-reply:member的排名。

若是member不是有序集key的成員，返回bulk-string-reply:nil。

 

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zrevrank set1 7val
(integer) 1
127.0.0.1:6379> zrevrank set1 8val
(integer) 0
127.0.0.1:6379> zrevrank set1 1val
(integer) 4
127.0.0.1:6379> zrevrank set1 otherval
(nil)


 

zrangebyscore

# zrangebyscore(返回有序集合中指定分數(不是指索引)區間內的成員，分數由低到高排序)

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zrevrank set1 7val
(integer) 1
127.0.0.1:6379> zrevrank set1 8val
(integer) 0
127.0.0.1:6379> zrevrank set1 1val
(integer) 4
127.0.0.1:6379> zrevrank set1 otherval
(nil)
127.0.0.1:6379> zrangebyscore set1 0 1
1) "1val"
127.0.0.1:6379> zrangebyscore set1 0 5
1) "1val"
127.0.0.1:6379> zrangebyscore set1 1 5
1) "1val"
127.0.0.1:6379> zrangebyscore set1 1 7
1) "1val"
2) "6val"
3) "2val"
4) "7val"
127.0.0.1:6379> zrangebyscore set1 1 7 withscores
1) "1val"
2) "1"
3) "6val"
4) "6"
5) "2val"
6) "7"
7) "7val"
8) "7"


 

 

六、四、二、二、4第四部分

 

zcard

#zcard(獲取一個排序的集合中的成員數量)

#返回值: key存在的時候，返回有序集的元素個數，不然返回0。

127.0.0.1:6379> zrange set1 0 -1
1) "1val"
2) "6val"
3) "2val"
4) "7val"
5) "8val"
127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zcard set1
(integer) 5
127.0.0.1:6379> zcard set2
(integer) 0


 

zcount

#zcount(返回分數範圍內的成員數量)

#返回有序集key中，score值在min和max之間(默認包括score值等於min或max)的成員。

#返回值:integer-reply: 指定分數範圍的元素個數。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zcount set1 0 2
(integer) 1
127.0.0.1:6379> zcount set1 0 1
(integer) 1
127.0.0.1:6379> zcount set1 1 1
(integer) 1
127.0.0.1:6379> zcount set1 1 5
(integer) 1
127.0.0.1:6379> zcount set1 1 7
(integer) 4

 

六、四、二、二、5第五部分

 

zremrangebyrank

# zremrangebyrank(在排序設置的全部成員在給定的索引中刪除)

#移除有序集key中，指定排名(rank)區間內的全部成員。下標參數start和stop都以0爲底，0處是分數最小的那個元素。這些索引也但是負數，表示位移從最高分處開始數。例如，-1是分數最高的元素，-2是分數第二高的，依次類推。

返回值: 被移除成員的數量。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"1val"
 2) "1"
 3)"6val"
 4) "6"
 5)"2val"
 6) "7"
 7)"7val"
 8) "7"
 9)"8val"
10) "8"
127.0.0.1:6379> zremrangebyrank set1 2 3
(integer) 2
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "1val"
2) "1"
3) "6val"
4) "6"
5) "8val"
6) "8"
127.0.0.1:6379> zremrangebyrank set1 -2 -1
(integer) 2
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "1val"
2) "1"
127.0.0.1:6379> zremrangebyrank set1 0 0
(integer) 1
127.0.0.1:6379> zrange set1 0 -1 withscores
(empty list or set)
127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"0val"
 2) "0"
 3)"1val"
 4) "1"
 5)"2val"
 6) "2"
 7)"3val"
 8) "3"
 9)"4val"
10) "4"
11) "5val"
12) "5"
127.0.0.1:6379> zremrangebyrank set1 0 1
(integer) 2
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "2val"
2) "2"
3) "3val"
4) "3"
5) "4val"
6) "4"
7) "5val"
8) "5"
127.0.0.1:6379> zremrangebyrank set1 0 0
(integer) 1
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "3val"
2) "3"
3) "4val"
4) "4"
5) "5val"
6) "5"
127.0.0.1:6379> zremrangebyrank set1 1 1
(integer) 1
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "3val"
2) "3"
3) "5val"
4) "5"
127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"0val"
 2) "0"
 3)"1val"
 4) "1"
 5)"2val"
 6) "2"
 7)"3val"
 8) "3"
 9)"4val"
10) "4"
11) "5val"
12) "5"
127.0.0.1:6379> zremrangebyrank set1 -3 0
(integer) 0
127.0.0.1:6379> zremrangebyrank set1 -3 -1
(integer) 3
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "1val"
4) "1"
5) "2val"
6) "2"


 

zremrangebyscore

# zremrangebyscore(在排序設置的全部成員在給定的序號中刪除)

#移除有序集key中，全部score值介於min和max之間(包括等於min或max)的成員。

#返回值: 刪除的元素的個數。

127.0.0.1:6379> zrange set1 0 -1 withscores
 1)"0val"
 2) "0"
 3)"2val"
 4) "2"
 5)"3val"
 6) "3"
 7)"4val"
 8) "4"
 9)"5val"
10) "5"
11) "7val"
12) "7"
127.0.0.1:6379> zrange set1 0 -1
1) "0val"
2) "2val"
3) "3val"
4) "4val"
5) "5val"
6) "7val"
127.0.0.1:6379> keys *
1) "set1"
127.0.0.1:6379> zremrangebyscore set1 3 5
(integer) 3
#按序號升序排序
127.0.0.1:6379> zrange set1 0 -1 withscores
1) "0val"
2) "0"
3) "2val"
4) "2"
5) "7val"
6) "7"
127.0.0.1:6379> zrange set1 0 -1
1) "0val"
2) "2val"
3) "7val"


 

六、5hash

六、五、1操做

hset

#hset

設置 key 指定的哈希集中指定字段的值。

若是 key 指定的哈希集不存在，會建立一個新的哈希集並與 key 關聯。

若是字段在哈希集中存在，它將被重寫。

返回值

integer-reply：含義以下

1若是field是一個新的字段

0若是field原來在map裏面已經存在

127.0.0.1:6379> hset myhash field1 hello
(integer) 1
127.0.0.1:6379> hget myhash field1
"hello"


 

hget

#hget

返回 key 指定的哈希集中該字段所關聯的值

返回值

bulk-string-reply：該字段所關聯的值。當字段不存在或者 key 不存在時返回nil。

127.0.0.1:6379> hset myhash field1 hello
(integer) 1
127.0.0.1:6379> hget myhash field1
"hello"
127.0.0.1:6379> hget myhash field2
(nil)
127.0.0.1:6379> hget mytest field
(nil)


 

hkeys

#hkeys

返回 key 指定的哈希集中全部字段的名字。

返回值

array-reply：哈希集中的字段列表，當 key 指定的哈希集不存在時返回空列表。

127.0.0.1:6379> hset myhash field1 hello
(integer) 1
127.0.0.1:6379> hset myhash field2 val2
(integer) 1
127.0.0.1:6379> hset myhash field3 val3
(integer) 1
127.0.0.1:6379> hset myhash field4 val4
(integer) 1
127.0.0.1:6379> hset myhash filed5 val5
(integer) 1
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "field2"
3) "field3"
4) "field4"
5) "filed5"


 

hdel

#hdel

從 key 指定的哈希集中移除指定的域。在哈希集中不存在的域將被忽略。

若是 key 指定的哈希集不存在，它將被認爲是一個空的哈希集，該命令將返回0。

返回值

integer-reply： 返回從哈希集中成功移除的域的數量，不包括指出但不存在的那些域

歷史

在 2.4及以上版本中 ：可接受多個域做爲參數。小於 2.4版本 的 Redis 每次調用只能移除一個域 要在早期版本中以原子方式從哈希集中移除多個域，可用MULTI/EXEC塊。

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "field2"
3) "field3"
4) "field4"
5) "filed5"
127.0.0.1:6379> hdel myhash field2
(integer) 1
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "field3"
3) "field4"
4) "filed5"
127.0.0.1:6379> hdel myhash field3 field4
(integer) 2
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
127.0.0.1:6379> hdel myhash testfield
(integer) 0
127.0.0.1:6379> hdel mytest testfield
(integer) 0
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
127.0.0.1:6379> hkeys mytest
(empty list or set)


 

hlen

#hlen

返回 key 指定的哈希集包含的字段的數量。

返回值

integer-reply： 哈希集中字段的數量，當 key 指定的哈希集不存在時返回 0

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
127.0.0.1:6379> hlen myhash
(integer) 2


hmset


#hmset(可同時設置多個值，hset只能一次設置一個)

設置 key 指定的哈希集中指定字段的值。該命令將重寫全部在哈希集中存在的字段。若是 key指定的哈希集不存在，會建立一個新的哈希集並與 key 關聯

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
127.0.0.1:6379> hmset myhash field2 val2 field3 val3field4 val4
OK
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
127.0.0.1:6379> hmset myhash field2 val22 field3 val33
OK
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
127.0.0.1:6379> hget myhash field2
"val22"
127.0.0.1:6379> hget myhash field3
"val33"
127.0.0.1:6379> hmget myhash field2 field3 
1) "val22"
2) "val33"


 

hmget

#hmget

返回 key 指定的哈希集中指定字段的值。

對於哈希集中不存在的每一個字段，返回 nil 值。由於不存在的keys被認爲是一個空的哈希集，對一個不存在的 key 執行 HMGET 將返回一個只含有 nil 值的列表

返回值

array-reply：含有給定字段及其值的列表，並保持與請求相同的順序。

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
127.0.0.1:6379> hmget myhash field4
1) "val4"
127.0.0.1:6379> hmget myhash field1 field2 field3field99
1) "hello"
2) "val22"
3) "val33"
4) (nil)
127.0.0.1:6379> hmget mytest field2 field3
1) (nil)
2) (nil)


 

hincrby

#hincrby

增長 key 指定的哈希集中指定字段的數值。若是 key 不存在，會建立一個新的哈希集並與 key 關聯。若是字段不存在，則字段的值在該操做執行前被設置爲 0

HINCRBY 支持的值的範圍限定在 64位 有符號整數

返回值

integer-reply：增值操做執行後的該字段的值。

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
127.0.0.1:6379> hget myhash field2
"val22"
127.0.0.1:6379> hincrby myhash field2 1
(error) ERR hash value is not an integer
127.0.0.1:6379> hset myhash field6 1
(integer) 1
127.0.0.1:6379> hincrby myhash field6 2
(integer) 3
127.0.0.1:6379> hget myhash field6
"3"
127.0.0.1:6379> hincrby myhash field7 2
(integer) 2
127.0.0.1:6379> hget myhash field7
"2"


 

hexists

#hexists

返回hash裏面key是否存在的標誌

返回值

integer-reply, 含義以下：

1 哈希集中含有該字段。

0 哈希集中不含有該存在字段，或者key不存在。

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
6) "field6"
7) "field7"
127.0.0.1:6379> hexists myhash field2
(integer) 1
127.0.0.1:6379> hexists myhash fieldtest
(integer) 0


 

 

hvals

#hval

返回 key 指定的哈希集中全部字段的值。

返回值

array-reply：哈希集中的值的列表，當 key 指定的哈希集不存在時返回空列表。

例子

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
6) "field6"
7) "field7"
127.0.0.1:6379> hvals myhash
1) "hello"
2) "val5"
3) "val22"
4) "val33"
5) "val4"
6) "3"
7) "2"
127.0.0.1:6379> hvals mytesthash
(empty list or set)


 

 

hsetnx

#hsetnx

只在 key 指定的哈希集中不存在指定的字段時，設置字段的值。若是 key 指定的哈希集不存在，會建立一個新的哈希集並與 key 關聯。若是字段已存在，該操做無效果。

返回值

integer-reply：含義以下

1：若是字段是個新的字段，併成功賦值

0：若是哈希集中已存在該字段，沒有操做被執行

 

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
6) "field6"
7) "field7"
127.0.0.1:6379> hsetnx myhash field7 val7
(integer) 0
127.0.0.1:6379> hsetnx myhash field8 val8
(integer) 1
127.0.0.1:6379> hget myhash field8
"val8"
127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
6) "field6"
7) "field7"
8) "field8"


 

 

hgetall

#hgetall

返回 key 指定的哈希集中全部的字段和值。返回值中，每一個字段名的下一個是它的值，因此返回值的長度是哈希集大小的兩倍

返回值

array-reply：哈希集中字段和值的列表。當 key 指定的哈希集不存在時返回空列表。

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "filed5"
3) "field2"
4) "field3"
5) "field4"
6) "field6"
7) "field7"
8) "field8"
127.0.0.1:6379> hgetall myhash
 1)"field1"
 2)"hello"
 3)"filed5"
 4)"val5"
 5)"field2"
 6)"val22"
 7)"field3"
 8)"val33"
 9)"field4"
10) "val4"
11) "field6"
12) "3"
13) "field7"
14) "2"
15) "field8"
16) "val8"


 

 

hstrlen

#hstrlen

返回hash指定field的value的字符串長度，若是hash或者field不存在，返回0.

返回值

integer-reply:返回hash指定field的value的字符串長度，若是hash或者field不存在，返回0.

127.0.0.1:6379> hgetall myhash
 1)"field1"
 2)"hello"
 3)"filed5"
 4)"val5"
 5)"field2"
 6)"val22"
 7)"field3"
 8)"val33"
 9)"field4"
10) "val4"
11) "field6"
12) "3"
13) "field7"
14) "2"
15) "field8"
16) "val8"
127.0.0.1:6379> hstrlen myhash field4
(integer) 4
127.0.0.1:6379> hstrlen myhash field10
(integer) 0
127.0.0.1:6379> hstrlen myhashtest testfield
(integer) 0


 

 

hincrbyfloat

#hincrbyfloat

爲指定key的hash的field字段值執行float類型的increment加。若是field不存在，則在執行該操做前設置爲0.若是出現下列狀況之一，則返回錯誤：

field的值包含的類型錯誤(不是字符串)。

當前field或者increment不能解析爲一個float類型。

此命令的確切行爲與INCRBYFLOAT命令相同，請參閱INCRBYFLOAT命令獲取更多信息。

返回值

bulk-string-reply： field執行increment加後的值

實現細節

該命令始終是在複製和模仿HSET，所以，在底層的浮點數運算不會出現數據不一致性問題。

 

127.0.0.1:6379> hgetall myhash
 1)"field1"
 2)"hello"
 3)"filed5"
 4)"val5"
 5)"field2"
 6)"val22"
 7)"field3"
 8)"val33"
 9)"field4"
10) "val4"
11) "field6"
12) "3"
13) "field7"
14) "2"
15) "field8"
16) "val8"
127.0.0.1:6379> HINCRBYFLOAT myhash field7 10.00
"22"
127.0.0.1:6379> HINCRBYFLOAT myhash field7 10.111
"32.111"
127.0.0.1:6379> hincrbyfloat myhash field8 223
(error) ERR hash value is not a valid float
127.0.0.1:6379> hincrbyfloat myhash field9 1.1109
"1.1109"
127.0.0.1:6379> hget myhash field9
"1.1109"
127.0.0.1:6379> hgetall myhash
 1)"field1"
 2)"hello"
 3)"filed5"
 4)"val5"
 5)"field2"
 6)"val22"
 7)"field3"
 8)"val33"
 9)"field4"
10) "val4"
11) "field6"
12) "3"
13) "field7"
14) "32.111"
15) "field8"
16) "val8"
17) "field9"
18) "1.1109"



 

 

6、6高級命令及特性一


exists

#exists判斷key是否存在

返回值

integer-reply，以下的整數結果

1 若是key存在

0 若是key不存在

 

127.0.0.1:6379> keys *
1) "set1"
127.0.0.1:6379> exists set1
(integer) 1
127.0.0.1:6379> exists set2
(integer) 0


 

expire

#expire

設置key的過時時間，超過期間後，將會自動刪除該key。在Redis的術語中一個key的相關超時是不肯定的。

超時後只有對key執行DEL命令或者SET命令或者GETSET時纔會清除。 這意味着，從概念上講全部改變key的值的操做都會使他清除。例如，INCR遞增key的值，執行LPUSH操做，或者用HSET改變hash的field全部這些操做都會觸發刪除動做。

使用PERSIST命令能夠清除超時，使其變成一個永久的key。

若是key被RENAME命令修改，相關的超時時間會轉移到新key上面。

若是key被RENAME命令修改，好比原來就存在Key_A,而後調用RENAME Key_B Key_A命令，這時無論原來Key_A是永久的仍是設置爲超時的，都會由Key_B的有效期狀態覆蓋。

刷新過時時間

對已經有過時時間的key執行EXPIRE操做，將會更新它的過時時間。有不少應用有這種業務場景，例如記錄會話的session。

返回值

integer-reply, 具體的:

1 若是成功設置過時時間。

0 若是key不存在或者不能設置過時時間。

 

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set name1 name1val
OK
127.0.0.1:6379> get name1
"name1val"
#設置超時時間10秒
127.0.0.1:6379> expire name1 10
(integer) 1
127.0.0.1:6379> ttl name1
(integer) 8
127.0.0.1:6379> ttl name1
(integer) 4
127.0.0.1:6379> ttl name1
(integer) -2
127.0.0.1:6379> get name1
(nil)
127.0.0.1:6379> set name1 name1val
OK
127.0.0.1:6379> ttl name1
(integer) -1


 

#更多操做參考「http://www.redis.cn/commands/expire.html」

 

persist

#persist

移除給定key的生存時間，將這個 key 從『易失的』(帶生存時間 key )轉換成『持久的』(一個不帶生存時間、永不過時的 key )。

返回值

integer-reply, 只有如下兩種值:

當生存時間移除成功時，返回 1 .

若是 key 不存在或 key 沒有設置生存時間，返回 0 .

127.0.0.1:6379> get name1
"name1val"
127.0.0.1:6379> persist name1
(integer) 0
127.0.0.1:6379> set name2 name2val
OK
127.0.0.1:6379> expire name2 10
(integer) 1
127.0.0.1:6379> ttl name2
(integer) 8
127.0.0.1:6379> persist name2
(integer) 1
127.0.0.1:6379> get name2
"name2val"
127.0.0.1:6379> ttl name2
(integer) -1


 

rename

#rename

將key重命名爲newkey，若是key與newkey相同，將返回一個錯誤。若是newkey已經存在，則值將被覆蓋。

 

127.0.0.1:6379> set name3 name3val
OK
127.0.0.1:6379> get name3
"name3val"
127.0.0.1:6379> expire name3 50
(integer) 1
127.0.0.1:6379> ttl name3
(integer) 48
127.0.0.1:6379> rename name3 name4
OK
127.0.0.1:6379> ttl name3
(integer) -2
127.0.0.1:6379> ttl name4
(integer) 31
127.0.0.1:6379> get name4
"name3val"
127.0.0.1:6379> persist name4
(integer) 1
127.0.0.1:6379> ttl name4
(integer) -1
127.0.0.1:6379> get name4
"name3val"
127.0.0.1:6379> set name5 name5val
OK
127.0.0.1:6379> expire name5 20
(integer) 1
127.0.0.1:6379> rename name5 name4
OK
127.0.0.1:6379> ttl name5
(integer) -2
127.0.0.1:6379> ttl name4
(integer) 7
127.0.0.1:6379> get name4
"name5val"
127.0.0.1:6379> get name4
"name5val"
127.0.0.1:6379> get name5
(nil)
127.0.0.1:6379> get name4
(nil)


 

select 

#select

選擇一個數據庫，下標值從0開始，一個新鏈接默認鏈接的數據庫是DB0(數據庫爲0-15，一共16個數據庫)。

爲何把數據庫切成16份？

數據安全。

16份是內存上邏輯劃分。

早期（沒集羣）：每份放在不一樣的機器上，備份，爲了數據安全。

 

127.0.0.1:6379> keys *
1) "name1"
2) "name2"
3) "name6"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
(empty list or set)
127.0.0.1:6379[1]> get name2
(nil)
127.0.0.1:6379[1]> select 15
OK
127.0.0.1:6379[15]> select 16
(error) ERR invalid DB index
127.0.0.1:6379[15]> select 0
OK
127.0.0.1:6379> keys *
1) "name1"
2) "name2"
3) "name6"


 

move

#move

將當前數據庫的 key 移動到給定的數據庫 db 當中。

若是當前數據庫(源數據庫)和給定數據庫(目標數據庫)有相同名字的給定 key ，或者key 不存在於當前數據庫，那麼 MOVE 沒有任何效果。

所以，也能夠利用這一特性，將 MOVE 看成鎖(locking)原語(primitive)。

返回值

integer-reply:

移動成功返回 1

失敗則返回 0

127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
(empty list or set)
127.0.0.1:6379[1]> set name1 name1val
OK
127.0.0.1:6379[1]> set name2 name2val
OK
127.0.0.1:6379[1]> keys *
1) "name1"
2) "name2"
127.0.0.1:6379[1]> select 2
OK
127.0.0.1:6379[2]> keys *
(empty list or set)
127.0.0.1:6379[2]> set name1 name1val2
OK
127.0.0.1:6379[2]> set name2 name2val2
OK
127.0.0.1:6379[2]> keys *
1) "name1"
2) "name2"
127.0.0.1:6379[2]> move name1 1
(integer) 0
127.0.0.1:6379[2]> select 1
OK
127.0.0.1:6379[1]> get name1
"name1val"
127.0.0.1:6379[1]> set name3 name3val
OK
127.0.0.1:6379[1]> move name3 2
(integer) 1
127.0.0.1:6379[1]> keys *
1) "name1"
2) "name2"
127.0.0.1:6379[1]> get name3
(nil)
127.0.0.1:6379[1]> select 2
OK
127.0.0.1:6379[2]> keys *
1) "name1"
2) "name3"
3) "name2"
127.0.0.1:6379[2]> get name3
"name3val"
 
#randomkey
#隨機返回某數據庫裏的一個key
127.0.0.1:6379[2]> randomkey 
"name3"
127.0.0.1:6379[2]> randomkey 
"name2"
127.0.0.1:6379[2]> randomkey 
"name2"
127.0.0.1:6379[2]> randomkey 
"name1"


 

 

6、7高級命令及特性二

echo

#echo

打印命令

127.0.0.1:6379[2]> keys *
1) "name1"
2) "name3"
3) "name2"
127.0.0.1:6379[2]> echo name3
"name3"
127.0.0.1:6379[2]> echo name1
"name1"


 

dbsize

#dbsize

返回當前數據庫的key的數量

127.0.0.1:6379[2]> keys *
1) "name1"
2) "name3"
3) "name2"
127.0.0.1:6379[2]> dbsize
(integer) 3
127.0.0.1:6379[2]> flushdb
OK
127.0.0.1:6379[2]> keys *
(empty list or set)
127.0.0.1:6379[2]> dbsize
(integer) 0


info 
#info
INFO命令以一種易於理解和閱讀的格式，返回關於Redis服務器的各類信息和統計數值。
經過給定可選的參數 section ，可讓命令只返回某一部分的信息:
server: Redis服務器的通常信息
clients: 客戶端的鏈接部分
memory: 內存消耗相關信息
persistence: RDB和AOF相關信息
stats: 通常統計
replication: 主/從複製信息
cpu: 統計CPU的消耗
commandstats: Redis命令統計
cluster: Redis集羣信息
keyspace: 數據庫的相關統計
它也能夠採起如下值:
all: 返回全部信息
default: 值返回默認設置的信息
若是沒有使用任何參數時，默認爲default。
返回值
bulk-string-reply: 文本行的合集
每一行包含了包含一種信息或者屬性（從#字符開始）。 全部的屬性都是以字段:值（field:value）的形式，已\r\n結尾。
 
注意
請注意不一樣Redis版本會添加或者刪除一些字段。一個健壯的客戶端應用解析該命令的結果時，應該跳過未知的字段，而且優雅的處理缺乏的字段。
已下描述要求 Redis >= 2.4
下面是全部 server 相關的信息:
redis_version: Redis 服務器版本
redis_git_sha1: Git SHA1
redis_git_dirty: Git dirty flag
os: Redis 服務器的宿主操做系統
arch_bits: 架構（32 或 64 位）
multiplexing_api: Redis 所使用的事件處理機制
gcc_version: 編譯 Redis 時所使用的 GCC 版本
process_id: 服務器進程的 PID
run_id: Redis 服務器的隨機標識符（用於 Sentinel 和集羣）
tcp_port: TCP/IP 監聽端口
uptime_in_seconds: 自 Redis 服務器啓動以來，通過的秒數
uptime_in_days: 自 Redis 服務器啓動以來，通過的天數
lru_clock: 以分鐘爲單位進行自增的時鐘，用於 LRU 管理
下面是全部 clients 相關的信息:
connected_clients: 已鏈接客戶端的數量（不包括經過從屬服務器鏈接的客戶端）
client_longest_output_list: 當前鏈接的客戶端當中，最長的輸出列表
client_biggest_input_buf: 當前鏈接的客戶端當中，最大輸入緩存
blocked_clients: 正在等待阻塞命令（BLPOP、BRPOP、BRPOPLPUSH）的客戶端的數量
下面是全部 memory 相關的信息:
used_memory: 由Redis 分配器分配的內存總量，以字節（byte）爲單位
used_memory_human: 以人類可讀的格式返回 Redis 分配的內存總量
used_memory_rss: 從操做系統的角度，返回 Redis 已分配的內存總量（俗稱常駐集大小）。這個值和 top 、 ps 等命令的輸出一致。
used_memory_peak: Redis 的內存消耗峯值（以字節爲單位）
used_memory_peak_human: 以人類可讀的格式返回 Redis 的內存消耗峯值
used_memory_lua: Lua 引擎所使用的內存大小（以字節爲單位）
mem_fragmentation_ratio: used_memory_rss 和 used_memory 之間的比率
mem_allocator: 在編譯時指定的， Redis 所使用的內存分配器。能夠是 libc 、 jemalloc 或者 tcmalloc 。 在理想狀況下， used_memory_rss 的值應該只比 used_memory 稍微高一點兒。
當 rss > used ，且二者的值相差較大時，表示存在（內部或外部的）內存碎片。
內存碎片的比率能夠經過mem_fragmentation_ratio 的值看出。
當 used > rss 時，表示 Redis 的部份內存被操做系統換出到交換空間了，在這種狀況下，操做可能會產生明顯的延遲。
當 Redis 釋放內存時，分配器可能會，也可能不會，將內存返還給操做系統。
若是 Redis 釋放了內存，卻沒有將內存返還給操做系統，那麼 used_memory 的值可能和操做系統顯示的 Redis 內存佔用並不一致。
查看 used_memory_peak 的值能夠驗證這種狀況是否發生。
 
 
#更多信息參考「http://www.redis.cn/commands/info.html」


 

config get

#config get

CONFIG GET命令用來讀取redis服務器的配置文件參數，但並非全部參數都支持。 與之對應的命令是CONFIGSET用來設置服務器的配置參數。

CONFIG GET 命令只接受一個參數，全部配置參數都採用key-value的形式。

#我的理解對應「/application/redis/conf/redis.conf」中的內容。

 

#查看配置中的全部信息

127.0.0.1:6379[2]> config get *
127.0.0.1:6379[2]> config get port
1) "port"
2) "6379"


 

config set
#config set
#設置配置文件中的參數
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "redis"
127.0.0.1:6379> config set requirepass test
OK
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "test"
127.0.0.1:6379> quit
[root@redis ~]# redis-cli
127.0.0.1:6379> config get *
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth redis
(error) ERR invalid password
127.0.0.1:6379> auth test
OK
127.0.0.1:6379> config get *
127.0.0.1:6379> config set port 8888
(error) ERR Unsupported CONFIG parameter: port
127.0.0.1:6379> config get port
1) "port"
2) "6379"


 

flushdb

#flushdb

刪除當前數據庫裏面的全部數據。

這個命令永遠不會出現失敗。

這個操做的時間複雜度是O(N),N是當前數據庫的keys數量。

127.0.0.1:6379[1]> select 2
OK
127.0.0.1:6379[2]> keys *
(empty list or set)
127.0.0.1:6379[2]> set name1 name1val
OK
127.0.0.1:6379[2]> set name2 name2val
OK
127.0.0.1:6379[2]> keys *
1) "name1"
2) "name2"
127.0.0.1:6379[2]> flushdb
OK
127.0.0.1:6379[2]> keys *
(empty list or set)
127.0.0.1:6379[2]> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name1"
2) "name2"


 

flushall 

#flushall

刪除全部數據庫裏面的全部數據，注意不是當前數據庫，而是全部數據庫。

這個命令永遠不會出現失敗。

這個操做的時間複雜度是O(N),N是數據庫的數量。

127.0.0.1:6379> keys *
1) "name1"
2) "name2"
3) "name6"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name1"
2) "name2"
127.0.0.1:6379[1]> flushall
OK
127.0.0.1:6379[1]> keys *
(empty list or set)
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> keys *
(empty list or set)





7、redis經常使用命令結合java代碼的使用

 

package org.mbox.testredis;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
 
public class TestRedis {
 
    private staticJedis jedis = new Jedis("10.0.0.7", 6379);
    
    publicTestRedis(){
        jedis.auth("redis");
    }
    
    @Test
    public voidtest(){
//      //1
//      jedis.flushDB();//清空當前庫,默認select 0
//      
//      jedis.set("name1","name1val");
//      jedis.set("name2","name2val");
//      
//      System.out.println(jedis.get("name1"));
        
//      //2操做map
//      jedis.flushDB();
//      jedis.mset("name1","name1val","name2","name2val");  //設置多個值,多個key val的形式
//      
//      List<String>listNames = jedis.mget("name1","name2");
////        Iterator<String>iterators = listNames.iterator();
////        while(iterators.hasNext()){
////            System.out.println(iterators.next());
////        }
//
//      for(Iterator<String>iterators = listNames.iterator();iterators.hasNext();){
//          Stringnameval = (String)iterators.next();
//          System.out.println(nameval);
//      }
        
//      //3
//      jedis.flushDB();
//      Map<String,String>map = new HashMap<String,String>();//key和value只能是string類型
//      map.put("name1","name1val");
//      map.put("name2","name2val");
//      map.put("name3","name3val");
//      jedis.hmset("myhashmap",map);
//
//      Set<String>setNames = jedis.hkeys("myhashmap");
//      for(Iterator<String>iterators = setNames.iterator();iterators.hasNext();){
//          Stringkey = iterators.next();
//          System.out.println(key+ "---->" + jedis.hget("myhashmap", key));
//      }
        
//      //4
//      //打印map中的全部值
//      System.out.println(jedis.hmget("myhashmap","name1", "name2", "name3"));
//      System.out.println("............................");
//      List<String>listNames = jedis.hmget("myhashmap", "name1","name2", "name3");
//      //打印map中的全部值        
//      for(Iterator<String>iterators = listNames.iterator();iterators.hasNext();){
//          System.out.println(iterators.next());
//      }
//      jedis.hdel("myhashmap","name1");//刪除map中的某個key
//      System.out.println("............................");
//      for(Iterator<String>iterators = listNames.iterator();iterators.hasNext();){
//          System.out.println(iterators.next());
//      }
//      System.out.println("............................");
        
        
//      //5
//      //獲取map中某個key的值
//      System.out.println(jedis.hmget("myhashmap","name1"));
//      System.out.println(jedis.hmget("myhashmap","name3"));
//      //獲取map中的key個數
//      System.out.println(jedis.hlen("myhashmap"));
//      //是否存在以myhashmap爲key的記錄
//      System.out.println(jedis.exists("myhashmap"));
//      //獲取map中的全部key名稱
//      System.out.println(jedis.hkeys("myhashmap"));
//      //獲取map中的全部key的value值
//      System.out.println(jedis.hvals("myhashmap"));
        
        
//      //6事務
////        jedis.flushDB();
//      jedis.set("age","11");
//      jedis.set("name","nameval1");
//      Transactiontransaction = jedis.multi();
//      //若是用了multi方法,那麼就必須利用transaction進行處理其餘命令操做,
//      //否則報錯內容爲:"Cannot use Jedis when inMulti. Please use JedisTransaction instead."
//      transaction.incr("age");
//      transaction.incr("name");
////        上述name爲啥不報錯,並能經過,但在linux環境下操做就報錯
////        127.0.0.1:6379>incr name
////        (error)ERR value is not an integer or out of range
//      
////        System.out.println(transaction.get("age"));
////        System.out.println(transaction.get("name"));
//      //discard和exec方法與multi方法分別是成對存在的,不要把discard和exec一塊兒使用
////        transaction.discard();
//      transaction.exec();
//      
//      System.out.println(jedis.get("age"));
//      System.out.println(jedis.get("name"));
        
        
//      //7操做list
//      jedis.flushDB();
//      //lpush棧:後進先出
//      //list名稱,後面全是值
//      jedis.lpush("testlist","list1", "list3", "list2", "list4");
//      //list名稱,0到-1是查詢出全部
//      System.out.println("1----------------"+ jedis.lrange("testlist", 0, -1));
//      jedis.lpush("testlist","list6");
//      jedis.lpush("testlist","list5");
//      System.out.println("2----------------"+ jedis.lrange("testlist", 0, -1));
//      jedis.del("testlist");
//      //rpush隊列:先進先出
//      jedis.rpush("testlist","list1", "list3", "list2", "list4");
//      System.out.println("3----------------"+ jedis.lrange("testlist", 0, -1));
        
        
//      //8操做set無序集合
//      jedis.flushDB();
//      jedis.sadd("testset","set1");
//      jedis.sadd("testset","set3");
//      jedis.sadd("testset","set2");
//      jedis.sadd("testset","set4", "set7", "set6", "set5");
//      System.out.println(jedis.smembers("testset"));//獲取全部元素
//      System.out.println(jedis.sismember("testset","set2"));//判斷元素是否在set中
//      System.out.println(jedis.scard("testset"));//返回set中元素的個數
//      jedis.srem("testset","set4", "set2");//刪除其中的元素
//      System.out.println(jedis.smembers("testset"));//獲取全部元素
//      System.out.println(jedis.sismember("testset","set2"));//判斷元素是否在set中
//      System.out.println(jedis.srandmember("testset"));//隨機返回一個元素
//      System.out.println(jedis.scard("testset"));//返回set中元素的個數
        
//      //9操做zset有序集合
//      jedis.flushDB();
//      //前面是key後面是value
//      jedis.zadd("zset1",1, "test1");
//      jedis.zadd("zset1",3, "test3");
//      jedis.zadd("zset1",2, "test2");
//      jedis.zadd("zset1",4, "test4");
//      Map<String,Double>zsetMap = new HashMap<String,Double>();
//      //前面是value後面是key
//      zsetMap.put("8",11.11);
//      zsetMap.put("6",21.11);
//      jedis.zadd("zset1",zsetMap);
//      System.out.println(jedis.zrange("zset1",0, -1));
        
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程