本文是參考《redis中文手冊》，將示例代碼用php來實現(xiàn)，注意php-redis與redis_cli的區(qū)別（主要是返回值類型和參數(shù)用法）。

redis中文手冊下載地址：http://m.miracleart.cn/xiazai/shouce/54

redis中文在線手冊：http://m.miracleart.cn/course/49.html

目錄(使用CTRL+F快速查找命令)：

phpredis是redis的php的一個擴展，效率是相當高有鏈表排序功能，對創(chuàng)建內(nèi)存級的模塊業(yè)務關系

很有用;以下是redis官方提供的命令使用技巧:

下載地址如下：

https://github.com/owlient/phpredis（支持redis 2.0.4）

Redis::__construct構造函數(shù)
$redis = new Redis();

connect, open 鏈接redis服務
參數(shù)
host: string，服務地址
port: int,端口號
timeout: float,鏈接時長 (可選, 默認為 0 ，不限鏈接時間)
注: 在redis.conf中也有時間，默認為300

pconnect, popen 不會主動關閉的鏈接
參考上面

setOption 設置redis模式

getOption 查看redis設置的模式

ping 查看連接狀態(tài)

?

KEY相關操作

DEL

移除給定的一個或多個key。

如果key不存在，則忽略該命令。

• 時間復雜度：

• O(N)，N為要移除的key的數(shù)量。

• 移除單個字符串類型的key，時間復雜度為O(1)。

  移除單個列表、集合、有序集合或哈希表類型的key，時間復雜度為O(M)，M為以上數(shù)據(jù)結構內(nèi)的元素數(shù)量。

• 返回值：

• 被移除key的數(shù)量。

->set('myname','ikodota');
 ->get('myname').'<br>'; 
->del('myname');(->get('myname')); 
(!->exists('fake_key')) (->del('fake_key')); 
=('first_key'=>'first_val',
          'second_key'=>'second_val',
          'third_key'=>'third_val');
->mset(); =('first_key','second_key','third_key');
(->mget()); 
->(); (->mget());

• KEYS

• KEYS pattern?

• 查找符合給定模式的key。

KEYS?*命中數(shù)據(jù)庫中所有key。

KEYS?h?llo命中hello，?hallo?and?hxllo等。

KEYS?h*llo命中hllo和heeeeello等。

KEYS?h[ae]llo命中hello和hallo，但不命中hillo。

特殊符號用"\"隔開

• 時間復雜度：

• O(N)，N為數(shù)據(jù)庫中key的數(shù)量。

• 返回值：

• 符合給定模式的key列表。

警告 :KEYS的速度非?？?，但在一個大的數(shù)據(jù)庫中使用它仍然可能造成性能問題，如果你需要從一個數(shù)據(jù)集中查找特定的key，你最好還是用集合(Set)。

=('one'=>'1',
          'two'=>'2',
          'three '=>'3',
          'four'=>'4');
->mset(); (->keys('*o*')); (->keys('t??')); (->keys('t[w]*')); (->keys('*'));

RANDOMKEY

從當前數(shù)據(jù)庫中隨機返回(不刪除)一個key。

• 時間復雜度：

• O(1)

• 返回值：

• 當數(shù)據(jù)庫不為空時，返回一個key。

  當數(shù)據(jù)庫為空時，返回nil。

->FLUSHALL();
=('fruit'=>'apple',
                'drink'=>'beer',
                'food'=>'cookis');
->mset();
 ->randomkey(); 
(->keys('*')); 
->flushdb();  (-> randomkey());

• TTL
  TTL key

返回給定key的剩余生存時間(time to live)(以秒為單位)。

• 時間復雜度：

• O(1)

• 返回值：

• key的剩余生存時間(以秒為單位)。

  當key不存在或沒有設置生存時間時，返回-1?。

->flushdb();
->expire('name',30);   ->get('name');  ->ttl('name'); (->get('name')); 
->set('site','wikipedia.org');(->ttl('site'));
->EXISTS('not_exists_key');(->TTL('not_exists_key'));

• EXISTS

• EXISTS key

檢查給定key是否存在。

• 時間復雜度：

• O(1)

• 返回值：

• 若key存在，返回1，否則返回0。

 '<br>EXISTS<br>';
->set('db',"redis"); (->exists('db'));  ->del('db');   (->exists('db'))

MOVE
MOVE key db

將當前數(shù)據(jù)庫(默認為0)的key移動到給定的數(shù)據(jù)庫db當中。

如果當前數(shù)據(jù)庫(源數(shù)據(jù)庫)和給定數(shù)據(jù)庫(目標數(shù)據(jù)庫)有相同名字的給定key，或者key不存在于當前數(shù)據(jù)庫，那么MOVE沒有任何效果。

因此，也可以利用這一特性，將MOVE當作鎖(locking)原語。

• 時間復雜度：

• O(1)

• 返回值：

• 移動成功返回1，失敗則返回0。

 '<br><br>MOVE<br>';
->SELECT(0);  ->SET('song',"secret base - Zone");  (->MOVE('song',1));  
->SELECT(1);
 (->EXISTS('fake_key'));(->MOVE('fake_key', 0));  
->SELECT(0); (->EXISTS('fake_key'));  

->SELECT(0);  ->SET('favorite_fruit',"banana");

->SELECT(1);  ->SET('favorite_fruit',"apple");

->SELECT(0);  (->MOVE('favorite_fruit',1));   ->GET('favorite_fruit');  
->SELECT(1);
 ->GET('favorite_fruit');

RENAME?

• RENAME key newkey

將key改名為newkey。

當key和newkey相同或者key不存在時，返回一個錯誤。

當newkey已經(jīng)存在時，RENAME命令將覆蓋舊值。

• 時間復雜度：

• O(1)

• 返回值：

• 改名成功時提示OK，失敗時候返回一個錯誤。

 '<br><br>RENAME<br>';
->SET('message',"hello world");
(->('message','greeting'));  (->EXISTS('message'));  (->EXISTS('greeting'));   
(->('fake_key','never_exists'));  
->SET('pc',"lenovo");
->SET('personal_computer',"dell"); 
(->('pc','personal_computer')); (->GET('pc')); (->GET('personal_computer'));

• RENAMENX?

• RENAMENX key newkey

當且僅當newkey不存在時，將key改為newkey。

出錯的情況和RENAME一樣(key不存在時報錯)。

• 時間復雜度：

• O(1)

• 返回值：

• 修改成功時，返回1。

  如果newkey已經(jīng)存在，返回0。

 '<br><br>RENAMENX<br>';

->SET('player',"MPlyaer");
->EXISTS('best_player'); (->RENAMENX('player','best_player')); 
->SET('animal',"bear");
->SET('favorite_animal', "butterfly");

(->RENAMENX('animal', 'favorite_animal'));
(->get('animal')); (->get('favorite_animal'));

• TYPE

• TYPE key

返回key所儲存的值的類型。

• 時間復雜度：

• O(1)

• 返回值：

• none(key不存在) int(0)

  string(字符串) int(1)

  list(列表) int(3)

  set(集合) int(2)

  zset(有序集) int(4)

  hash(哈希表) int(5)

->flushALL();
 '<br><br>TYPE<br>';

(->TYPE('fake_key')); 
->SET('weather',"sunny");  (->TYPE('weather'));
->SADD('pat',"dog");  (->TYPE('pat')); 
->LPUSH('book_list',"programming in scala");  (->TYPE('book_list'));
->ZADD('pats',1,'cat');  ->ZADD('pats',2,'dog');
->ZADD('pats',3,'pig');
(->zRange('pats',0,-1)); (->TYPE('pats')); 
->HSET('website','google','www.g.cn');   (->HGET('website','google')); (->TYPE('website'));

EXPIRE

EXPIRE key seconds

為給定key設置生存時間。

當key過期時，它會被自動刪除。

在Redis中，帶有生存時間的key被稱作“易失的”(volatile)。

在低于2.1.3版本的Redis中，已存在的生存時間不可覆蓋。

從2.1.3版本開始，key的生存時間可以被更新，也可以被PERSIST命令移除。(詳情參見?http://redis.io/topics/expire)。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  設置成功返回1。

  當key不存在或者不能為key設置生存時間時(比如在低于2.1.3中你嘗試更新key的生存時間)，返回0。

->select(7);

 '<br><br>EXPIRE<br>';
->SET('cache_page',"www.cnblogs.com/ikodota");
->EXPIRE('cache_page', 30);  (6);
 ->TTL('cache_page').'<br>';   
->EXPIRE('cache_page', 3000);  (4);
 ->TTL('cache_page').'<br>';

?

?

• EXPIREAT?

• EXPIREAT key timestamp

EXPIREAT的作用和EXPIRE一樣，都用于為key設置生存時間。

不同在于EXPIREAT命令接受的時間參數(shù)是UNIX時間戳(unix timestamp)。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  如果生存時間設置成功，返回1。

  當key不存在或沒辦法設置生存時間，返回0。

?

 '<br><br>EXPIREAT<br>';
->SET('cache','www.google.com');
 ->EXPIREAT('cache','1355292000'); 
 (->TTL('cache'));

?

• OBJECT?

• OBJECT subcommand [arguments [arguments]]

OBJECT命令允許從內(nèi)部察看給定key的Redis對象。

它通常用在除錯(debugging)或者了解為了節(jié)省空間而對key使用特殊編碼的情況。

當將Redis用作緩存程序時，你也可以通過OBJECT命令中的信息，決定key的驅逐策略(eviction policies)。

OBJECT命令有多個子命令：

• OBJECT?REFCOUNT?返回給定key引用所儲存的值的次數(shù)。此命令主要用于除錯。

• OBJECT?ENCODING?返回給定key鎖儲存的值所使用的內(nèi)部表示(representation)。

• OBJECT?IDLETIME?返回給定key自儲存以來的空轉時間(idle， 沒有被讀取也沒有被寫入)，以秒為單位。

對象可以以多種方式編碼：

• 字符串可以被編碼為raw(一般字符串)或int(用字符串表示64位數(shù)字是為了節(jié)約空間)。

• 列表可以被編碼為ziplist或linkedlist。ziplist是為節(jié)約大小較小的列表空間而作的特殊表示。

• 集合可以被編碼為intset或者hashtable。intset是只儲存數(shù)字的小集合的特殊表示。

• 哈希表可以編碼為zipmap或者hashtable。zipmap是小哈希表的特殊表示。

• 有序集合可以被編碼為ziplist或者skiplist格式。ziplist用于表示小的有序集合，而skiplist則用于表示任何大小的有序集合。

假如你做了什么讓Redis沒辦法再使用節(jié)省空間的編碼時(比如將一個只有1個元素的集合擴展為一個有100萬個元素的集合)，特殊編碼類型(specially encoded types)會自動轉換成通用類型(general type)。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  REFCOUNT和IDLETIME返回數(shù)字。

  ENCODING返回相應的編碼類型。

->select(8);
 '<br><br>OBJECT<br>';
->SET('game',"WOW");  ->('REFCOUNT','game');   ->('IDLETIME','game');  (->('ENCODING','game'));  ->SET('phone',15820123123);  (->('ENCODING','phone')); ->SET('age',20);  (->('ENCODING','age'));

?

• PERSIST?

• PERSIST key

?

移除給定key的生存時間。

?

• 時間復雜度：

• O(1)

• 返回值：

• 
  

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

  如果key不存在或key沒有設置生存時間，返回0。

?

 '<br><br>PERSIST<br>';
->SET('time_to_say_goodbye',"886...");
->EXPIRE('time_to_say_goodbye', 300);
(3);
 ->TTL('time_to_say_goodbye');  '<br>';

->PERSIST('time_to_say_goodbye');   ->TTL('time_to_say_goodbye');

SORT

?

• SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

排序，分頁等
參數(shù)

array(
‘by’ => ‘some_pattern_*’,
‘limit’ => array(0, 1),
‘get’ => ‘some_other_pattern_*’ or an array of patterns,
‘sort’ => ‘a(chǎn)sc’ or ‘desc’,
‘a(chǎn)lpha’ => TRUE,
‘store’ => ‘external-key’
)

返回或保存給定列表、集合、有序集合key中經(jīng)過排序的元素。

排序默認以數(shù)字作為對象，值被解釋為雙精度浮點數(shù)，然后進行比較。

?

一般SORT用法

最簡單的SORT使用方法是SORT?key。

假設today_cost是一個保存數(shù)字的列表，SORT命令默認會返回該列表值的遞增(從小到大)排序結果。

?

->LPUSH('today_cost', 30);
->LPUSH('today_cost', 1.5);
->LPUSH('today_cost', 10);
->LPUSH('today_cost', 8);

(->('today_cost'));

當數(shù)據(jù)集中保存的是字符串值時，你可以用ALPHA修飾符(modifier)進行排序。

->LPUSH('website', "www.reddit.com");
->LPUSH('website', "www.slashdot.com");
->LPUSH('website', "www.infoq.com");
(->('website'));
(->('website', ('ALPHA'=>)));

如果你正確設置了!LC_COLLATE環(huán)境變量的話，Redis能識別UTF-8編碼。

排序之后返回的元素數(shù)量可以通過LIMIT修飾符進行限制。

LIMIT修飾符接受兩個參數(shù)：offset和count。

offset指定要跳過的元素數(shù)量，count指定跳過offset個指定的元素之后，要返回多少個對象。

以下例子返回排序結果的前5個對象(offset為0表示沒有元素被跳過)。

->LPUSH('rank', 30); ->LPUSH('rank', 56); ->LPUSH('rank', 42); ->LPUSH('rank', 22); ->LPUSH('rank', 0);  ->LPUSH('rank', 11); ->LPUSH('rank', 32); ->LPUSH('rank', 67); ->LPUSH('rank', 50); ->LPUSH('rank', 44); ->LPUSH('rank', 55); 
=('LIMIT'=>(0,5));
(->('rank',));

修飾符可以組合使用。以下例子返回降序(從大到小)的前5個對象。

=(
            'LIMIT'=>(0,5),
            'SORT'=>'DESC'
            );
(->('rank',));

?

使用外部key進行排序

有時候你會希望使用外部的key作為權重來比較元素，代替默認的對比方法。

假設現(xiàn)在有用戶(user)數(shù)據(jù)如下：

id　　　 ?name　　　　level
-------------------------------
1　　　　admin　　　 ?9999
2　　　　huangz　　　10
59230 　jack 　　　 ? ?3
222 　　?hacker 　　 ??9999

id數(shù)據(jù)保存在key名為user_id的列表中。
name數(shù)據(jù)保存在key名為user_name_{id}的列表中
level數(shù)據(jù)保存在user_level_{id}的key中。

->LPUSH('user_id', 1);->SET('user_name_1', 'admin');
->SET('user_level_1',9999);

->LPUSH('user_id', 2);->SET('user_name_2', 'huangz');
->SET('user_level_2', 10);

->LPUSH('user_id', 59230);->SET('user_name_59230','jack');
->SET('user_level_59230', 3);

->LPUSH('user_id', 222);  ->SET('user_name_222', 'hacker');
->SET('user_level_222', 9999);

?

如果希望按level從大到小排序user_id，可以使用以下命令：

=('BY'=>'user_level_*',
            'SORT'=>'DESC'
            );
(->('user_id',));

但是有時候只是返回相應的id沒有什么用，你可能更希望排序后返回id對應的用戶名，這樣更友好一點，使用GET選項可以做到這一點：

?

=('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>'user_name_*'
            );
(->('user_id', ));

#1) "hacker"#2) "admin"#3) "huangz"#4) "jack"

可以多次地、有序地使用GET操作來獲取更多外部key。

比如你不但希望獲取用戶名，還希望連用戶的密碼也一并列出，可以使用以下命令：

?

->SET('user_password_222', "hey,im in");
->SET('user_password_1', "a_long_long_password");
->SET('user_password_2', "nobodyknows");
->SET('user_password_59230', "jack201022");

=('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>('user_name_*','user_password_*')
            );
(->('user_id',));

# 注意GET操作是有序的，GET user_name_* GET user_password_* 和 GET user_password_* GET user_name_*返回的結果位置不同

?

=('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>('','')
            );
(->('user_id',));

GET還有一個特殊的規(guī)則——"GET?#"，用于獲取被排序對象(我們這里的例子是user_id)的當前元素。

比如你希望user_id按level排序，還要列出id、name和password，可以使用以下命令：

?

=('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>('#','user_password_*','user_name_*')
            );
(->('user_id',));

只獲取對象而不排序

BY修飾符可以將一個不存在的key當作權重，讓SORT跳過排序操作。

該方法用于你希望獲取外部對象而又不希望引起排序開銷時使用。

?

->EXISTS('fake_key');
=('BY'=>'fake_key',
            'SORT'=>'DESC',
            'GET'=>('#','user_name_*','user_password_*')
            );
(->('user_id',));

保存排序結果

默認情況下，SORT操作只是簡單地返回排序結果，如果你希望保存排序結果，可以給STORE選項指定一個key作為參數(shù)，排序結果將以列表的形式被保存到這個key上。(若指定key已存在，則覆蓋。)

->EXISTS('user_info_sorted_by_level');  =('BY'=>'user_level_*',
            'GET'=>('#','user_name_*','user_password_*'),
            'STORE'=>'user_info_sorted_by_level'
            );

(->('user_id',)); (->LRANGE('user_info_sorted_by_level', 0 ,11));

一個有趣的用法是將SORT結果保存，用EXPIRE為結果集設置生存時間，這樣結果集就成了SORT操作的一個緩存。

這樣就不必頻繁地調(diào)用SORT操作了，只有當結果集過期時，才需要再調(diào)用一次SORT操作。

有時候為了正確實現(xiàn)這一用法，你可能需要加鎖以避免多個客戶端同時進行緩存重建(也就是多個客戶端，同一時間進行SORT操作，并保存為結果集)，具體參見SETNX命令。

在GET和BY中使用哈希表

可以使用哈希表特有的語法，在SORT命令中進行GET和BY操作。

=(1=>'23131283',
                2=>'23810573',
                222=>'502342349',
                59230=>'2435829758'
                );

->HMSET('serial',);

=('BY'=>'*->serial');
(->('user_id', ));

?

符號"->"用于分割哈希表的關鍵字(key name)和索引域(hash field)，格式為"key->field"。

除此之外，哈希表的BY和GET操作和上面介紹的其他數(shù)據(jù)結構(列表、集合、有序集合)沒有什么不同。

• 時間復雜度：

• 
  

  O(N+M*log(M))，N為要排序的列表或集合內(nèi)的元素數(shù)量，M為要返回的元素數(shù)量。

  如果只是使用SORT命令的GET選項獲取數(shù)據(jù)而沒有進行排序，時間復雜度O(N)。

• 返回值：

• 
  

  沒有使用STORE參數(shù)，返回列表形式的排序結果。

  使用STORE參數(shù)，返回排序結果的元素數(shù)量。

?

字符串(String)

SET

• SET key value

將字符串值value關聯(lián)到key。

如果key已經(jīng)持有其他值，SET就覆寫舊值，無視類型。

時間復雜度：O(1)返回值：總是返回OK(TRUE)，因為SET不可能失敗。

->SET('apple', 'www.apple.com');->GET('apple');
->LPUSH('greet_list', "hello");  ->TYPE('greet_list');
->SET('greet_list', "yooooooooooooooooo");   ->TYPE('greet_list');

?

SETNX

• SETNX key value

將key的值設為value，當且僅當key不存在。

若給定的key已經(jīng)存在，則SETNX不做任何動作。

SETNX是”SET if Not eXists”(如果不存在，則SET)的簡寫。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  設置成功，返回1。

  設置失敗，返回0。

 '<br><br>SETNX<br>';
->EXISTS('job');  ->SETNX('job', "programmer");  ->SETNX('job', "code-farmer");   ->GET('job');

設計模式(Design pattern): 將SETNX用于加鎖(locking)

SETNX可以用作加鎖原語(locking primitive)。比如說，要對關鍵字(key)foo加鎖，客戶端可以嘗試以下方式：

SETNX?lock.foo??Unix?time?+?lock?timeout?+?1>

如果SETNX返回1，說明客戶端已經(jīng)獲得了鎖，key設置的unix時間則指定了鎖失效的時間。之后客戶端可以通過DEL?lock.foo來釋放鎖。

如果SETNX返回0，說明key已經(jīng)被其他客戶端上鎖了。如果鎖是非阻塞(non blocking lock)的，我們可以選擇返回調(diào)用，或者進入一個重試循環(huán)，直到成功獲得鎖或重試超時(timeout)。

處理死鎖(deadlock)

上面的鎖算法有一個問題：如果因為客戶端失敗、崩潰或其他原因導致沒有辦法釋放鎖的話，怎么辦？

這種狀況可以通過檢測發(fā)現(xiàn)——因為上鎖的key保存的是unix時間戳，假如key值的時間戳小于當前的時間戳，表示鎖已經(jīng)不再有效。

但是，當有多個客戶端同時檢測一個鎖是否過期并嘗試釋放它的時候，我們不能簡單粗暴地刪除死鎖的key，再用SETNX上鎖，因為這時競爭條件(race condition)已經(jīng)形成了：

• C1和C2讀取lock.foo并檢查時間戳，SETNX都返回0，因為它已經(jīng)被C3鎖上了，但C3在上鎖之后就崩潰(crashed)了。

• C1向lock.foo發(fā)送DEL命令。

• C1向lock.foo發(fā)送SETNX并成功。

• C2向lock.foo發(fā)送DEL命令。

• C2向lock.foo發(fā)送SETNX并成功。

• 出錯：因為競爭條件的關系，C1和C2兩個都獲得了鎖。

幸好，以下算法可以避免以上問題。來看看我們聰明的C4客戶端怎么辦：

• C4向lock.foo發(fā)送SETNX命令。

• 因為崩潰掉的C3還鎖著lock.foo，所以Redis向C4返回0。

• C4向lock.foo發(fā)送GET命令，查看lock.foo的鎖是否過期。如果不，則休眠(sleep)一段時間，并在之后重試。

• 另一方面，如果lock.foo內(nèi)的unix時間戳比當前時間戳老，C4執(zhí)行以下命令：

GETSET?lock.foo??Unix?timestamp?+?lock?timeout?+?1>

• 因為GETSET的作用，C4可以檢查看GETSET的返回值，確定lock.foo之前儲存的舊值仍是那個過期時間戳，如果是的話，那么C4獲得鎖。

• 如果其他客戶端，比如C5，比C4更快地執(zhí)行了GETSET操作并獲得鎖，那么C4的GETSET操作返回的就是一個未過期的時間戳(C5設置的時間戳)。C4只好從第一步開始重試。

注意，即便C4的GETSET操作對key進行了修改，這對未來也沒什么影響。

(這里是不是有點問題？C4的確是可以重試，但C5怎么辦？它的鎖的過期被C4修改了?！g注)

?警告為了讓這個加鎖算法更健壯，獲得鎖的客戶端應該常常檢查過期時間以免鎖因諸如DEL等命令的執(zhí)行而被意外解開，因為客戶端失敗的情況非常復雜，不僅僅是崩潰這么簡單，還可能是客戶端因為某些操作被阻塞了相當長時間，緊接著DEL命令被嘗試執(zhí)行(但這時鎖卻在另外的客戶端手上)。

?

SETEX

SETEX key seconds value

將值value關聯(lián)到key，并將key的生存時間設為seconds(以秒為單位)。

如果key?已經(jīng)存在，SETEX命令將覆寫舊值。

這個命令類似于以下兩個命令：

->SET('key', 'value');
->EXPIRE('key','seconds');

不同之處是，SETEX是一個原子性(atomic)操作，關聯(lián)值和設置生存時間兩個動作會在同一時間內(nèi)完成，該命令在Redis用作緩存時，非常實用。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  設置成功時返回OK。

  當seconds參數(shù)不合法時，返回一個錯誤。

->SETEX('cache_user_id', 60,10086); ->GET('cache_user_id');  
(4);
 ->TTL('cache_user_id');  
->SET('cd', "timeless"); ->SETEX('cd', 3000,"goodbye my love");  ->GET('cd');

?

SETRANGE

SETRANGE key offset value

用value參數(shù)覆寫(Overwrite)給定key所儲存的字符串值，從偏移量offset開始。

不存在的key當作空白字符串處理。

SETRANGE命令會確保字符串足夠長以便將value設置在指定的偏移量上，如果給定key原來儲存的字符串長度比偏移量小(比如字符串只有5個字符長，但你設置的offset是10)，那么原字符和偏移量之間的空白將用零比特(zerobytes,"\x00")來填充。

注意你能使用的最大偏移量是2^29-1(536870911)，因為Redis的字符串被限制在512兆(megabytes)內(nèi)。如果你需要使用比這更大的空間，你得使用多個key。

• 時間復雜度：

• 
  

  對小(small)的字符串，平攤復雜度O(1)。(關于什么字符串是”小”的，請參考APPEND命令)

  否則為O(M)，M為value參數(shù)的長度。

• 返回值：

• 被SETRANGE修改之后，字符串的長度。

?警告

?當生成一個很長的字符串時，Redis需要分配內(nèi)存空間，該操作有時候可能會造成服務器阻塞(block)。在2010年的Macbook Pro上，設置偏移量為536870911(512MB內(nèi)存分配)，耗費約300毫秒， 設置偏移量為134217728(128MB內(nèi)存分配)，耗費約80毫秒，設置偏移量33554432(32MB內(nèi)存分配)，耗費約30毫秒，設置偏移量為8388608(8MB內(nèi)存分配)，耗費約8毫秒。 注意若首次內(nèi)存分配成功之后，再對同一個key調(diào)用SETRANGE操作，無須再重新內(nèi)存。

模式

因為有了SETRANGE和GETRANGE命令，你可以將Redis字符串用作具有O(1)隨機訪問時間的線性數(shù)組。這在很多真實用例中都是非?？焖偾腋咝У膬Υ娣绞健?/p>

->SET('greeting', "hello world");
->SETRANGE('greeting', 6, "Redis"); ->GET('greeting');
->EXISTS('empty_string');->SETRANGE('empty_string', 5 ,"Redis!");  (->GET('empty_string'));

MSET?
MSET key value [key value ...]

同時設置一個或多個key-value對。

當發(fā)現(xiàn)同名的key存在時，MSET會用新值覆蓋舊值，如果你不希望覆蓋同名key，請使用MSETNX命令。

MSET是一個原子性(atomic)操作，所有給定key都在同一時間內(nèi)被設置，某些給定key被更新而另一些給定key沒有改變的情況，不可能發(fā)生。

• 時間復雜度：

• O(N)，N為要設置的key數(shù)量。

• 返回值：

• 總是返回OK(因為MSET不可能失敗)

 '<br><br>MSET<br>';
->select(0);
->flushdb();
=('date'=>'2012.3.5',
        'time'=>'9.09a.m.',
        'weather'=>'sunny'
        );
->MSET(); 
(->KEYS('*'));   
(->SET('google', "google.cn"));   (->MSET('google',"google.hk"));  ->GET('google');

?

MSETNX

• MSETNX key value [key value ...]

同時設置一個或多個key-value對，當且僅當key不存在。

即使只有一個key已存在，MSETNX也會拒絕所有傳入key的設置操作

MSETNX是原子性的，因此它可以用作設置多個不同key表示不同字段(field)的唯一性邏輯對象(unique logic object)，所有字段要么全被設置，要么全不被設置。

• 時間復雜度：

• O(N)，N為要設置的key的數(shù)量。

• 返回值：

• 
  

  當所有key都成功設置，返回1。

  如果所有key都設置失敗(最少有一個key已經(jīng)存在)，那么返回0。

=('rmdbs'=>'MySQL',
        'nosql'=>'MongoDB',
        'key-value-store'=>'redis'
        );
->MSETNX();

=('rmdbs'=>'Sqlite',
        'language'=>'python'
        );
(->MSETNX());  (->EXISTS('language'));  
 ->GET('rmdbs');  
=( 'rmdbs', 'nosql', 'key-value-store');
(->MGET());

?

APPEND

• APPEND key value

如果key已經(jīng)存在并且是一個字符串，APPEND命令將value追加到key原來的值之后。

如果key不存在，APPEND就簡單地將給定key設為value，就像執(zhí)行SET?key?value一樣。

• 時間復雜度：

• 平攤復雜度O(1)

• 返回值：

• 追加value之后，key中字符串的長度。

->EXISTS('myphone');  ->APPEND('myphone',"nokia");  
->APPEND('myphone', " - 1110");
 ->GET('myphone');

GET

• GET key

返回key所關聯(lián)的字符串值。

如果key不存在則返回特殊值nil。

假如key儲存的值不是字符串類型，返回一個錯誤，因為GET只能用于處理字符串值。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  key的值。

  如果key不存在，返回nil。

?

(->GET('fake_key')); ->SET('animate', "anohana"); (->GET('animate'));

?

MGET

• MGET key [key ...]

返回所有(一個或多個)給定key的值。

如果某個指定key不存在，那么返回特殊值nil。因此，該命令永不失敗。

• 時間復雜度:

• O(1)

• 返回值：

• 一個包含所有給定key的值的列表。

 '<br><br>MGET<br>';
=('name'=>'ikodota','blog'=>'cnblogs.com/ikodota');
->MSET();
=('name','blog');
(->MGET()); 
->EXISTS('fake_key'); 
=('name','fake_key');
(->MGET());

GETRANGE

• GETRANGE key start end

返回key中字符串值的子字符串，字符串的截取范圍由start和end兩個偏移量決定(包括start和end在內(nèi))。

負數(shù)偏移量表示從字符串最后開始計數(shù)，-1表示最后一個字符，-2表示倒數(shù)第二個，以此類推。

GETRANGE通過保證子字符串的值域(range)不超過實際字符串的值域來處理超出范圍的值域請求。

• 時間復雜度：

• 
  

  O(N)，N為要返回的字符串的長度。

  復雜度最終由返回值長度決定，但因為從已有字符串中建立子字符串的操作非常廉價(cheap)，所以對于長度不大的字符串，該操作的復雜度也可看作O(1)。

• 返回值：

• 截取得出的子字符串。

注解:在

 '<br><br>GETRANGE<br>';
->SET('greeting', "hello, my friend");
 ->GETRANGE('greeting', 0, 4).'<br>';   ->GETRANGE('greeting', -1 ,-5).'<br>';   ->GETRANGE('greeting', -3 ,-1).'<br>';   ->GETRANGE('greeting', 0, -1).'<br>';   ->GETRANGE('greeting', 0, 1008611).'<br>';

?

GETSET

• GETSET key value

將給定key的值設為value，并返回key的舊值。

當key存在但不是字符串類型時，返回一個錯誤。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  返回給定key的舊值(old value)。

  當key沒有舊值時，返回nil。

 '<br><br>GETSET<br>';
(->EXISTS('mail'));(->GETSET('mail','xxx@google.com'));  
(->GETSET('mail','xxx@yahoo.com'));

設計模式

GETSET可以和INCR組合使用，實現(xiàn)一個有原子性(atomic)復位操作的計數(shù)器(counter)。

舉例來說，每次當某個事件發(fā)生時，進程可能對一個名為mycount的key調(diào)用INCR操作，通常我們還要在一個原子時間內(nèi)同時完成獲得計數(shù)器的值和將計數(shù)器值復位為0兩個操作。

可以用命令GETSET?mycounter?0來實現(xiàn)這一目標。

->SELECT(2);
 ->INCR('mycount').'<br>'; 
(->GET('mycount')>19){
 ->GETSET('mycount', 0).'<br>';  }
 ->GET('mycount');

?

STRLEN

• STRLEN key

返回key所儲存的字符串值的長度。

當key儲存的不是字符串值時，返回一個錯誤。

• 復雜度：

• O(1)

• 返回值：

• 
  

  字符串值的長度。

  當?key不存在時，返回0。

->SET('mykey', "Hello world");
 ->('mykey');  ->('nonexisting');

INCR

• INCR key

將key中儲存的數(shù)字值增一。

如果key不存在，以0為key的初始值，然后執(zhí)行INCR操作。

如果值包含錯誤的類型，或字符串類型的值不能表示為數(shù)字，那么返回一個錯誤。

本操作的值限制在64位(bit)有符號數(shù)字表示之內(nèi)。

• 時間復雜度：

• O(1)

• 返回值：

• 執(zhí)行INCR命令之后key的值。

注解:這是一個針對字符串的操作，因為Redis沒有專用的整數(shù)類型，所以key內(nèi)儲存的字符串被解釋為十進制64位有符號整數(shù)來執(zhí)行INCR操作。

->SET('page_view', 20);
(->INCR('page_view')); (->GET('page_view'));

INCRBY

• INCRBY key increment

將key所儲存的值加上增量increment。

如果key不存在，以0為key的初始值，然后執(zhí)行INCRBY命令。

如果值包含錯誤的類型，或字符串類型的值不能表示為數(shù)字，那么返回一個錯誤。

本操作的值限制在64位(bit)有符號數(shù)字表示之內(nèi)。

關于更多遞增(increment)/遞減(decrement)操作信息，參見INCR命令。

• 時間復雜度：

• O(1)

• 返回值：

• 加上increment之后，key的值。

 '<br><br>INCRBY<br>';
->SET('rank', 50);  ->INCRBY('rank', 20);  (->GET('rank')); 
->EXISTS('counter'); ->INCRBY('counter'); (->GET('counter')); 
->SET('book', "long long ago...");
(->INCRBY('book', 200));

?

DECR

• DECR key

將key中儲存的數(shù)字值減一。

如果key不存在，以0為key的初始值，然后執(zhí)行DECR操作。

如果值包含錯誤的類型，或字符串類型的值不能表示為數(shù)字，那么返回一個錯誤。

本操作的值限制在64位(bit)有符號數(shù)字表示之內(nèi)。

關于更多遞增(increment)/遞減(decrement)操作信息，參見INCR命令。

• 時間復雜度：

• O(1)

• 返回值：

• 執(zhí)行DECR命令之后key的值。

->SELECT(3);
->flushdb();
 '<br><br>DECR<br>';
->SET('failure_times', 10);
->DECR('failure_times');  ->GET('failure_times').'<br>';  
->EXISTS('count'); ->DECR('count');   ->GET('count').'<br>'; 
->SET('company', 'YOUR_CODE_SUCKS.LLC');
(->DECR('company'));  ->GET('company').'<br>';

?

DECRBY

• DECRBY key decrement

將key所儲存的值減去減量decrement。

如果key不存在，以0為key的初始值，然后執(zhí)行DECRBY操作。

如果值包含錯誤的類型，或字符串類型的值不能表示為數(shù)字，那么返回一個錯誤。

本操作的值限制在64位(bit)有符號數(shù)字表示之內(nèi)。

關于更多遞增(increment)/遞減(decrement)操作信息，參見INCR命令。

• 時間復雜度：

• O(1)

• 返回值：

• 減去decrement之后，key的值。

->SET('count', 100);
(->DECRBY('count', 20)); (->GET('count'));  
->EXISTS('pages');(->DECRBY('pages', 10));  (->GET('pages'));

?

SETBIT

• SETBIT key offset value

對key所儲存的字符串值，設置或清除指定偏移量上的位(bit)。

位的設置或清除取決于value參數(shù)，可以是0也可以是1。

當key不存在時，自動生成一個新的字符串值。

字符串會增長(grown)以確保它可以將value保存在指定的偏移量上。當字符串值增長時，空白位置以0填充。

offset參數(shù)必須大于或等于0，小于2^32(bit映射被限制在512MB內(nèi))。

• 時間復雜度:

• O(1)

• 返回值：

• 指定偏移量原來儲存的位（"0"或"1"）.

警告:對使用大的offset的SETBIT操作來說，內(nèi)存分配可能造成Redis服務器被阻塞。具體參考SETRANGE命令，warning(警告)部分。

 '<br><br>SETBIT<br>';
=67;
 ().'<br>'; (->SETBIT('bit',1,1));(->SETBIT('bit',2,0));(->SETBIT('bit',3,0));(->SETBIT('bit',4,0));(->SETBIT('bit',5,0));(->SETBIT('bit',6,1));(->SETBIT('bit',7,1));
(->GET('bit')); 
(->GETBIT('bit', 6 )); 
(->SETBIT('bit',5,1));(->SETBIT('bit',6,0));
(->GET('bit'));

GETBIT

• GETBIT key offset

對key所儲存的字符串值，獲取指定偏移量上的位(bit)。

當offset比字符串值的長度大，或者key不存在時，返回0。

• 時間復雜度：

• O(1)

• 返回值：

• 字符串值指定偏移量上的位(bit)。

#參見SETBIT的示例

?

哈希表(Hash)

HSET

• HSET key field value

將哈希表key中的域field的值設為value。

如果key不存在，一個新的哈希表被創(chuàng)建并進行HSET操作。

如果域field已經(jīng)存在于哈希表中，舊值將被覆蓋。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  如果field是哈希表中的一個新建域，并且值設置成功，返回1。

  如果哈希表中域field已經(jīng)存在且舊值已被新值覆蓋，返回0。

?

HSETNX

• HSETNX key field value

將哈希表key中的域field的值設置為value，當且僅當域field不存在。

若域field已經(jīng)存在，該操作無效。

如果key不存在，一個新哈希表被創(chuàng)建并執(zhí)行HSETNX命令。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  設置成功，返回1。

  如果給定域已經(jīng)存在且沒有操作被執(zhí)行，返回0。

?

HMSET

• HMSET key field value [field value ...]

同時將多個field?-?value(域-值)對設置到哈希表key中。

此命令會覆蓋哈希表中已存在的域。

如果key不存在，一個空哈希表被創(chuàng)建并執(zhí)行HMSET操作。

• 時間復雜度：

• O(N)，N為field?-?value對的數(shù)量。

• 返回值：

• 
  

  如果命令執(zhí)行成功，返回OK。

  當key不是哈希表(hash)類型時，返回一個錯誤。

?

?

HGET

• HGET key field

返回哈希表key中給定域field的值。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  給定域的值。

  當給定域不存在或是給定key不存在時，返回nil。

?

HMGET

• HMGET key field [field ...]

返回哈希表key中，一個或多個給定域的值。

如果給定的域不存在于哈希表，那么返回一個nil值。

因為不存在的key被當作一個空哈希表來處理，所以對一個不存在的key進行HMGET操作將返回一個只帶有nil值的表。

• 時間復雜度：

• O(N)，N為給定域的數(shù)量。

• 返回值：

• 一個包含多個給定域的關聯(lián)值的表，表值的排列順序和給定域參數(shù)的請求順序一樣。

?

?

HGETALL

• HGETALL key

返回哈希表key中，所有的域和值。

在返回值里，緊跟每個域名(field name)之后是域的值(value)，所以返回值的長度是哈希表大小的兩倍。

• 時間復雜度：

• O(N)，N為哈希表的大小。

• 返回值：

• 以列表形式返回哈希表的域和域的值。 若key不存在，返回空列表。

?

?

HDEL

• HDEL key field [field ...]

刪除哈希表key中的一個或多個指定域，不存在的域將被忽略。

• 時間復雜度:

• O(N)，N為要刪除的域的數(shù)量。

• 返回值:

• 被成功移除的域的數(shù)量，不包括被忽略的域。

注解:在Redis2.4以下的版本里，HDEL每次只能刪除單個域，如果你需要在一個原子時間內(nèi)刪除多個域，請將命令包含在MULTI/?EXEC塊內(nèi)。

?

HLEN

• HLEN key

返回哈希表key中域的數(shù)量。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  哈希表中域的數(shù)量。

  當key不存在時，返回0。

?

HEXISTS

• HEXISTS key field

查看哈希表key中，給定域field是否存在。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  如果哈希表含有給定域，返回1。

  如果哈希表不含有給定域，或key不存在，返回0。

?

HINCRBY

• HINCRBY key field increment

為哈希表key中的域field的值加上增量increment。

增量也可以為負數(shù)，相當于對給定域進行減法操作。

如果key不存在，一個新的哈希表被創(chuàng)建并執(zhí)行HINCRBY命令。

如果域field不存在，那么在執(zhí)行命令前，域的值被初始化為0。

對一個儲存字符串值的域field執(zhí)行HINCRBY命令將造成一個錯誤。

本操作的值限制在64位(bit)有符號數(shù)字表示之內(nèi)。

• 時間復雜度：

• O(1)

• 返回值：

• 執(zhí)行HINCRBY命令之后，哈希表key中域field的值。

?

HKEYS

• HKEYS key

返回哈希表key中的所有域。

• 時間復雜度：

• O(N)，N為哈希表的大小。

• 返回值：

• 
  

  一個包含哈希表中所有域的表。

  當key不存在時，返回一個空表。

?

HVALS

• HVALS key

返回哈希表key中的所有值。

• 時間復雜度：

• O(N)，N為哈希表的大小。

• 返回值：

• 
  

  一個包含哈希表中所有值的表。

  當key不存在時，返回一個空表。

?

表(List)

頭元素和尾元素

頭元素指的是列表左端/前端第一個元素，尾元素指的是列表右端/后端第一個元素。

舉個例子，列表list包含三個元素：x,?y,?z，其中x是頭元素，而z則是尾元素。

空列表

指不包含任何元素的列表，Redis將不存在的key也視為空列表。

?

LPUSH

• LPUSH key value [value ...]

將一個或多個值value插入到列表key的表頭。

如果有多個value值，那么各個value值按從左到右的順序依次插入到表頭：比如對一個空列表(mylist)執(zhí)行LPUSH?mylist?a?b?c，則結果列表為c?b?a，等同于執(zhí)行執(zhí)行命令LPUSH?mylist?a、LPUSH?mylist?b、LPUSH?mylist?c。

如果key不存在，一個空列表會被創(chuàng)建并執(zhí)行LPUSH操作。

當key存在但不是列表類型時，返回一個錯誤。

• 時間復雜度：

• O(1)

• 返回值：

• 執(zhí)行LPUSH命令后，列表的長度。

?

注解:在Redis 2.4版本以前的LPUSH命令，都只接受單個value值。

?

LPUSHX

• LPUSHX key value

將值value插入到列表key的表頭，當且僅當key存在并且是一個列表。

和LPUSH命令相反，當key不存在時，LPUSHX命令什么也不做。

• 時間復雜度：

• O(1)

• 返回值：

• LPUSHX命令執(zhí)行之后，表的長度。

?

RPUSH

• RPUSH key value [value ...]

將一個或多個值value插入到列表key的表尾。

如果有多個value值，那么各個value值按從左到右的順序依次插入到表尾：比如對一個空列表(mylist)執(zhí)行RPUSH?mylist?a?b?c，則結果列表為a?b?c，等同于執(zhí)行命令RPUSHmylist?a、RPUSH?mylist?b、RPUSH?mylist?c。

如果key不存在，一個空列表會被創(chuàng)建并執(zhí)行RPUSH操作。

當key存在但不是列表類型時，返回一個錯誤。

• 時間復雜度：

• O(1)

• 返回值：

• 執(zhí)行RPUSH操作后，表的長度。

注解:在Redis 2.4版本以前的RPUSH命令，都只接受單個value值。

?

RPUSHX

• RPUSHX key value

將值value插入到列表key的表尾，當且僅當key存在并且是一個列表。

和RPUSH命令相反，當key不存在時，RPUSHX命令什么也不做。

• 時間復雜度：

• O(1)

• 返回值：

• RPUSHX命令執(zhí)行之后，表的長度。

?

LPOP

• LPOP key

移除并返回列表key的頭元素。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  列表的頭元素。

  當key不存在時，返回nil。

?

RPOP

• RPOP key

移除并返回列表key的尾元素。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  列表的尾元素。

  當key不存在時，返回nil。

?

BLPOP

• BLPOP key [key ...] timeout

BLPOP是列表的阻塞式(blocking)彈出原語。

它是LPOP命令的阻塞版本，當給定列表內(nèi)沒有任何元素可供彈出的時候，連接將被BLPOP命令阻塞，直到等待超時或發(fā)現(xiàn)可彈出元素為止。

當給定多個key參數(shù)時，按參數(shù)key的先后順序依次檢查各個列表，彈出第一個非空列表的頭元素。

非阻塞行為

當BLPOP被調(diào)用時，如果給定key內(nèi)至少有一個非空列表，那么彈出遇到的第一個非空列表的頭元素，并和被彈出元素所屬的列表的名字一起，組成結果返回給調(diào)用者。

當存在多個給定key時，BLPOP按給定key參數(shù)排列的先后順序，依次檢查各個列表。

假設現(xiàn)在有job、?command和request三個列表，其中job不存在，command和request都持有非空列表。考慮以下命令：

BLPOP?job?command?request?0

BLPOP保證返回的元素來自command，因為它是按”查找job?-> 查找command?-> 查找request“這樣的順序，第一個找到的非空列表。

?

?

阻塞行為

如果所有給定key都不存在或包含空列表，那么BLPOP命令將阻塞連接，直到等待超時，或有另一個客戶端對給定key的任意一個執(zhí)行LPUSH或RPUSH命令為止。

超時參數(shù)timeout接受一個以秒為單位的數(shù)字作為值。超時參數(shù)設為0表示阻塞時間可以無限期延長(block indefinitely) 。

?

?

相同的key被多個客戶端同時阻塞

相同的key可以被多個客戶端同時阻塞。

不同的客戶端被放進一個隊列中，按”先阻塞先服務”(first-BLPOP，first-served)的順序為key執(zhí)行BLPOP命令。

在MULTI/EXEC事務中的BLPOP

BLPOP可以用于流水線(pipline,批量地發(fā)送多個命令并讀入多個回復)，但把它用在MULTI/EXEC塊當中沒有意義。因為這要求整個服務器被阻塞以保證塊執(zhí)行時的原子性，該行為阻止了其他客戶端執(zhí)行LPUSH或RPUSH命令。

因此，一個被包裹在MULTI/EXEC塊內(nèi)的BLPOP命令，行為表現(xiàn)得就像LPOP一樣，對空列表返回nil，對非空列表彈出列表元素，不進行任何阻塞操作。

?

?

時間復雜度：O(1)返回值：

如果列表為空，返回一個nil。

反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的key，第二個元素是被彈出元素的值。

?

?

BRPOP

• BRPOP key [key ...] timeout

BRPOP是列表的阻塞式(blocking)彈出原語。

它是RPOP命令的阻塞版本，當給定列表內(nèi)沒有任何元素可供彈出的時候，連接將被BRPOP命令阻塞，直到等待超時或發(fā)現(xiàn)可彈出元素為止。

當給定多個key參數(shù)時，按參數(shù)key的先后順序依次檢查各個列表，彈出第一個非空列表的尾部元素。

關于阻塞操作的更多信息，請查看BLPOP命令，BRPOP除了彈出元素的位置和BLPOP不同之外，其他表現(xiàn)一致。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  假如在指定時間內(nèi)沒有任何元素被彈出，則返回一個nil和等待時長。

  反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的key，第二個元素是被彈出元素的值。

?

LLEN

• LLEN key

返回列表key的長度。

如果key不存在，則key被解釋為一個空列表，返回0.

如果key不是列表類型，返回一個錯誤。

• 時間復雜度：

• O(1)

• 返回值：

• 列表key的長度。

?

LRANGE

• LRANGE key start stop

返回列表key中指定區(qū)間內(nèi)的元素，區(qū)間以偏移量start和stop指定。

下標(index)參數(shù)start和stop都以0為底，也就是說，以0表示列表的第一個元素，以1表示列表的第二個元素，以此類推。

你也可以使用負數(shù)下標，以-1表示列表的最后一個元素，-2表示列表的倒數(shù)第二個元素，以此類推。

注意LRANGE命令和編程語言區(qū)間函數(shù)的區(qū)別

假如你有一個包含一百個元素的列表，對該列表執(zhí)行LRANGE?list?0?10，結果是一個包含11個元素的列表，這表明stop下標也在LRANGE命令的取值范圍之內(nèi)(閉區(qū)間)，這和某些語言的區(qū)間函數(shù)可能不一致，比如Ruby的Range.new、Array#slice和Python的range()函數(shù)。

超出范圍的下標

超出范圍的下標值不會引起錯誤。

如果start下標比列表的最大下標end(LLEN?list減去1)還要大，或者start?>?stop，LRANGE返回一個空列表。

如果stop下標比end下標還要大，Redis將stop的值設置為end。

• 時間復雜度:

• O(S+N)，S為偏移量start，N為指定區(qū)間內(nèi)元素的數(shù)量。

• 返回值:

• 一個列表，包含指定區(qū)間內(nèi)的元素。

?

LREM

• LREM key count value

根據(jù)參數(shù)count的值，移除列表中與參數(shù)value相等的元素。

• count的值可以是以下幾種：

• • count?>?0: 從表頭開始向表尾搜索，移除與value相等的元素，數(shù)量為count。

  • count??0: 從表尾開始向表頭搜索，移除與value相等的元素，數(shù)量為count的絕對值。

  • count?=?0: 移除表中所有與value相等的值。

• 時間復雜度：

• O(N)，N為列表的長度。

• 返回值：

• 
  

  被移除元素的數(shù)量。

  因為不存在的key被視作空表(empty list)，所以當key不存在時，LREM命令總是返回0。

?

LSET

• LSET key index value

將列表key下標為index的元素的值甚至為value。

更多信息請參考LINDEX操作。

當index參數(shù)超出范圍，或對一個空列表(key不存在)進行LSET時，返回一個錯誤。

• 時間復雜度：

• 
  

  對頭元素或尾元素進行LSET操作，復雜度為O(1)。

  其他情況下，為O(N)，N為列表的長度。

• 返回值：

• 操作成功返回ok，否則返回錯誤信息

?

LTRIM

• LTRIM key start stop

對一個列表進行修剪(trim)，就是說，讓列表只保留指定區(qū)間內(nèi)的元素，不在指定區(qū)間之內(nèi)的元素都將被刪除。

舉個例子，執(zhí)行命令LTRIM?list?0?2，表示只保留列表list的前三個元素，其余元素全部刪除。

下標(index)參數(shù)start和stop都以0為底，也就是說，以0表示列表的第一個元素，以1表示列表的第二個元素，以此類推。

你也可以使用負數(shù)下標，以-1表示列表的最后一個元素，-2表示列表的倒數(shù)第二個元素，以此類推。

當key不是列表類型時，返回一個錯誤。

LTRIM命令通常和LPUSH命令或RPUSH命令配合使用，舉個例子：

?

?

這個例子模擬了一個日志程序，每次將最新日志newest_log放到log列表中，并且只保留最新的100項。注意當這樣使用LTRIM命令時，時間復雜度是O(1)，因為平均情況下，每次只有一個元素被移除。

注意LTRIM命令和編程語言區(qū)間函數(shù)的區(qū)別

假如你有一個包含一百個元素的列表list，對該列表執(zhí)行LTRIM?list?0?10，結果是一個包含11個元素的列表，這表明stop下標也在LTRIM命令的取值范圍之內(nèi)(閉區(qū)間)，這和某些語言的區(qū)間函數(shù)可能不一致，比如Ruby的Range.new、Array#slice和Python的range()函數(shù)。

超出范圍的下標

超出范圍的下標值不會引起錯誤。

如果start下標比列表的最大下標end(LLEN?list減去1)還要大，或者start?>?stop，LTRIM返回一個空列表(因為LTRIM已經(jīng)將整個列表清空)。

如果stop下標比end下標還要大，Redis將stop的值設置為end。

• 時間復雜度:

• O(N)，N為被移除的元素的數(shù)量。

• 返回值:

• 
  

  命令執(zhí)行成功時，返回ok。

?

?

LINDEX

• LINDEX key index

返回列表key中，下標為index的元素。

下標(index)參數(shù)start和stop都以0為底，也就是說，以0表示列表的第一個元素，以1表示列表的第二個元素，以此類推。

你也可以使用負數(shù)下標，以-1表示列表的最后一個元素，-2表示列表的倒數(shù)第二個元素，以此類推。

如果key不是列表類型，返回一個錯誤。

• 時間復雜度：

• 
  

  O(N)，N為到達下標index過程中經(jīng)過的元素數(shù)量。

  因此，對列表的頭元素和尾元素執(zhí)行LINDEX命令，復雜度為O(1)。

• 返回值:

• 
  

  列表中下標為index的元素。

  如果index參數(shù)的值不在列表的區(qū)間范圍內(nèi)(out of range)，返回nil。

?

LINSERT

• LINSERT key BEFORE|AFTER pivot value

將值value插入到列表key當中，位于值pivot之前或之后。

當pivot不存在于列表key時，不執(zhí)行任何操作。

當key不存在時，key被視為空列表，不執(zhí)行任何操作。

如果key不是列表類型，返回一個錯誤。

• 時間復雜度:

• O(N)，N為尋找pivot過程中經(jīng)過的元素數(shù)量。

• 返回值:

• 
  

  如果命令執(zhí)行成功，返回插入操作完成之后，列表的長度。

  如果沒有找到pivot，返回-1。

  如果key不存在或為空列表，返回0。

?

?

RPOPLPUSH

• RPOPLPUSH source destination

命令RPOPLPUSH在一個原子時間內(nèi)，執(zhí)行以下兩個動作：

• 將列表source中的最后一個元素(尾元素)彈出，并返回給客戶端。

• 將source彈出的元素插入到列表destination，作為destination列表的的頭元素。

舉個例子，你有兩個列表source和destination，source列表有元素a,?b,?c，destination列表有元素x,?y,?z，執(zhí)行RPOPLPUSH?source?destination之后，source列表包含元素a,?b，destination列表包含元素c,?x,?y,?z?，并且元素c被返回。

如果source不存在，值nil被返回，并且不執(zhí)行其他動作。

如果source和destination相同，則列表中的表尾元素被移動到表頭，并返回該元素，可以把這種特殊情況視作列表的旋轉(rotation)操作。

• 時間復雜度：

• O(1)

• 返回值：

• 被彈出的元素。

?

設計模式： 一個安全的隊列

Redis的列表經(jīng)常被用作隊列(queue)，用于在不同程序之間有序地交換消息(message)。一個程序(稱之為生產(chǎn)者，producer)通過LPUSH命令將消息放入隊列中，而另一個程序(稱之為消費者，consumer)通過RPOP命令取出隊列中等待時間最長的消息。

不幸的是，在這個過程中，一個消費者可能在獲得一個消息之后崩潰，而未執(zhí)行完成的消息也因此丟失。

使用RPOPLPUSH命令可以解決這個問題，因為它在返回一個消息之余，還將該消息添加到另一個列表當中，另外的這個列表可以用作消息的備份表：假如一切正常，當消費者完成該消息的處理之后，可以用LREM命令將該消息從備份表刪除。

另一方面，助手(helper)程序可以通過監(jiān)視備份表，將超過一定處理時限的消息重新放入隊列中去(負責處理該消息的消費者可能已經(jīng)崩潰)，這樣就不會丟失任何消息了。

?

BRPOPLPUSH

• BRPOPLPUSH source destination timeout

BRPOPLPUSH是RPOPLPUSH的阻塞版本，當給定列表source不為空時，BRPOPLPUSH的表現(xiàn)和RPOPLPUSH一樣。

當列表source為空時，BRPOPLPUSH命令將阻塞連接，直到等待超時，或有另一個客戶端對source執(zhí)行LPUSH或RPUSH命令為止。

超時參數(shù)timeout接受一個以秒為單位的數(shù)字作為值。超時參數(shù)設為0表示阻塞時間可以無限期延長(block indefinitely) 。

更多相關信息，請參考RPOPLPUSH命令。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  假如在指定時間內(nèi)沒有任何元素被彈出，則返回一個nil和等待時長。

  反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素的值，第二個元素是等待時長。

?

?

集合(Set)

?附錄，常用集合運算：

? ?A = {'a', 'b', 'c'}
B = {'a', 'e', 'i', 'o', 'u'}

inter(x, y): 交集，在集合x和集合y中都存在的元素。
inter(A, B) = {'a'}

union(x, y): 并集，在集合x中或集合y中的元素，如果一個元素在x和y中都出現(xiàn)，那只記錄一次即可。
union(A,B) = {'a', 'b', 'c', 'e', 'i', 'o', 'u'}

diff(x, y): 差集，在集合x中而不在集合y中的元素。
diff(A,B) = {'b', 'c'}

card(x): 基數(shù)，一個集合中元素的數(shù)量。
card(A) = 3

空集： 基數(shù)為0的集合。

登錄后復制

?

SADD

• SADD key member [member ...]

將一個或多個member元素加入到集合key當中，已經(jīng)存在于集合的member元素將被忽略。

假如key不存在，則創(chuàng)建一個只包含member元素作成員的集合。

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

• 時間復雜度:

• O(N)，N是被添加的元素的數(shù)量。

• 返回值:

• 被添加到集合中的新元素的數(shù)量，不包括被忽略的元素。

注解:在Redis2.4版本以前，SADD只接受單個member值。

?

?

SREM

• SREM key member [member ...]

移除集合key中的一個或多個member元素，不存在的member元素會被忽略。

當key不是集合類型，返回一個錯誤。

• 時間復雜度:

• O(N)，N為給定member元素的數(shù)量。

• 返回值:

• 被成功移除的元素的數(shù)量，不包括被忽略的元素。

注解:在Redis2.4版本以前，SREM只接受單個member值。

?

?

SMEMBERS

• SMEMBERS key

返回集合key中的所有成員。

• 時間復雜度:

• O(N)，N為集合的基數(shù)。

• 返回值:

• 集合中的所有成員。

?

?

SISMEMBER

• SISMEMBER key member

判斷member元素是否是集合key的成員。

• 時間復雜度:

• O(1)

• 返回值:

• 
  

  如果member元素是集合的成員，返回1。

  如果member元素不是集合的成員，或key不存在，返回0。

?

?

SCARD

• SCARD key

返回集合key的基數(shù)(集合中元素的數(shù)量)。

• 時間復雜度:

• O(1)

• 返回值：

• 
  

  集合的基數(shù)。

  當key不存在時，返回0。

?

?

SMOVE

• SMOVE source destination member

將member元素從source集合移動到destination集合。

SMOVE是原子性操作。

如果source集合不存在或不包含指定的member元素，則SMOVE命令不執(zhí)行任何操作，僅返回0。否則，member元素從source集合中被移除，并添加到destination集合中去。

當destination集合已經(jīng)包含member元素時，SMOVE命令只是簡單地將source集合中的member元素刪除。

當source或destination不是集合類型時，返回一個錯誤。

• 時間復雜度:

• O(1)

• 返回值:

• 
  

  如果member元素被成功移除，返回1。

  如果member元素不是source集合的成員，并且沒有任何操作對destination集合執(zhí)行，那么返回0。

?

?

SPOP

• SPOP key

移除并返回集合中的一個隨機元素。

• 時間復雜度:

• O(1)

• 返回值:

• 
  

  被移除的隨機元素。

  當key不存在或key是空集時，返回nil。

?

?

也可以參考:如果只想獲取一個隨機元素，但不想該元素從集合中被移除的話，可以使用SRANDMEMBER命令。

?

SRANDMEMBER

• SRANDMEMBER key

返回集合中的一個隨機元素。

該操作和SPOP相似，但SPOP將隨機元素從集合中移除并返回，而SRANDMEMBER則僅僅返回隨機元素，而不對集合進行任何改動。

• 時間復雜度:

• O(1)

• 返回值:

• 被選中的隨機元素。 當key不存在或key是空集時，返回nil。

?

?

SINTER

• SINTER key [key ...]

返回一個集合的全部成員，該集合是所有給定集合的交集。

不存在的key被視為空集。

當給定集合當中有一個空集時，結果也為空集(根據(jù)集合運算定律)。

• 時間復雜度:

• O(N * M)，N為給定集合當中基數(shù)最小的集合，M為給定集合的個數(shù)。

• 返回值:

• 交集成員的列表。

?

?

SINTERSTORE

• SINTERSTORE destination key [key ...]

此命令等同于SINTER，但它將結果保存到destination集合，而不是簡單地返回結果集。

如果destination集合已經(jīng)存在，則將其覆蓋。

destination可以是key本身。

• 時間復雜度:

• O(N * M)，N為給定集合當中基數(shù)最小的集合，M為給定集合的個數(shù)。

• 返回值:

• 結果集中的成員數(shù)量。

?

?

SUNION

• SUNION key [key ...]

返回一個集合的全部成員，該集合是所有給定集合的并集。

不存在的key被視為空集。

• 時間復雜度:

• O(N)，N是所有給定集合的成員數(shù)量之和。

• 返回值:

• 并集成員的列表。

?

?

SUNIONSTORE

• SUNIONSTORE destination key [key ...]

此命令等同于SUNION，但它將結果保存到destination集合，而不是簡單地返回結果集。

如果destination已經(jīng)存在，則將其覆蓋。

destination可以是key本身。

• 時間復雜度:

• O(N)，N是所有給定集合的成員數(shù)量之和。

• 返回值:

• 結果集中的元素數(shù)量。

?

?

SDIFF

• SDIFF key [key ...]

返回一個集合的全部成員，該集合是所有給定集合的差集?。

不存在的key被視為空集。

• 時間復雜度:

• O(N)，N是所有給定集合的成員數(shù)量之和。

• 返回值:

• 交集成員的列表。

?

?

SDIFFSTORE

• SDIFFSTORE destination key [key ...]

此命令等同于SDIFF，但它將結果保存到destination集合，而不是簡單地返回結果集。

如果destination集合已經(jīng)存在，則將其覆蓋。

destination可以是key本身。

• 時間復雜度:

• O(N)，N是所有給定集合的成員數(shù)量之和。

• 返回值:

• 結果集中的元素數(shù)量。

?

?

有序集(Sorted Set)

ZADD

?

• ZADD key score member [[score member] [score member] ...]

將一個或多個member元素及其score值加入到有序集key當中。

如果某個member已經(jīng)是有序集的成員，那么更新這個member的score值，并通過重新插入這個member元素，來保證該member在正確的位置上。

score值可以是整數(shù)值或雙精度浮點數(shù)。

如果key不存在，則創(chuàng)建一個空的有序集并執(zhí)行ZADD操作。

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

對有序集的更多介紹請參見sorted set。

• 時間復雜度:

• O(M*log(N))，N是有序集的基數(shù)，M為成功添加的新成員的數(shù)量。

• 返回值:

• 被成功添加的新成員的數(shù)量，不包括那些被更新的、已經(jīng)存在的成員。

?

?

注解:在Redis2.4版本以前，ZADD每次只能添加一個元素。

?

?

ZREM

• ZREM key member [member ...]

移除有序集key中的一個或多個成員，不存在的成員將被忽略。

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

• 時間復雜度:

• O(M*log(N))，N為有序集的基數(shù)，M為被成功移除的成員的數(shù)量。

• 返回值:

• 被成功移除的成員的數(shù)量，不包括被忽略的成員。

注解：在Redis2.4版本以前，ZREM每次只能刪除一個元素。

?

?

ZCARD

• ZCARD key

返回有序集key的基數(shù)。

• 時間復雜度:

• O(1)

• 返回值:

• 
  

  當key存在且是有序集類型時，返回有序集的基數(shù)。

  當key不存在時，返回0。

?

ZCOUNT

• ZCOUNT key min max

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

關于參數(shù)min和max的詳細使用方法，請參考ZRANGEBYSCORE命令。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，M為值在min和max之間的元素的數(shù)量。

• 返回值:

• score值在min和max之間的成員的數(shù)量。

?

ZSCORE

• ZSCORE key member

返回有序集key中，成員member的score值。

如果member元素不是有序集key的成員，或key不存在，返回nil。

• 時間復雜度:

• O(1)

• 返回值:

• member成員的score值，以字符串形式表示。

?

ZINCRBY

• ZINCRBY key increment member

為有序集key的成員member的score值加上增量increment。

你也可以通過傳遞一個負數(shù)值increment，讓score減去相應的值，比如ZINCRBY?key?-5?member，就是讓member的score值減去5。

當key不存在，或member不是key的成員時，ZINCRBY?key?increment?member等同于ZADD?key?increment?member。

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

score值可以是整數(shù)值或雙精度浮點數(shù)。

• 時間復雜度:

• O(log(N))

• 返回值:

• member成員的新score值，以字符串形式表示。

?

?

ZRANGE

• ZRANGE key start stop [WITHSCORES]

返回有序集key中，指定區(qū)間內(nèi)的成員。

其中成員的位置按score值遞增(從小到大)來排序。

具有相同score值的成員按字典序(lexicographical order)來排列。

如果你需要成員按score值遞減(從大到小)來排列，請使用ZREVRANGE命令。

下標參數(shù)start和stop都以0為底，也就是說，以0表示有序集第一個成員，以1表示有序集第二個成員，以此類推。

你也可以使用負數(shù)下標，以-1表示最后一個成員，-2表示倒數(shù)第二個成員，以此類推。

超出范圍的下標并不會引起錯誤。

比如說，當start的值比有序集的最大下標還要大，或是start?>?stop時，ZRANGE命令只是簡單地返回一個空列表。

另一方面，假如stop參數(shù)的值比有序集的最大下標還要大，那么Redis將stop當作最大下標來處理。

可以通過使用WITHSCORES選項，來讓成員和它的score值一并返回，返回列表以value1,score1,?...,?valueN,scoreN的格式表示。

客戶端庫可能會返回一些更復雜的數(shù)據(jù)類型，比如數(shù)組、元組等。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，而M為結果集的基數(shù)。

• 返回值:

• 指定區(qū)間內(nèi)，帶有score值(可選)的有序集成員的列表。

?

ZREVRANGE

• ZREVRANGE key start stop [WITHSCORES]

返回有序集key中，指定區(qū)間內(nèi)的成員。

其中成員的位置按score值遞減(從大到小)來排列。

具有相同score值的成員按字典序的反序(reverse lexicographical order)排列。

除了成員按score值遞減的次序排列這一點外，ZREVRANGE命令的其他方面和ZRANGE命令一樣。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，而M為結果集的基數(shù)。

• 返回值:

• 指定區(qū)間內(nèi)，帶有score值(可選)的有序集成員的列表。

?

?

ZRANGEBYSCORE

• ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

返回有序集key中，所有score值介于min和max之間(包括等于min或max)的成員。有序集成員按score值遞增(從小到大)次序排列。

具有相同score值的成員按字典序(lexicographical order)來排列(該屬性是有序集提供的，不需要額外的計算)。

可選的LIMIT參數(shù)指定返回結果的數(shù)量及區(qū)間(就像SQL中的SELECT?LIMIT?offset,?count)，注意當offset很大時，定位offset的操作可能需要遍歷整個有序集，此過程最壞復雜度為O(N)時間。

可選的WITHSCORES參數(shù)決定結果集是單單返回有序集的成員，還是將有序集成員及其score值一起返回。

該選項自Redis 2.0版本起可用。

區(qū)間及無限

min和max可以是-inf和+inf，這樣一來，你就可以在不知道有序集的最低和最高score值的情況下，使用ZRANGEBYSCORE這類命令。

默認情況下，區(qū)間的取值使用閉區(qū)間(小于等于或大于等于)，你也可以通過給參數(shù)前增加(符號來使用可選的開區(qū)間(小于或大于)。

舉個例子：

?

返回所有符合條件1??score??5的成員；

?

返回所有符合條件5??score??10的成員。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，M為被結果集的基數(shù)。

• 返回值:

• 指定區(qū)間內(nèi)，帶有score值(可選)的有序集成員的列表。

?

?

ZREVRANGEBYSCORE

• ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

返回有序集key中，score值介于max和min之間(默認包括等于max或min)的所有的成員。有序集成員按score值遞減(從大到小)的次序排列。

具有相同score值的成員按字典序的反序(reverse lexicographical order)排列。

除了成員按score值遞減的次序排列這一點外，ZREVRANGEBYSCORE命令的其他方面和ZRANGEBYSCORE命令一樣。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，M為結果集的基數(shù)。

• 返回值:

• 指定區(qū)間內(nèi)，帶有score值(可選)的有序集成員的列表。

?

?

ZRANK

• ZRANK key member

返回有序集key中成員member的排名。其中有序集成員按score值遞增(從小到大)順序排列。

排名以0為底，也就是說，score值最小的成員排名為0。

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

• 時間復雜度:

• O(log(N))

• 返回值:

• 
  

  如果member是有序集key的成員，返回member的排名。

  如果member不是有序集key的成員，返回nil。

?

ZREVRANK

• ZREVRANK key member

返回有序集key中成員member的排名。其中有序集成員按score值遞減(從大到小)排序。

排名以0為底，也就是說，score值最大的成員排名為0。

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

• 時間復雜度:

• O(log(N))

• 返回值:

• 
  

  如果member是有序集key的成員，返回member的排名。

  如果member不是有序集key的成員，返回nil。

?

?

ZREMRANGEBYRANK

• ZREMRANGEBYRANK key start stop

移除有序集key中，指定排名(rank)區(qū)間內(nèi)的所有成員。

區(qū)間分別以下標參數(shù)start和stop指出，包含start和stop在內(nèi)。

下標參數(shù)start和stop都以0為底，也就是說，以0表示有序集第一個成員，以1表示有序集第二個成員，以此類推。

你也可以使用負數(shù)下標，以-1表示最后一個成員，-2表示倒數(shù)第二個成員，以此類推。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，而M為被移除成員的數(shù)量。

• 返回值:

• 被移除成員的數(shù)量。

?

?

ZREMRANGEBYSCORE

• ZREMRANGEBYSCORE key min max

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

自版本2.1.6開始，score值等于min或max的成員也可以不包括在內(nèi)，詳情請參見ZRANGEBYSCORE命令。

• 時間復雜度:

• O(log(N)+M)，N為有序集的基數(shù)，而M為被移除成員的數(shù)量。

• 返回值:

• 被移除成員的數(shù)量。

?

?

ZINTERSTORE

• ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

計算給定的一個或多個有序集的交集，其中給定key的數(shù)量必須以numkeys參數(shù)指定，并將該交集(結果集)儲存到destination。

默認情況下，結果集中某個成員的score值是所有給定集下該成員score值之和。

關于WEIGHTS和AGGREGATE選項的描述，參見ZUNIONSTORE命令。

• 時間復雜度:

• O(N*K)+O(M*log(M))，N為給定key中基數(shù)最小的有序集，K為給定有序集的數(shù)量，M為結果集的基數(shù)。

• 返回值:

• 保存到destination的結果集的基數(shù)。

?

?

ZUNIONSTORE

• ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

計算給定的一個或多個有序集的并集，其中給定key的數(shù)量必須以numkeys參數(shù)指定，并將該并集(結果集)儲存到destination。

默認情況下，結果集中某個成員的score值是所有給定集下該成員score值之和。

WEIGHTS

使用WEIGHTS選項，你可以為每個給定有序集分別指定一個乘法因子(multiplication factor)，每個給定有序集的所有成員的score值在傳遞給聚合函數(shù)(aggregation function)之前都要先乘以該有序集的因子。

如果沒有指定WEIGHTS選項，乘法因子默認設置為1。

AGGREGATE

使用AGGREGATE選項，你可以指定并集的結果集的聚合方式。

默認使用的參數(shù)SUM，可以將所有集合中某個成員的score值之和作為結果集中該成員的score值；使用參數(shù)MIN，可以將所有集合中某個成員的最小score值作為結果集中該成員的score值；而參數(shù)MAX則是將所有集合中某個成員的最大score值作為結果集中該成員的score值。

• 時間復雜度:

• O(N)+O(M log(M))，N為給定有序集基數(shù)的總和，M為結果集的基數(shù)。

• 返回值:

• 保存到destination的結果集的基數(shù)。

?

?

發(fā)布/訂閱(Pub/Sub)

PUBLISH

• PUBLISH channel message

將信息?message?發(fā)送到指定的頻道?channel?。

• 時間復雜度：

• O(N+M)，其中?N?是頻道?channel?的訂閱者數(shù)量，而?M?則是使用模式訂閱(subscribed patterns)的客戶端的數(shù)量。

• 返回值：

• 接收到信息?message?的訂閱者數(shù)量。

?

?

SUBSCRIBE

• SUBSCRIBE channel [channel ...]

訂閱給定頻道的信息。

• 時間復雜度：

• O(N)，其中?N?是訂閱的頻道的數(shù)量。

• 返回值：

• 接收到的信息(請參見下面的代碼說明)。

?

?

PSUBSCRIBE

• PSUBSCRIBE pattern [pattern ...]

訂閱符合給定模式的頻道。

每個模式以?*?作為匹配符，比如?huangz*?匹配所有以?huangz?開頭的頻道(?huangzmsg?、?huangz-blog?、?huangz.tweets?等等)，?news.*?匹配所有以?news.?開頭的頻道(news.it?、?news.global.today?等等)，諸如此類。

• 時間復雜度：

• O(N)，?N?是訂閱的模式的數(shù)量。

• 返回值：

• 接收到的信息(請參見下面的代碼說明)。

?

?

UNSUBSCRIBE

警告:此命令在新版 Redis 中似乎已經(jīng)被廢棄？

PUNSUBSCRIBE

警告:此命令在新版 Redis 中似乎已經(jīng)被廢棄？

?

事務(Transaction)

WATCH

• ATCH key [key ...]

監(jiān)視一個(或多個) key ，如果在事務執(zhí)行之前這個(或這些) key 被其他命令所改動，那么事務將被打斷。

• 時間復雜度：

• O(1)。

• 返回值：

• 總是返回?OK?。

?

UNWATCH

UNWATCH

取消?WATCH?命令對所有 key 的監(jiān)視。

如果在執(zhí)行?WATCH?命令之后，?EXEC?命令或?DISCARD?命令先被執(zhí)行了的話，那么就不需要再執(zhí)行?UNWATCH?了。

因為?EXEC?命令會執(zhí)行事務，因此?WATCH?命令的效果已經(jīng)產(chǎn)生了；而?DISCARD?命令在取消事務的同時也會取消所有對 key 的監(jiān)視，因此這兩個命令執(zhí)行之后，就沒有必要執(zhí)行?UNWATCH?了。

• 時間復雜度：

• O(1)

• 返回值：

• 總是?OK?。

?

MULTI

MULTI

標記一個事務塊的開始。

事務塊內(nèi)的多條命令會按照先后順序被放進一個隊列當中，最后由?EXEC?命令在一個原子時間內(nèi)執(zhí)行。

• 時間復雜度：

• O(1)。

• 返回值：

• 總是返回?OK?。

?

?

EXEC

EXEC

執(zhí)行所有事務塊內(nèi)的命令。

假如某個(或某些) key 正處于?WATCH?命令的監(jiān)視之下，且事務塊中有和這個(或這些) key 相關的命令，那么?EXEC?命令只在這個(或這些) key 沒有被其他命令所改動的情況下執(zhí)行并生效，否則該事務被打斷(abort)。

• 時間復雜度：

• 事務塊內(nèi)所有命令的時間復雜度的總和。

• 返回值：

• 
  

  事務塊內(nèi)所有命令的返回值，按命令執(zhí)行的先后順序排列。

  當操作被打斷時，返回空值?nil?。

?

?

DISCARD

DISCARD

取消事務，放棄執(zhí)行事務塊內(nèi)的所有命令。

如果正在使用?WATCH?命令監(jiān)視某個(或某些) key ，那么取消所有監(jiān)視，等同于執(zhí)行命令?UNWATCH?。

• 時間復雜度：

• O(1)。

• 返回值：

• 總是返回?OK?。

?

?

連接(Connection)

AUTH

• AUTH password

通過設置配置文件中?requirepass?項的值(使用命令?CONFIG?SET?requirepass?password?)，可以使用密碼來保護 Redis 服務器。

如果開啟了密碼保護的話，在每次連接 Redis 服務器之后，就要使用?AUTH?命令解鎖，解鎖之后才能使用其他 Redis 命令。

如果?AUTH?命令給定的密碼?password?和配置文件中的密碼相符的話，服務器會返回?OK?并開始接受命令輸入。

反之，如果密碼不匹配的話，服務器將返回一個錯誤，并要求客戶端需重新輸入密碼。

?

警告:因為 Redis 高性能的特點，在很短時間內(nèi)嘗試猜測非常多個密碼是有可能的，因此請確保使用的密碼足夠復雜和足夠長，以免遭受密碼猜測攻擊。

• 時間復雜度：

• O(1)

• 返回值：

• 密碼匹配時返回?OK?，否則返回一個錯誤。

?

PING

PING

客戶端向服務器發(fā)送一個?PING?，然后服務器返回客戶端一個?PONG?。

通常用于測試與服務器的連接是否仍然生效，或者用于測量延遲值。

• 時間復雜度：

• O(1)

• 返回值：

• PONG

?

?

SELECT

• SELECT index

切換到指定的數(shù)據(jù)庫，數(shù)據(jù)庫索引號用數(shù)字值指定，以?0?作為起始索引值。

新的鏈接總是使用?0?號數(shù)據(jù)庫。

• 時間復雜度：

• O(1)

• 返回值：

• OK

?

ECHO

• ECHO message

打印一個特定的信息?message?，測試時使用。

• 時間復雜度：

• O(1)

• 返回值：

• message?自身。

?

?

QUIT

QUIT

請求服務器關閉與當前客戶端的連接。

一旦所有等待中的回復(如果有的話)順利寫入到客戶端，連接就會被關閉。

• 時間復雜度：

• O(1)

• 返回值：

• 總是返回?OK?(但是不會被打印顯示，因為當時 Redis-cli 已經(jīng)退出)。

?

?

服務器(Server)

BGREWRITEAOF

BGREWRITEAOF

異步(Asynchronously)重寫 AOF 文件以反應當前數(shù)據(jù)庫的狀態(tài)。

即使?BGREWRITEAOF?命令執(zhí)行失敗，舊 AOF 文件中的數(shù)據(jù)也不會因此丟失或改變。

• 時間復雜度：

• O(N)，?N?為要追加到 AOF 文件中的數(shù)據(jù)數(shù)量。

• 返回值：

• 反饋信息。

?

BGSAVE

在后臺異步保存當前數(shù)據(jù)庫的數(shù)據(jù)到磁盤。

BGSAVE?命令執(zhí)行之后立即返回?OK?，然后 Redis fork出一個新子進程，原來的 Redis 進程(父進程)繼續(xù)處理客戶端請求，而子進程則負責將數(shù)據(jù)保存到磁盤，然后退出。

客戶端可以通過?LASTSAVE?命令查看相關信息，判斷?BGSAVE?命令是否執(zhí)行成功。

• 時間復雜度：

• O(N)，?N?為要保存到數(shù)據(jù)庫中的 key 的數(shù)量。

• 返回值：

• 反饋信息。

?

SAVE

SAVE

同步保存當前數(shù)據(jù)庫的數(shù)據(jù)到磁盤。

• 時間復雜度：

• O(N)，?N?為要保存到數(shù)據(jù)庫中的 key 的數(shù)量。

• 返回值：

• 總是返回?OK?。

?

?

LASTSAVE

LASTSAVE

返回最近一次 Redis 成功執(zhí)行保存操作的時間點(?SAVE?、?BGSAVE?等)，以 UNIX 時間戳格式表示。

• 時間復雜度：

• O(1)

• 返回值：

• 一個 UNIX 時間戳。

?

?

DBSIZE

DBSIZE

返回當前數(shù)據(jù)庫的 key 的數(shù)量。

• 時間復雜度：

• O(1)

• 返回值：

• 當前數(shù)據(jù)庫的 key 的數(shù)量。

?

?

SLAVEOF

• SLAVEOF host port

SLAVEOF?命令用于在 Redis 運行時動態(tài)地修改復制(replication)功能的行為。

通過執(zhí)行?SLAVEOF?host?port?命令，可以將當前服務器轉變?yōu)橹付ǚ掌鞯膹膶俜掌?slave server)。

如果當前服務器已經(jīng)是某個主服務器(master server)的從屬服務器，那么執(zhí)行?SLAVEOF?host?port?將使當前服務器停止對舊主服務器的同步，丟棄舊數(shù)據(jù)集，轉而開始對新主服務器進行同步。

另外，對一個從屬服務器執(zhí)行命令?SLAVEOF?NO?ONE?將使得這個從屬服務器關閉復制功能，并從從屬服務器轉變回主服務器，原來同步所得的數(shù)據(jù)集不會被丟棄。

利用“?SLAVEOF?NO?ONE?不會丟棄同步所得數(shù)據(jù)集”這個特性，可以在主服務器失敗的時候，將從屬服務器用作新的主服務器，從而實現(xiàn)無間斷運行。

• 時間復雜度：

• 
  

  SLAVEOF?host?port?，O(N)，?N?為要同步的數(shù)據(jù)數(shù)量。

  SLAVEOF?NO?ONE?， O(1) 。

• 返回值：

• 總是返回?OK?。

?

?

FLUSHALL

FLUSHALL

清空整個 Redis 服務器的數(shù)據(jù)(刪除所有數(shù)據(jù)庫的所有 key)。

此命令從不失敗。

• 時間復雜度：

• 尚未明確

• 返回值：

• 總是返回?OK?。

?

?

FLUSHDB

FLUSHDB

清空當前數(shù)據(jù)庫中的所有 key 。

此命令從不失敗。

• 時間復雜度：

• O(1)

• 返回值：

• 總是返回?OK?。

?

?

SHUTDOWN

SHUTDOWN

SHUTDOWN?命令執(zhí)行以下操作：

• 停止所有客戶端

• 如果有最少一個保存點在等待，執(zhí)行?SAVE?命令

• 如果 AOF 選項被打開，更新 AOF 文件

• 服務器關閉

如果持久化被打開的話，?SHUTDOWN?命令會保證服務器正常關閉而不丟失任何數(shù)據(jù)。

假如只是單純地執(zhí)行?SAVE?命令，然后再執(zhí)行?QUIT?命令，則沒有這一保證 —— 因為在執(zhí)行?SAVE?之后、執(zhí)行?QUIT?之前的這段時間中間，其他客戶端可能正在和服務器進行通訊，這時如果執(zhí)行?QUIT?就會造成數(shù)據(jù)丟失。

• 時間復雜度：

• 不明確

• 返回值：

• 
  

  執(zhí)行失敗時返回錯誤。

  執(zhí)行成功時不返回任何信息，服務器和客戶端的連接斷開，客戶端自動退出。

?

?

SLOWLOG

• SLOWLOG subcommand [argument]

什么是 SLOWLOG

Slow log 是 Redis 用來記錄查詢執(zhí)行時間的日志系統(tǒng)。

查詢執(zhí)行時間指的是不包括像客戶端響應(talking)、發(fā)送回復等 IO 操作，而單單是執(zhí)行一個查詢命令所耗費的時間。

另外，slow log 保存在內(nèi)存里面，讀寫速度非?？欤虼四憧梢苑判牡厥褂盟?，不必擔心因為開啟 slow log 而損害 Redis 的速度。

設置 SLOWLOG

Slow log 的行為由兩個配置參數(shù)(configuration parameter)指定，可以通過改寫 redis.conf 文件或者用?CONFIG?GET?和?CONFIG?SET?命令對它們動態(tài)地進行修改。

第一個選項是?slowlog-log-slower-then?，它決定要對執(zhí)行時間大于多少微秒(microsecond，1秒 = 1,000,000 微秒)的查詢進行記錄。

比如執(zhí)行以下命令將讓 slow log 記錄所有查詢時間大于等于 100 微秒的查詢：

CONFIG?SET?slowlog-log-slower-then?100?，

而以下命令記錄所有查詢時間大于 1000 微秒的查詢：

CONFIG?SET?slowlog-log-slower-then?1000?。

另一個選項是?slowlog-max-len?，它決定 slow log?最多能保存多少條日志， slow log 本身是一個 LIFO 隊列，當隊列大小超過?slowlog-max-len?時，最舊的一條日志將被刪除，而最新的一條日志加入到 slow log ，以此類推。

以下命令讓 slow log 最多保存 1000 條日志：

CONFIG?SET?slowlog-max-len?1000?。

使用?CONFIG?GET?命令可以查詢兩個選項的當前值：

?

?

查看 slow log

要查看 slow log ，可以使用?SLOWLOG?GET?或者?SLOWLOG?GET?number?命令，前者打印所有 slow log ，最大長度取決于?slowlog-max-len?選項的值，而?SLOWLOG?GET?number?則只打印指定數(shù)量的日志。

最新的日志會最先被打?。?/p>

?

?

日志的唯一 id 只有在 Redis 服務器重啟的時候才會重置，這樣可以避免對日志的重復處理(比如你可能會想在每次發(fā)現(xiàn)新的慢查詢時發(fā)郵件通知你)。

查看當前日志的數(shù)量

使用命令?SLOWLOG?LEN?可以查看當前日志的數(shù)量。

請注意這個值和?slower-max-len?的區(qū)別，它們一個是當前日志的數(shù)量，一個是允許記錄的最大日志的數(shù)量。

?

清空日志

使用命令?SLOWLOG?RESET?可以清空 slow log 。

?

?

時間復雜度：O(1)

返回值：取決于不同命令，返回不同的值。

?

INFO

INFO

返回關于 Redis 服務器的各種信息和統(tǒng)計值。

• 時間復雜度：

• O(1)

• 返回值：

• 具體請參見下面的測試代碼。

?

?

CONFIG GET

• CONFIG GET parameter

CONFIG GET?命令用于取得運行中的 Redis 服務器的配置參數(shù)(configuration parameters)，不過并非所有配置參數(shù)都被?CONFIG?GET?命令所支持。

CONFIG GET?接受單個參數(shù)?parameter?作為搜索關鍵字，查找所有匹配的配置參數(shù)，其中參數(shù)和值以“鍵-值對”(key-value pairs)的方式排列。

比如執(zhí)行?CONFIG?GET?s*?命令，服務器就會返回所有以?s?開頭的配置參數(shù)及參數(shù)的值：

?

?

如果你只是尋找特定的某個參數(shù)的話，你當然也可以直接指定參數(shù)的名字：

?

使用命令?CONFIG?GET?*?，可以列出?CONFIG?GET?命令支持的所有參數(shù)：

?

所有被?CONFIG?SET?所支持的配置參數(shù)都可以在配置文件 redis.conf 中找到，不過?CONFIG?GET?和?CONFIG?SET?使用的格式和 redis.conf 文件所使用的格式有以下兩點不同：

• 
  

  10kb?、?2gb?這些在配置文件中所使用的儲存單位縮寫，不可以用在?CONFIG?命令中，?CONFIG?SET?的值只能通過數(shù)字值顯式地設定。

  ?

  像?CONFIG?SET?xxx?1k?這樣的命令是錯誤的，正確的格式是?CONFIG?SET?xxx?1000?。

• 
  

  save?選項在 redis.conf 中是用多行文字儲存的，但在?CONFIG?GET?命令中，它只打印一行文字。

  ?

  以下是?save?選項在 redis.conf 文件中的表示：

  ?

  save?900?1

  save?300?10

  save?60?10000

  ?

  但是?CONFIG?GET?命令的輸出只有一行：

  ?

  redis>?CONFIG?GET?save

  1)?"save"

  2)?"900?1?300?10?60?10000"

  ?

  上面?save?參數(shù)的三個值表示：在 900 秒內(nèi)最少有 1 個 key 被改動，或者 300 秒內(nèi)最少有 10 個 key 被改動，又或者 60 秒內(nèi)最少有 1000 個 key 被改動，以上三個條件隨便滿足一個，就觸發(fā)一次保存操作。

• 時間復雜度：

• 不明確

• 返回值：

• 給定配置參數(shù)的值。

?

CONFIG SET

• CONFIG SET parameter value

CONFIG SET?命令可以動態(tài)地調(diào)整 Redis 服務器的配置(configuration)而無須重啟。

你可以使用它修改配置參數(shù)，或者改變 Redis 的持久化(Persistence)方式。

CONFIG SET?可以修改的配置參數(shù)可以使用命令?CONFIG?GET?*?來列出，所有被?CONFIG SET?修改的配置參數(shù)都會立即生效。

關于?CONFIG SET?命令的更多消息，請參見命令?CONFIG GET?的說明。

關于如何使用?CONFIG SET?命令修改 Redis 持久化方式，請參見?Redis Persistence?。

• 時間復雜度：

• 不明確

• 返回值：

• 當設置成功時返回?OK?，否則返回一個錯誤。

?

CONFIG RESETSTAT

• CONFIG RESETSTAT

重置?INFO?命令中的某些統(tǒng)計數(shù)據(jù)，包括：

• Keyspace hits (鍵空間命中次數(shù))

• Keyspace misses (鍵空間不命中次數(shù))

• Number of commands processed (執(zhí)行命令的次數(shù))

• Number of connections received (連接服務器的次數(shù))

• Number of expired keys (過期key的數(shù)量)

• 時間復雜度：

• O(1)

• 返回值：

• 總是返回?OK?。

?

DEBUG OBJECT

• DEBUG OBJECT key

返回給定?key?的調(diào)試信息。

• 時間復雜度：

• O(1)

• 返回值：

• 
  

  當?key?存在時，返回有關信息。

  當?key?不存在時，返回一個錯誤。

?

DEBUG SEGFAULT

• DEBUG SEGFAULT

令 Redis 服務器崩潰，調(diào)試用。

• 時間復雜度：

• 不明確

• 返回值：

• 無

?

MONITOR

MONITOR

實時打印出 Redis 服務器接收到的命令，調(diào)試用。

• 時間復雜度：

• 不明確

• 返回值：

• 總是返回?OK?。

?

SYNC

YNC

用于復制功能(replication)的內(nèi)部命令。

• 時間復雜度：

• 不明確

• 返回值：

• 不明確