PHP操做redis詳細講解（轉）

時間 2019-11-11

標籤 php redis 詳細講解欄目 PHP 简体版

原文原文鏈接

PHP中redis的使用

redis是一個key-value存儲系統。和Memcached相似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)和zset(有序集合)。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操做，並且這些操做都是原子性的。在此基礎上，redis支持各類不一樣方式的排序。與memcached同樣，爲了保證效率，數據都是緩存在內存中。區別的是redis會週期性的把更新的數據寫入磁盤或者把修改操做寫入追加的記錄文件，而且在此基礎上實現了master-slave(主從)同步。
Redis 是一個高性能的key-value數據庫。redis的出現，很大程度補償了memcached這類keyvalue存儲的不足，在部分場合能夠對關係數據庫起到很好的補充做用。它提供了Python，Ruby，Erlang，PHP客戶端，使用很方便。php

若想在PHP中使用redis，首先要先安裝redis。而後在PHP中配置擴展。html

1.安裝redis。前端

首先下載好redis安裝文件，解壓到D盤或其餘盤。python

而後經過Dos命令行進行安裝。git

把這個文件夾複製到其它地方，好比D：\redis 目錄下。

打開一個cmd窗口使用cd命令切換目錄到D:\redis 運行 redis-server.exe redis.conf

若是想方便的話，能夠把redis的路徑加到系統的環境變量裏，這樣就免得再輸路徑了，後面的那個redis.conf能夠省略，若是省略，會啓用默認的。輸入以後，會顯示以下界面：

這時候另啓一個cmd窗口，原來的不要關閉，否則就沒法訪問服務端了

切換到redis目錄下運行 redis-cli.exe -h 127.0.0.1 -p 6379 出現下圖：

這時候，就已經完成配置了。github

完成了配置以後，要在PHP中添加redis的擴展，以後才能夠用PHP靈活的使用它。web

在windows下安裝php的redis擴展很是簡單，下載一個.dll擴展包放到php的ext目錄下，在php.ini裏邊添加一行配置就能夠了。redis

php代碼測試算法

sql

輸出hello world!

phpredis是redis的php的一個擴展，效率是至關高有鏈表排序功能，對建立內存級的模塊業務關係

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

下載地址以下：

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

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

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

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

setOption 設置redis模式

getOption 查看redis設置的模式

ping 查看鏈接狀態

KEY相關操做

DEL

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

若是key不存在，則忽略該命令。

時間複雜度：: O(N)， N爲要移除的 key的數量。

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

移除單個列表、集合、有序集合或哈希表類型的 key，時間複雜度爲O(M)， M爲以上數據結構內的元素數量。
返回值：: 被移除 key的數量。

//DEL
# 狀況1： 刪除單個key
$redis->set('myname','ikodota');
echo $redis->get('myname').'<br>'; # 返回:ikodota

$redis->del('myname');# 返回 TRUE(1)
var_dump($redis->get('myname')); # 返回 bool(false)

# 狀況2： 刪除一個不存在的key
if(!$redis->exists('fake_key')) # 不存在
var_dump($redis->del('fake_key')); # 返回 int(0)

# 狀況3： 同時刪除多個key
$array_mset=array('first_key'=>'first_val',
          'second_key'=>'second_val',
          'third_key'=>'third_val');
$redis->mset($array_mset); #用MSET一次儲存多個值
$array_mget=array('first_key','second_key','third_key');
var_dump($redis->mget($array_mget)); #一次返回多個值 //array(3) { [0]=> string(9) "first_val" [1]=> string(10) "second_val" [2]=> string(9) "third_val" }

$redis->del($array_mget); #同時刪除多個key
var_dump($redis->mget($array_mget)); #返回 array(3) { [0]=> bool(false) [1]=> bool(false) [2]=> bool(false) }

KEYS
KEYS pattern
查找符合給定模式的 key。

 
     KEYS *命中數據庫中全部 
     key。 
    
 
     KEYS h?llo命中 
     hello，  
     hallo and hxllo等。 
    
 
     KEYS h*llo命中 
     hllo和 
     heeeeello等。 
    
 
     KEYS h[ae]llo命中 
     hello和 
     hallo，但不命中 
     hillo。 
    

特殊符號用"\"隔開

時間複雜度：: O(N)， N爲數據庫中 key的數量。
返回值：: 符合給定模式的 key列表。

警告 :KEYS的速度很是快，但在一個大的數據庫中使用它仍然可能形成性能問題，若是你須要從一個數據集中查找特定的key，你最好仍是用集合(Set)。

//KEYS
#$redis->FLUSHALL();
$array_mset_keys=array('one'=>'1',
          'two'=>'2',
          'three '=>'3',
          'four'=>'4');
$redis->mset($array_mset_keys); #用MSET一次儲存多個值
var_dump($redis->keys('*o*')); //array(3) { [0]=> string(4) "four" [1]=> string(3) "two" [2]=> string(3) "one" }
var_dump($redis->keys('t??')); //array(1) { [0]=> string(3) "two" }
var_dump($redis->keys('t[w]*')); //array(1) { [0]=> string(3) "two" }
print_r($redis->keys('*')); //Array ( [0] => four [1] => three [2] => two [3] => one )

RANDOMKEY

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

時間複雜度：: O(1)
返回值：: 當數據庫不爲空時，返回一個 key。

當數據庫爲空時，返回 nil。

//RANDOMKEY
$redis->FLUSHALL();
# 狀況1：數據庫不爲空
$array_mset_randomkey=array('fruit'=>'apple',
                'drink'=>'beer',
                'food'=>'cookis');
$redis->mset($array_mset_randomkey);
echo $redis->randomkey(); 
print_r($redis->keys('*')); # 查看數據庫內全部key，證實RANDOMKEY並不刪除key//Array ( [0] => food [1] => drink [2] => fruit )

# 狀況2：數據庫爲空
$redis->flushdb();  # 刪除當前數據庫全部key
var_dump($redis-> randomkey()); //bool(false)

TTL TTL key

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

時間複雜度：: O(1)
返回值：: key的剩餘生存時間(以秒爲單位)。

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

//TTL
# 狀況1：帶TTL的key
$redis->flushdb();
//$redis->set('name','ikodota'); # 設置一個key
$redis->expire('name',30);  # 設置生存時間爲30秒 //return (integer) 1
echo $redis->get('name'); //return ikodota
echo $redis->ttl('name'); //(integer) 25

//echo $redis->ttl('name');  # 30秒過去，name過時 //(integer) -1
var_dump($redis->get('name')); # 過時的key將被刪除 //return bool(false);

# 狀況2：不帶TTL的key
$redis->set('site','wikipedia.org');//OK
var_dump($redis->ttl('site'));//int(-1)

# 狀況3：不存在的key
$redis->EXISTS('not_exists_key');//int(0)
var_dump($redis->TTL('not_exists_key'));//int(-1)

EXISTS
EXISTS key

檢查給定key是否存在。

時間複雜度：: O(1)
返回值：: 若 key存在，返回 1，不然返回 0。

//EXISTS
echo '<br>EXISTS<br>';
$redis->set('db',"redis"); //bool(true) 
var_dump($redis->exists('db'));  # key存在 //bool(true) 
$redis->del('db');   # 刪除key //int(1)
var_dump($redis->exists('db'))  # key不存在 //bool(false)

MOVE
MOVE key db

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

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

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

時間複雜度：: O(1)
返回值：: 移動成功返回 1，失敗則返回 0。

//MOVE
echo '<br><br>MOVE<br>';
# 狀況1： key存在於當前數據庫
$redis->SELECT(0);  # redis默認使用數據庫0，爲了清晰起見，這裏再顯式指定一次。//OK
$redis->SET('song',"secret base - Zone"); //OK
var_dump ($redis->MOVE('song',1));  # 將song移動到數據庫1 //bool(true)

# 狀況2：當key不存在的時候
$redis->SELECT(1);
var_dump ($redis->EXISTS('fake_key'));//bool(false);
var_dump($redis->MOVE('fake_key', 0));  # 試圖從數據庫1移動一個不存在的key到數據庫0，失敗) //bool(false)

$redis->SELECT(0); # 使用數據庫0
var_dump($redis->EXISTS('fake_key'));  # 證明fake_key不存在 //bool(false)

# 狀況3：當源數據庫和目標數據庫有相同的key時

$redis->SELECT(0);  # 使用數據庫0
$redis->SET('favorite_fruit',"banana");

$redis->SELECT(1);  # 使用數據庫1
$redis->SET('favorite_fruit',"apple");

$redis->SELECT(0);  # 使用數據庫0，並試圖將favorite_fruit移動到數據庫1
var_dump($redis->MOVE('favorite_fruit',1));  # 由於兩個數據庫有相同的key，MOVE失敗 //return bool(false)
echo $redis->GET('favorite_fruit');  # 數據庫0的favorite_fruit沒變 //return banana

$redis->SELECT(1);
echo $redis->GET('favorite_fruit');   # 數據庫1的favorite_fruit也是 //return apple

RENAME

RENAME key newkey

將key更名爲newkey。

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

當newkey已經存在時，RENAME命令將覆蓋舊值。

時間複雜度：: O(1)
返回值：: 更名成功時提示 OK，失敗時候返回一個錯誤。

//RENAME
echo '<br><br>RENAME<br>';
# 狀況1：key存在且newkey不存在
$redis->SET('message',"hello world");
var_dump($redis->RENAME('message','greeting'));  //bool(true)
var_dump($redis->EXISTS('message'));  # message不復存在 //bool(false)
var_dump($redis->EXISTS('greeting'));   # greeting取而代之 //bool(true)

# 狀況2：當key不存在時，返回錯誤 ,php返回false;
var_dump($redis->RENAME('fake_key','never_exists'));  //bool(false)

# 狀況3：newkey已存在時，RENAME會覆蓋舊newkey
$redis->SET('pc',"lenovo");
$redis->SET('personal_computer',"dell"); 
var_dump($redis->RENAME('pc','personal_computer')); //bool(true)
var_dump($redis->GET('pc')); //(nil)   bool(false)
var_dump($redis->GET('personal_computer'));  # dell「沒有」了 //string(6) "lenovo"

RENAMENX

RENAMENX key newkey

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

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

時間複雜度：: O(1)
返回值：: 修改爲功時，返回 1。

若是 newkey已經存在，返回 0。

//RENAMENX
echo '<br><br>RENAMENX<br>';

# 狀況1：newkey不存在，成功
$redis->SET('player',"MPlyaer");
$redis->EXISTS('best_player'); //int(0)
var_dump($redis->RENAMENX('player','best_player')); // bool(true) 

# 狀況2：newkey存在時，失敗
$redis->SET('animal',"bear");
$redis->SET('favorite_animal', "butterfly");

var_dump($redis->RENAMENX('animal', 'favorite_animal'));// bool(false)

var_dump($redis->get('animal')); //string(4) "bear"
var_dump($redis->get('favorite_animal')); //string(9) "butterfly"

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)

//TYPE
$redis->flushALL();
echo '<br><br>TYPE<br>';

var_dump($redis->TYPE('fake_key')); //none /int(0)

$redis->SET('weather',"sunny");  # 構建一個字符串
var_dump($redis->TYPE('weather'));//string / int(1)

$redis->SADD('pat',"dog");  # 構建一個集合
var_dump($redis->TYPE('pat')); //set /int(2)

$redis->LPUSH('book_list',"programming in scala");  # 構建一個列表
var_dump($redis->TYPE('book_list'));//list / int(3) 

$redis->ZADD('pats',1,'cat');  # 構建一個zset (sorted set) // int(1)
$redis->ZADD('pats',2,'dog');
$redis->ZADD('pats',3,'pig');
var_dump($redis->zRange('pats',0,-1)); // array(3) { [0]=> string(3) "cat" [1]=> string(3) "dog" [2]=> string(3) "pig" }
var_dump($redis->TYPE('pats')); //zset / int(4)

$redis->HSET('website','google','www.g.cn');   # 一個新域
var_dump($redis->HGET('website','google')); //string(8) "www.g.cn"
var_dump($redis->TYPE('website')); //hash /int(5)

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。

//EXPIRE
$redis->select(7);
//$redis->flushdb();

echo '<br><br>EXPIRE<br>';
$redis->SET('cache_page',"www.cnblogs.com/ikodota");
$redis->EXPIRE('cache_page', 30);  # 設置30秒後過時
sleep(6);
echo $redis->TTL('cache_page').'<br>';   # 查看給定key的剩餘生存時間 //(integer) 24

$redis->EXPIRE('cache_page', 3000);  # 更新生存時間，3000秒
sleep(4);
echo $redis->TTL('cache_page').'<br>';   //(integer) 2996

EXPIREAT
EXPIREAT key timestamp

EXPIREAT的做用和EXPIRE同樣，都用於爲key設置生存時間。

不一樣在於EXPIREAT命令接受的時間參數是UNIX時間戳(unix timestamp)。

時間複雜度：: O(1)
返回值：: 若是生存時間設置成功，返回 1。

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

//EXPIREAT
echo '<br><br>EXPIREAT<br>';
$redis->SET('cache','www.google.com');
echo $redis->EXPIREAT('cache','1355292000'); # 這個key將在2012.12.12過時

echo ($redis->TTL('cache')); //return 124345085

OBJECT
OBJECT subcommand [arguments [arguments]]

OBJECT命令容許從內部察看給定key的Redis對象。

它一般用在除錯(debugging)或者瞭解爲了節省空間而對 key使用特殊編碼的狀況。

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

OBJECT命令有多個子命令：

OBJECT REFCOUNT <key>返回給定key引用所儲存的值的次數。此命令主要用於除錯。
OBJECT ENCODING <key>返回給定key鎖儲存的值所使用的內部表示(representation)。
OBJECT IDLETIME <key>返回給定key自儲存以來的空轉時間(idle，沒有被讀取也沒有被寫入)，以秒爲單位。

對象能夠以多種方式編碼：

字符串能夠被編碼爲raw(通常字符串)或int(用字符串表示64位數字是爲了節約空間)。
列表能夠被編碼爲ziplist或linkedlist。ziplist是爲節約大小較小的列表空間而做的特殊表示。
集合能夠被編碼爲intset或者hashtable。intset是隻儲存數字的小集合的特殊表示。
哈希表能夠編碼爲zipmap或者hashtable。zipmap是小哈希表的特殊表示。
有序集合能夠被編碼爲ziplist或者skiplist格式。ziplist用於表示小的有序集合，而skiplist則用於表示任何大小的有序集合。

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

時間複雜度：: O(1)
返回值：: REFCOUNT和 IDLETIME返回數字。

ENCODING返回相應的編碼類型。

//OBJECT
$redis->select(8);
echo '<br><br>OBJECT<br>';
$redis->SET('game',"WOW");  # 設置一個字符串
$redis->OBJECT('REFCOUNT','game');  # 只有一個引用

//sleep(5);
echo $redis->OBJECT('IDLETIME','game');  # 等待一陣。。。而後查看空轉時間 //(integer) 10
//echo $redis->GET('game');  # 提取game， 讓它處於活躍(active)狀態  //return WOW
//echo $redis->OBJECT('IDLETIME','game');  # 再也不處於空轉 //(integer) 0
var_dump($redis->OBJECT('ENCODING','game'));  # 字符串的編碼方式 //string(3) "raw"
$redis->SET('phone',15820123123);  # 大的數字也被編碼爲字符串
var_dump($redis->OBJECT('ENCODING','phone')); //string(3) "raw"
$redis->SET('age',20);  # 短數字被編碼爲int
var_dump($redis->OBJECT('ENCODING','age')); //string(3) "int"

PERSIST
PERSIST key

移除給定key的生存時間。

時間複雜度：: O(1)
返回值：: 當生存時間移除成功時，返回 1.

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

//PERSIST
echo '<br><br>PERSIST<br>';
$redis->SET('time_to_say_goodbye',"886...");
$redis->EXPIRE('time_to_say_goodbye', 300);
sleep(3);
echo $redis->TTL('time_to_say_goodbye'); # (int) 297
echo '<br>';

$redis->PERSIST('time_to_say_goodbye');  # 移除生存時間
echo $redis->TTL('time_to_say_goodbye');  # 移除成功  //int(-1)

SORT

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

排序，分頁等
參數

array(
‘by’ => ‘some_pattern_*’,
‘limit’ => array(0, 1),
‘get’ => ‘some_other_pattern_*’ or an array of patterns,
‘sort’ => ‘asc’ or ‘desc’,
‘alpha’ => TRUE,
‘store’ => ‘external-key’
)

返回或保存給定列表、集合、有序集合key中通過排序的元素。

排序默認以數字做爲對象，值被解釋爲雙精度浮點數，而後進行比較。

通常SORT用法

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

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


# 將數據一一加入到列表中
$redis->LPUSH('today_cost', 30);
$redis->LPUSH('today_cost', 1.5);
$redis->LPUSH('today_cost', 10);
$redis->LPUSH('today_cost', 8);
# 排序
var_dump($redis->SORT('today_cost')); //array(4) { [0]=> string(3) "1.5" [1]=> string(1) "8" [2]=> string(2) "10" [3]=> string(2) "30" }

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

# 將數據一一加入到列表中
$redis->LPUSH('website', "www.reddit.com");
$redis->LPUSH('website', "www.slashdot.com");
$redis->LPUSH('website', "www.infoq.com");
# 默認排序
var_dump($redis->SORT('website'));//array(3) { [0]=> string(13) "www.infoq.com" [1]=> string(16) "www.slashdot.com" [2]=> string(14) "www.reddit.com" }

# 按字符排序 ALPHA=true
var_dump($redis->SORT('website', array('ALPHA'=>TRUE))); //array(3) { [0]=> string(13) "www.infoq.com" [1]=> string(14) "www.reddit.com" [2]=> string(16) "www.slashdot.com" }

若是你正確設置了!LC_COLLATE環境變量的話，Redis能識別UTF-8編碼。

      排序以後返回的元素數量能夠經過 
     LIMIT修飾符進行限制。 
    
 
     LIMIT修飾符接受兩個參數： 
     offset和 
     count。 
    
 
     offset指定要跳過的元素數量， 
     count指定跳過 
     offset個指定的元素以後，要返回多少個對象。 
    

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

# 將數據一一加入到列表中
$redis->LPUSH('rank', 30); //(integer) 1
$redis->LPUSH('rank', 56); //(integer) 2
$redis->LPUSH('rank', 42); //(integer) 3
$redis->LPUSH('rank', 22); //(integer) 4
$redis->LPUSH('rank', 0);  //(integer) 5
$redis->LPUSH('rank', 11); //(integer) 6
$redis->LPUSH('rank', 32); //(integer) 7
$redis->LPUSH('rank', 67); //(integer) 8
$redis->LPUSH('rank', 50); //(integer) 9
$redis->LPUSH('rank', 44); //(integer) 10
$redis->LPUSH('rank', 55); //(integer) 11

# 排序
$redis_sort_option=array('LIMIT'=>array(0,5));
var_dump($redis->SORT('rank',$redis_sort_option));   # 返回排名前五的元素 // array(5) { [0]=> string(1) "0" [1]=> string(2) "11" [2]=> string(2) "22" [3]=> string(2) "30" [4]=> string(2) "32" }

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

$redis_sort_option=array(
            'LIMIT'=>array(0,5),
            'SORT'=>'DESC'
            );
var_dump($redis->SORT('rank',$redis_sort_option)); //array(5) { [0]=> string(2) "67" [1]=> string(2) "56" [2]=> string(2) "55" [3]=> string(2) "50" [4]=> string(2) "44" }

使用外部key進行排序

有時候你會但願使用外部的key做爲權重來比較元素，代替默認的對比方法。

假設如今有用戶(user)數據以下：

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

id數據保存在key名爲user_id的列表中。
name數據保存在key名爲user_name_{id}的列表中
level數據保存在user_level_{id}的key中。

# 先將要使用的數據加入到數據庫中

# admin
$redis->LPUSH('user_id', 1);//(integer) 1
$redis->SET('user_name_1', 'admin');
$redis->SET('user_level_1',9999);

# huangz
$redis->LPUSH('user_id', 2);//(integer) 2
$redis->SET('user_name_2', 'huangz');
$redis->SET('user_level_2', 10);

# jack
$redis->LPUSH('user_id', 59230);//(integer) 3
$redis->SET('user_name_59230','jack');
$redis->SET('user_level_59230', 3);

# hacker
$redis->LPUSH('user_id', 222);  //(integer) 4
$redis->SET('user_name_222', 'hacker');
$redis->SET('user_level_222', 9999);

若是但願按level從大到小排序user_id，可使用如下命令：

$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC'
            );
var_dump($redis->SORT('user_id',$redis_sort_option)); //array(4) { [0]=> string(3) "222" [1]=> string(1) "1" [2]=> string(1) "2" [3]=> string(5) "59230" }

#---------------------------
#1) "222"    # hacker
#2) "1"      # admin
#3) "2"      # huangz
#4) "59230"  # jack

可是有時候只是返回相應的id沒有什麼用，你可能更但願排序後返回id對應的用戶名，這樣更友好一點，使用GET選項能夠作到這一點：

$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>'user_name_*'
            );
var_dump($redis->SORT('user_id', $redis_sort_option)); //array(4) { [0]=> string(6) "hacker" [1]=> string(5) "admin" [2]=> string(6) "huangz" [3]=> string(4) "jack" }

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

能夠屢次地、有序地使用GET操做來獲取更多外部key。

好比你不但但願獲取用戶名，還但願連用戶的密碼也一併列出，可使用如下命令：

# 先添加一些測試數據
$redis->SET('user_password_222', "hey,im in");
$redis->SET('user_password_1', "a_long_long_password");
$redis->SET('user_password_2', "nobodyknows");
$redis->SET('user_password_59230', "jack201022");

# 獲取name和password
$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>array('user_name_*','user_password_*')
            );
var_dump($redis->SORT('user_id',$redis_sort_option));//array(8) { [0]=> string(6) "hacker" [1]=> string(9) "hey,im in" [2]=> string(5) "admin" [3]=> string(20) "a_long_long_password" [4]=> string(6) "huangz" [5]=> string(11) "nobodyknows" [6]=> string(4) "jack" [7]=> string(10) "jack201022" }

#------------------------------------
#1) "hacker"       # 用戶名
#2) "hey,im in"    # 密碼
#3) "jack"
#4) "jack201022"
#5) "huangz"
#6) "nobodyknows"
#7) "admin"
#8) "a_long_long_password"

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

# 獲取name和password 注意GET操做是有序的
$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>array('user_password_*','user_name_*')
            );
var_dump($redis->SORT('user_id',$redis_sort_option));// array(8) { [0]=> string(9) "hey,im in" [1]=> string(6) "hacker" [2]=> string(20) "a_long_long_password" [3]=> string(5) "admin" [4]=> string(11) "nobodyknows" [5]=> string(6) "huangz" [6]=> string(10) "jack201022" [7]=> string(4) "jack" }

GET還有一個特殊的規則——"GET #"，用於獲取被排序對象(咱們這裏的例子是user_id)的當前元素。

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

$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>array('#','user_password_*','user_name_*')
            );
var_dump($redis->SORT('user_id',$redis_sort_option));//array(12) { [0]=> string(3) "222" [1]=> string(9) "hey,im in" [2]=> string(6) "hacker" [3]=> string(1) "1" [4]=> string(20) "a_long_long_password" [5]=> string(5) "admin" [6]=> string(1) "2" [7]=> string(11) "nobodyknows" [8]=> string(6) "huangz" [9]=> string(5) "59230" [10]=> string(10) "jack201022" [11]=> string(4) "jack" }

#--------------------------------------------------------------
#1) "222"          # id
#2) "hacker"       # name
#3) "hey,im in"    # password
#4) "1"
#5) "admin"
#6) "a_long_long_password"
#7) "2"
#8) "huangz"
#9) "nobodyknows"
#10) "59230"
#11) "jack"
#12) "jack201022"

只獲取對象而不排序

BY修飾符能夠將一個不存在的key看成權重，讓SORT跳過排序操做。

該方法用於你但願獲取外部對象而又不但願引發排序開銷時使用。

# 確保fake_key不存在
$redis->EXISTS('fake_key');//(integer) 0

# 以fake_key做BY參數，不排序，只GET name 和 GET password
$redis_sort_option=array('BY'=>'fake_key',
            'SORT'=>'DESC',
            'GET'=>array('#','user_name_*','user_password_*')
            );
var_dump($redis->SORT('user_id',$redis_sort_option));//array(12) { [0]=> string(3) "222" [1]=> string(6) "hacker" [2]=> string(9) "hey,im in" [3]=> string(5) "59230" [4]=> string(4) "jack" [5]=> string(10) "jack201022" [6]=> string(1) "2" [7]=> string(6) "huangz" [8]=> string(11) "nobodyknows" [9]=> string(1) "1" [10]=> string(5) "admin" [11]=> string(20) "a_long_long_password" }

#----------------------------------------------
#1) "222"        # id
#2) "hacker"     # user_name
#3) "hey,im in"  # password
#4) "59230"
#5) "jack"
#6) "jack201022"
#7) "2"
#8) "huangz"
#9) "nobodyknows"
#10) "1"
#11) "admin"
#12) "a_long_long_password"

保存排序結果

默認狀況下，SORT操做只是簡單地返回排序結果，若是你但願保存排序結果，能夠給STORE選項指定一個key做爲參數，排序結果將以列表的形式被保存到這個key上。(若指定key已存在，則覆蓋。)

$redis->EXISTS('user_info_sorted_by_level');  # 確保指定key不存在   //(integer) 0
$redis_sort_option=array('BY'=>'user_level_*',
            'GET'=>array('#','user_name_*','user_password_*'),
            'STORE'=>'user_info_sorted_by_level'
            );

var_dump($redis->SORT('user_id',$redis_sort_option)); //int(12)
var_dump($redis->LRANGE('user_info_sorted_by_level', 0 ,11));  # 查看排序結果  //array(12) { [0]=> string(5) "59230" [1]=> string(4) "jack" [2]=> string(10) "jack201022" [3]=> string(1) "2" [4]=> string(6) "huangz" [5]=> string(11) "nobodyknows" [6]=> string(3) "222" [7]=> string(6) "hacker" [8]=> string(9) "hey,im in" [9]=> string(1) "1" [10]=> string(5) "admin" [11]=> string(20) "a_long_long_password" }

#-----------------------------------------------------------------
#1) "59230"
#2) "jack"
#3) "jack201022"
#4) "2"
#5) "huangz"
#6) "nobodyknows"
#7) "222"
#8) "hacker"
#9) "hey,im in"
#10) "1"
#11) "admin"
#12) "a_long_long_password"

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

這樣就沒必要頻繁地調用SORT操做了，只有當結果集過時時，才須要再調用一次SORT操做。

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

在GET和BY中使用哈希表

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

# 假設如今咱們的用戶表新增了一個serial項來爲做爲每一個用戶的序列號
# 序列號以哈希表的形式保存在serial哈希域內。

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

$redis->HMSET('serial',$redis_hash_testdata_array);

# 咱們但願以比較serial中的大小來做爲排序user_id的方式
$redis_sort_option=array('BY'=>'*->serial');
var_dump($redis->SORT('user_id', $redis_sort_option)); //array(4) { [0]=> string(3) "222" [1]=> string(5) "59230" [2]=> string(1) "2" [3]=> string(1) "1" }

#----------------------------------------
#1) "222"
#2) "59230"
#3) "2"
#4) "1"

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

除此以外，哈希表的BY和GET操做和上面介紹的其餘數據結構(列表、集合、有序集合)沒有什麼不一樣。

時間複雜度：: O(N+M*log(M))， N爲要排序的列表或集合內的元素數量， M爲要返回的元素數量。

若是隻是使用SORT命令的 GET選項獲取數據而沒有進行排序，時間複雜度O(N)。
返回值：: 沒有使用 STORE參數，返回列表形式的排序結果。

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

字符串(String)

SET

SET key value

將字符串值value關聯到key。

若是key已經持有其餘值，SET就覆寫舊值，無視類型。

時間複雜度：O(1)返回值：老是返回OK(TRUE)，由於SET不可能失敗。

# 狀況1：對字符串類型的key進行SET
$redis->SET('apple', 'www.apple.com');#OK  //bool(true)
$redis->GET('apple');//"www.apple.com"

# 狀況2：對非字符串類型的key進行SET
$redis->LPUSH('greet_list', "hello");  # 創建一個列表 #(integer) 1 //int(1)
$redis->TYPE('greet_list');#list //int(3)

$redis->SET('greet_list', "yooooooooooooooooo");   # 覆蓋列表類型 #OK //bool(true)
$redis->TYPE('greet_list');#string //int(1)

SETNX

SETNX key value

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

若給定的key已經存在，則SETNX不作任何動做。

SETNX是」SET if Not eXists」(若是不存在，則SET)的簡寫。

時間複雜度：: O(1)
返回值：: 設置成功，返回 1。

設置失敗，返回 0。

//SETNX
echo '<br><br>SETNX<br>';
$redis->EXISTS('job');  # job不存在 //bool(false);
$redis->SETNX('job', "programmer");  # job設置成功 //bool(true)
$redis->SETNX('job', "code-farmer");  # job設置失敗 //bool(false)
echo $redis->GET('job');  # 沒有被覆蓋 //"programmer"

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

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

SETNX lock.foo <current Unix time + lock timeout + 1>

若是SETNX返回1，說明客戶端已經得到了鎖，key設置的unix時間則指定了鎖失效的時間。以後客戶端能夠經過DEL lock.foo來釋放鎖。

若是SETNX返回0，說明key已經被其餘客戶端上鎖了。若是鎖是非阻塞(non blocking lock)的，咱們能夠選擇返回調用，或者進入一個重試循環，直到成功得到鎖或重試超時(timeout)。

處理死鎖(deadlock)

上面的鎖算法有一個問題：若是由於客戶端失敗、崩潰或其餘緣由致使沒有辦法釋放鎖的話，怎麼辦？

這種情況能夠經過檢測發現——由於上鎖的key保存的是unix時間戳，假如key值的時間戳小於當前的時間戳，表示鎖已經再也不有效。

可是，當有多個客戶端同時檢測一個鎖是否過時並嘗試釋放它的時候，咱們不能簡單粗暴地刪除死鎖的key，再用SETNX上鎖，由於這時競爭條件(race condition)已經造成了：

C1和C2讀取lock.foo並檢查時間戳，SETNX都返回0，由於它已經被C3鎖上了，但C3在上鎖以後就崩潰(crashed)了。
C1向lock.foo發送DEL命令。
C1向lock.foo發送SETNX併成功。
C2向lock.foo發送DEL命令。
C2向lock.foo發送SETNX併成功。
出錯：由於競爭條件的關係，C1和C2兩個都得到了鎖。

幸虧，如下算法能夠避免以上問題。來看看咱們聰明的C4客戶端怎麼辦：

C4向lock.foo發送SETNX命令。
由於崩潰掉的C3還鎖着lock.foo，因此Redis向C4返回0。
C4向lock.foo發送GET命令，查看lock.foo的鎖是否過時。若是不，則休眠(sleep)一段時間，並在以後重試。
另外一方面，若是lock.foo內的unix時間戳比當前時間戳老，C4執行如下命令：

GETSET lock.foo <current Unix timestamp + lock timeout + 1>

由於GETSET的做用，C4能夠檢查看GETSET的返回值，肯定lock.foo以前儲存的舊值還是那個過時時間戳，若是是的話，那麼C4得到鎖。
若是其餘客戶端，好比C5，比C4更快地執行了GETSET操做並得到鎖，那麼C4的GETSET操做返回的就是一個未過時的時間戳(C5設置的時間戳)。C4只好從第一步開始重試。

注意，即使C4的GETSET操做對 key進行了修改，這對將來也沒什麼影響。

(這裏是否是有點問題？C4的確是能夠重試，但C5怎麼辦？它的鎖的過時被C4修改了。——譯註)

警告

爲了讓這個加鎖算法更健壯，得到鎖的客戶端應該經常檢查過時時間以避免鎖因諸如DEL等命令的執行而被意外解開，由於客戶端失敗的狀況很是複雜，不只僅是崩潰這麼簡單，還多是客戶端由於某些操做被阻塞了至關長時間，緊接着DEL命令被嘗試執行(但這時鎖卻在另外的客戶端手上)。

SETEX

SETEX key seconds value

將值value關聯到key，並將key的生存時間設爲seconds(以秒爲單位)。

若是key 已經存在，SETEX命令將覆寫舊值。

這個命令相似於如下兩個命令：

$redis->SET('key', 'value');
$redis->EXPIRE('key','seconds');  # 設置生存時間

不一樣之處是，SETEX是一個原子性(atomic)操做，關聯值和設置生存時間兩個動做會在同一時間內完成，該命令在Redis用做緩存時，很是實用。

時間複雜度：: O(1)
返回值：: 設置成功時返回 OK。

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

# 狀況1：key不存在
$redis->SETEX('cache_user_id', 60,10086);//bool(true)
echo $redis->GET('cache_user_id');  # 值 //"10086"

sleep(4);
echo $redis->TTL('cache_user_id');  # 剩餘生存時間 //int(56)

# 狀況2：key已經存在，key被覆寫
$redis->SET('cd', "timeless"); //bool(true);
$redis->SETEX('cd', 3000,"goodbye my love"); //bool(true);
echo $redis->GET('cd');//"goodbye my love"

SETRANGE

SETRANGE key offset value

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

不存在的key看成空白字符串處理。

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

注意你能使用的最大偏移量是2^29-1(536870911)，由於Redis的字符串被限制在512兆(megabytes)內。若是你須要使用比這更大的空間，你得使用多個key。

時間複雜度：: 對小(small)的字符串，平攤複雜度O(1)。(關於什麼字符串是」小」的，請參考APPEND命令)

不然爲O(M)，M爲value參數的長度。
返回值：: 被SETRANGE修改以後，字符串的長度。

警告

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

模式

由於有了SETRANGE和GETRANGE命令，你能夠將Redis字符串用做具備O(1)隨機訪問時間的線性數組。這在不少真實用例中都是很是快速且高效的儲存方式。

# 狀況1：對非空字符串進行SETRANGE
$redis->SET('greeting', "hello world");
$redis->SETRANGE('greeting', 6, "Redis"); //int(11)
$redis->GET('greeting');//"hello Redis"

# 狀況2：對空字符串/不存在的key進行SETRANGE
$redis->EXISTS('empty_string');//bool(false)
$redis->SETRANGE('empty_string', 5 ,"Redis!");  # 對不存在的key使用SETRANGE //int(11)
var_dump($redis->GET('empty_string'));  # 空白處被"\x00"填充  #"\x00\x00\x00\x00\x00Redis!"   //return string(11) "Redis!"

MSET
MSET key value [key value ...]

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

當發現同名的key存在時，MSET會用新值覆蓋舊值，若是你不但願覆蓋同名key，請使用MSETNX命令。

MSET是一個原子性(atomic)操做，全部給定key都在同一時間內被設置，某些給定key被更新而另外一些給定key沒有改變的狀況，不可能發生。

時間複雜度：: O(N)， N爲要設置的 key數量。
返回值：: 老是返回 OK(由於 MSET不可能失敗)

#MSET
echo '<br><br>MSET<br>';
$redis->select(0);
$redis->flushdb();
$array_mset=array('date'=>'2012.3.5',
        'time'=>'9.09a.m.',
        'weather'=>'sunny'
        );
$redis->MSET($array_mset); //bool(true)

var_dump($redis->KEYS('*'));   # 確保指定的三個key-value對被插入 //array(3) { [0]=> string(4) "time" [1]=> string(7) "weather" [2]=> string(4) "date" }

# MSET覆蓋舊值的例子 可是通過測試覆蓋不了
var_dump($redis->SET('google', "google.cn"));   //bool(true)
var_dump($redis->MSET('google',"google.hk")); //bool(false)
echo $redis->GET('google'); //google.cn  與redis手冊的示例結果不符

MSETNX

MSETNX key value [key value ...]

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

即便只有一個key已存在，MSETNX也會拒絕全部傳入key的設置操做

MSETNX是原子性的，所以它能夠用做設置多個不一樣key表示不一樣字段(field)的惟一性邏輯對象(unique logic object)，全部字段要麼全被設置，要麼全不被設置。

時間複雜度：: O(N)， N爲要設置的 key的數量。
返回值：: 當全部 key都成功設置，返回 1。

若是全部key都設置失敗(最少有一個 key已經存在)，那麼返回 0。

# 狀況1：對不存在的key進行MSETNX
$array_mset=array('rmdbs'=>'MySQL',
        'nosql'=>'MongoDB',
        'key-value-store'=>'redis'
        );
$redis->MSETNX($array_mset);//bool(true)


# 狀況2：對已存在的key進行MSETNX
$array_mset=array('rmdbs'=>'Sqlite',
        'language'=>'python'
        );
var_dump($redis->MSETNX($array_mset));  # rmdbs鍵已經存在，操做失敗 //bool(false)
var_dump($redis->EXISTS('language'));  # 由於操做是原子性的，language沒有被設置  bool(false)

echo $redis->GET('rmdbs');  # rmdbs沒有被修改 //"MySQL"

$array_mset_keys=array( 'rmdbs', 'nosql', 'key-value-store');
print_r($redis->MGET($array_mset_keys)); //Array ( [0] => MySQL [1] => MongoDB [2] => redis )

APPEND

APPEND key value

若是key已經存在而且是一個字符串，APPEND命令將value追加到key原來的值以後。

若是key不存在，APPEND就簡單地將給定key設爲value，就像執行SET key value同樣。

時間複雜度：: 平攤複雜度O(1)
返回值：: 追加 value以後， key中字符串的長度。

# 狀況1：對不存在的key執行APPEND

$redis->EXISTS('myphone');  # 確保myphone不存在 //bool(false)
$redis->APPEND('myphone',"nokia");  # 對不存在的key進行APPEND，等同於SET myphone "nokia" //int(5) # 字符長度

# 狀況2：對字符串進行APPEND
$redis->APPEND('myphone', " - 1110");# 長度從5個字符增長到12個字符 //int(12)

echo $redis->GET('myphone');  # 查看整個字符串 //"nokia - 1110"

GET

GET key

返回key所關聯的字符串值。

若是key不存在則返回特殊值nil。

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

時間複雜度：: O(1)
返回值：: key的值。

若是 key不存在，返回 nil。

//GET
var_dump($redis->GET('fake_key')); #(nil) //return bool(false)
$redis->SET('animate', "anohana"); //return bool(true)
var_dump($redis->GET('animate')); //return string(7) "anohana"

MGET

MGET key [key ...]

返回全部(一個或多個)給定key的值。

若是某個指定key不存在，那麼返回特殊值nil。所以，該命令永不失敗。

時間複雜度:: O(1)
返回值：: 一個包含全部給定 key的值的列表。

//MGET
echo '<br><br>MGET<br>';
$redis_mget_data_array=array('name'=>'ikodota','blog'=>'cnblogs.com/ikodota');
$redis->MSET($redis_mget_data_array);#用MSET一次儲存多個值 

$redis_mget_key_array=array('name','blog');
var_dump($redis->MGET($redis_mget_key_array)); //array(2) { [0]=> string(7) "ikodota" [1]=> string(19) "cnblogs.com/ikodota" }

$redis->EXISTS('fake_key'); //bool(false)

$redis_mget_key_array=array('name','fake_key');
var_dump($redis->MGET($redis_mget_key_array));  # 當MGET中有不存在key的狀況   //array(2) { [0]=> string(7) "ikodota" [1]=> bool(false) }

GETRANGE

GETRANGE key start end

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

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

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

時間複雜度：: O(N)， N爲要返回的字符串的長度。

複雜度最終由返回值長度決定，但由於從已有字符串中創建子字符串的操做很是廉價(cheap)，因此對於長度不大的字符串，該操做的複雜度也可看做O(1)。
返回值：: 截取得出的子字符串。

註解:在<=2.0的版本里，GETRANGE被叫做SUBSTR。

//GETRANGE
echo '<br><br>GETRANGE<br>';
$redis->SET('greeting', "hello, my friend");
echo $redis->GETRANGE('greeting', 0, 4).'<br>';  # 返回索引0-4的字符，包括4。 //"hello"
echo $redis->GETRANGE('greeting', -1 ,-5).'<br>';  # 不支持迴繞操做  //""
echo $redis->GETRANGE('greeting', -3 ,-1).'<br>';  # 負數索引 //"end"
echo $redis->GETRANGE('greeting', 0, -1).'<br>';  # 從第一個到最後一個 //"hello, my friend"
echo $redis->GETRANGE('greeting', 0, 1008611).'<br>';  # 值域範圍不超過實際字符串，超過部分自動被符略 //"hello, my friend"

GETSET

GETSET key value

將給定key的值設爲value，並返回key的舊值。

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

時間複雜度：: O(1)
返回值：: 返回給定 key的舊值(old value)。

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

//GETSET
echo '<br><br>GETSET<br>';
var_dump($redis->EXISTS('mail'));//return bool(false);
var_dump($redis->GETSET('mail','xxx@google.com'));  # 由於mail以前不存在，沒有舊值，返回nil ,#(nil)   //bool(false)

var_dump($redis->GETSET('mail','xxx@yahoo.com'));  # mail被更新，舊值被返回 //string(14) "xxx@google.com"

設計模式

GETSET能夠和INCR組合使用，實現一個有原子性(atomic)復位操做的計數器(counter)。

舉例來講，每次當某個事件發生時，進程可能對一個名爲mycount的key調用INCR操做，一般咱們還要在一個原子時間內同時完成得到計數器的值和將計數器值復位爲0兩個操做。

能夠用命令GETSET mycounter 0來實現這一目標。

$redis->SELECT(2);
echo $redis->INCR('mycount').'<br>'; #(integer) 11

if($redis->GET('mycount')>19){
    echo $redis->GETSET('mycount', 0).'<br>';  # 一個原子內完成GET mycount和SET mycount 0操做 #"11" 
}
echo $redis->GET('mycount'); #"0"

STRLEN

STRLEN key

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

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

複雜度：: O(1)
返回值：: 字符串值的長度。

當 key不存在時，返回 0。

$redis->SET('mykey', "Hello world");
echo $redis->STRLEN('mykey'); //int(11)
echo $redis->STRLEN('nonexisting'); # 不存在的key長度視爲0  //int(0)

INCR

INCR key

將key中儲存的數字值增一。

若是key不存在，以0爲key的初始值，而後執行INCR操做。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在64位(bit)有符號數字表示以內。

時間複雜度：: O(1)
返回值：: 執行INCR命令以後 key的值。

註解:這是一個針對字符串的操做，由於Redis沒有專用的整數類型，因此key內儲存的字符串被解釋爲十進制64位有符號整數來執行INCR操做。

$redis->SET('page_view', 20);
var_dump($redis->INCR('page_view')); //int(21) 
var_dump($redis->GET('page_view'));    # 數字值在Redis中以字符串的形式保存 //string(2) "21

INCRBY

INCRBY key increment

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

若是key不存在，以0爲key的初始值，而後執行INCRBY命令。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在64位(bit)有符號數字表示以內。

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

時間複雜度：: O(1)
返回值：: 加上 increment以後， key的值。

//INCRBY
echo '<br><br>INCRBY<br>';
# 狀況1：key存在且是數字值
$redis->SET('rank', 50);  # 設置rank爲50
$redis->INCRBY('rank', 20);  # 給rank加上20
var_dump($redis->GET('rank')); #"70"   //string(2) "70"

# 狀況2：key不存在
$redis->EXISTS('counter'); //bool(false)
$redis->INCRBY('counter'); #int 30  //bool(false)
var_dump($redis->GET('counter')); #30 //經測試 與手冊上結果不同，不能直接從bool型轉爲int型。 return bool(false) 

# 狀況3：key不是數字值
$redis->SET('book', "long long ago...");
var_dump($redis->INCRBY('book', 200)); #(error) ERR value is not an integer or out of range   // bool(false)

DECR


DECR key

將key中儲存的數字值減一。

若是key不存在，以0爲key的初始值，而後執行DECR操做。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在64位(bit)有符號數字表示以內。

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

時間複雜度：: O(1)
返回值：: 執行DECR命令以後 key的值。

//DECR
$redis->SELECT(3);
$redis->flushdb();
echo '<br><br>DECR<br>';
# 狀況1：對存在的數字值key進行DECR
$redis->SET('failure_times', 10);
$redis->DECR('failure_times'); //int(9)
echo $redis->GET('failure_times').'<br>';  //string(1) "9"

# 狀況2：對不存在的key值進行DECR
$redis->EXISTS('count'); #(integer) 0 //bool(false)
$redis->DECR('count');  //int(-1) 
echo $redis->GET('count').'<br>'; //string(2) "-1"

# 狀況3：對存在但不是數值的key進行DECR
$redis->SET('company', 'YOUR_CODE_SUCKS.LLC');
var_dump($redis->DECR('company')); #(error) ERR value is not an integer or out of range   //bool(false)
echo $redis->GET('company').'<br>'; //YOUR_CODE_SUCKS.LLC

DECRBY

DECRBY key decrement

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

若是key不存在，以0爲key的初始值，而後執行DECRBY操做。

若是值包含錯誤的類型，或字符串類型的值不能表示爲數字，那麼返回一個錯誤。

本操做的值限制在64位(bit)有符號數字表示以內。

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

時間複雜度：: O(1)
返回值：: 減去 decrement以後， key的值。

# 狀況1：對存在的數值key進行DECRBY
$redis->SET('count', 100);
var_dump($redis->DECRBY('count', 20)); //int(80)
var_dump($redis->GET('count'));  //string(2) "80"

# 狀況2：對不存在的key進行DECRBY
$redis->EXISTS('pages');#(integer) 0  //bool(false)
var_dump($redis->DECRBY('pages', 10));  //int(-10)
var_dump($redis->GET('pages')); //string(3) "-10"

SETBIT

SETBIT key offset value

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

位的設置或清除取決於value參數，能夠是0也能夠是1。

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

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

offset參數必須大於或等於0，小於2^32(bit映射被限制在512MB內)。

時間複雜度:: O(1)
返回值：: 指定偏移量原來儲存的位（"0"或"1"）.

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

//SETBIT
echo '<br><br>SETBIT<br>';
$bit_val=67;
echo decbin($bit_val).'<br>'; //1000011
var_dump($redis->SETBIT('bit',1,1));//int(0)  空位上都是0
var_dump($redis->SETBIT('bit',2,0));//int(0)
var_dump($redis->SETBIT('bit',3,0));//int(0)
var_dump($redis->SETBIT('bit',4,0));//int(0)
var_dump($redis->SETBIT('bit',5,0));//int(0)
var_dump($redis->SETBIT('bit',6,1));//int(0)
var_dump($redis->SETBIT('bit',7,1));//int(0)

var_dump($redis->GET('bit')); //string(1) "C" ,二進制爲：1000011 ,ASCII:67

var_dump($redis->GETBIT('bit', 6 )); //int(1)  取出第6位（從左到右）爲「1」

var_dump($redis->SETBIT('bit',5,1));//int(0)  把第5位的0改成1
var_dump($redis->SETBIT('bit',6,0));//int(1)  把第6位的1改成0

var_dump($redis->GET('bit')); //string(1) "E ,二進制爲：1000101,ASCII:69l

GETBIT

GETBIT key offset

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

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

時間複雜度：: O(1)
返回值：: 字符串值指定偏移量上的位(bit)。

#參見SETBIT的示例

哈希表(Hash)

HSET

HSET key field value

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

若是key不存在，一個新的哈希表被建立並進行HSET操做。

若是域field已經存在於哈希表中，舊值將被覆蓋。

時間複雜度：: O(1)
返回值：: 若是 field是哈希表中的一個新建域，而且值設置成功，返回 1。

若是哈希表中域 field已經存在且舊值已被新值覆蓋，返回 0。

HSETNX

HSETNX key field value

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

若域field已經存在，該操做無效。

若是key不存在，一個新哈希表被建立並執行HSETNX命令。

時間複雜度：: O(1)
返回值：: 設置成功，返回 1。

若是給定域已經存在且沒有操做被執行，返回 0。

HMSET

HMSET key field value [field value ...]

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

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

若是key不存在，一個空哈希表被建立並執行HMSET操做。

時間複雜度：: O(N)， N爲 field - value對的數量。
返回值：: 若是命令執行成功，返回 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爲給定域的數量。
返回值：: 一個包含多個給定域的關聯值的表，表值的排列順序和給定域參數的請求順序同樣。

HGETALL

HGETALL key

返回哈希表key中，全部的域和值。

在返回值裏，緊跟每一個域名(field name)以後是域的值(value)，因此返回值的長度是哈希表大小的兩倍。

時間複雜度：: O(N)， N爲哈希表的大小。
返回值：: 以列表形式返回哈希表的域和域的值。若 key不存在，返回空列表。

HDEL

HDEL key field [field ...]

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

時間複雜度:: O(N)， N爲要刪除的域的數量。
返回值:: 被成功移除的域的數量，不包括被忽略的域。

註解:在Redis2.4如下的版本里，HDEL每次只能刪除單個域，若是你須要在一個原子時間內刪除多個域，請將命令包含在MULTI/ EXEC塊內。

HLEN

HLEN key

返回哈希表key中域的數量。

時間複雜度：: O(1)
返回值：: 哈希表中域的數量。

當 key不存在時，返回 0。

HEXISTS

HEXISTS key field

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

時間複雜度：: O(1)
返回值：: 若是哈希表含有給定域，返回 1。

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

HINCRBY

HINCRBY key field increment

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

增量也能夠爲負數，至關於對給定域進行減法操做。

若是key不存在，一個新的哈希表被建立並執行HINCRBY命令。

若是域field不存在，那麼在執行命令前，域的值被初始化爲0。

對一個儲存字符串值的域field執行HINCRBY命令將形成一個錯誤。

本操做的值限制在64位(bit)有符號數字表示以內。

時間複雜度：: O(1)
返回值：: 執行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)執行LPUSH mylist a b c，則結果列表爲c b a，等同於執行執行命令LPUSH mylist a、LPUSH mylist b、LPUSH mylist c。

若是key不存在，一個空列表會被建立並執行LPUSH操做。

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

時間複雜度：: O(1)
返回值：: 執行LPUSH命令後，列表的長度。

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

LPUSHX

LPUSHX key value

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

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

時間複雜度：: O(1)
返回值：: LPUSHX命令執行以後，表的長度。

RPUSH

RPUSH key value [value ...]

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

若是有多個value值，那麼各個value值按從左到右的順序依次插入到表尾：好比對一個空列表(mylist)執行RPUSH mylist a b c，則結果列表爲a b c，等同於執行命令RPUSHmylist a、RPUSH mylist b、RPUSH mylist c。

若是key不存在，一個空列表會被建立並執行RPUSH操做。

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

時間複雜度：: O(1)
返回值：: 執行RPUSH操做後，表的長度。

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

RPUSHX

RPUSHX key value

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

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

時間複雜度：: O(1)
返回值：: RPUSHX命令執行以後，表的長度。

LPOP

LPOP key

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

時間複雜度：: O(1)
返回值：: 列表的頭元素。

當 key不存在時，返回 nil。

RPOP

RPOP key

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

時間複雜度：: O(1)
返回值：: 列表的尾元素。

當 key不存在時，返回 nil。

BLPOP

BLPOP key [key ...] timeout

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

它是LPOP命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，鏈接將被BLPOP命令阻塞，直到等待超時或發現可彈出元素爲止。

當給定多個key參數時，按參數key的前後順序依次檢查各個列表，彈出第一個非空列表的頭元素。

非阻塞行爲

當BLPOP被調用時，若是給定key內至少有一個非空列表，那麼彈出遇到的第一個非空列表的頭元素，並和被彈出元素所屬的列表的名字一塊兒，組成結果返回給調用者。

當存在多個給定key時，BLPOP按給定key參數排列的前後順序，依次檢查各個列表。

假設如今有job、 command和request三個列表，其中job不存在，command和request都持有非空列表。考慮如下命令：

BLPOP job command request 0

BLPOP保證返回的元素來自command，由於它是按」查找job -> 查找command -> 查找request「這樣的順序，第一個找到的非空列表。

阻塞行爲

若是全部給定key都不存在或包含空列表，那麼BLPOP命令將阻塞鏈接，直到等待超時，或有另外一個客戶端對給定key的任意一個執行LPUSH或RPUSH命令爲止。

超時參數timeout接受一個以秒爲單位的數字做爲值。超時參數設爲0表示阻塞時間能夠無限期延長(block indefinitely) 。

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

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

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

在MULTI/EXEC事務中的BLPOP

BLPOP能夠用於流水線(pipline,批量地發送多個命令並讀入多個回覆)，但把它用在MULTI/EXEC塊當中沒有意義。由於這要求整個服務器被阻塞以保證塊執行時的原子性，該行爲阻止了其餘客戶端執行LPUSH或RPUSH命令。

所以，一個被包裹在MULTI/EXEC塊內的BLPOP命令，行爲表現得就像LPOP同樣，對空列表返回nil，對非空列表彈出列表元素，不進行任何阻塞操做。

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

若是列表爲空，返回一個 nil。

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

BRPOP

BRPOP key [key ...] timeout

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

它是RPOP命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，鏈接將被BRPOP命令阻塞，直到等待超時或發現可彈出元素爲止。

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

關於阻塞操做的更多信息，請查看BLPOP命令，BRPOP除了彈出元素的位置和BLPOP不一樣以外，其餘表現一致。

時間複雜度：: O(1)
返回值：: 假如在指定時間內沒有任何元素被彈出，則返回一個 nil和等待時長。

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

LLEN

LLEN key

返回列表key的長度。

若是key不存在，則key被解釋爲一個空列表，返回0.

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

時間複雜度：: O(1)
返回值：: 列表 key的長度。

LRANGE

LRANGE key start stop

返回列表key中指定區間內的元素，區間以偏移量start和stop指定。

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

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

注意LRANGE命令和編程語言區間函數的區別

假如你有一個包含一百個元素的列表，對該列表執行LRANGE list 0 10，結果是一個包含11個元素的列表，這代表stop下標也在LRANGE命令的取值範圍以內(閉區間)，這和某些語言的區間函數可能不一致，好比Ruby的Range.new、Array#slice和Python的range()函數。

超出範圍的下標

超出範圍的下標值不會引發錯誤。

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

若是stop下標比end下標還要大，Redis將stop的值設置爲end。

時間複雜度:: O(S+N)， S爲偏移量 start， N爲指定區間內元素的數量。
返回值:: 一個列表，包含指定區間內的元素。

LREM

LREM key count value

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

count的值能夠是如下幾種：

count > 0: 從表頭開始向表尾搜索，移除與value相等的元素，數量爲count。
count < 0: 從表尾開始向表頭搜索，移除與value相等的元素，數量爲count的絕對值。
count = 0: 移除表中全部與value相等的值。

時間複雜度：

O(N)， N爲列表的長度。

返回值：

被移除元素的數量。

由於不存在的 key被視做空表(empty list)，因此當 key不存在時，LREM命令老是返回 0。

LSET

LSET key index value

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

更多信息請參考LINDEX操做。

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

時間複雜度：: 對頭元素或尾元素進行LSET操做，複雜度爲O(1)。

其餘狀況下，爲O(N)， N爲列表的長度。
返回值：: 操做成功返回 ok，不然返回錯誤信息

LTRIM

LTRIM key start stop

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

舉個例子，執行命令LTRIM list 0 2，表示只保留列表list的前三個元素，其他元素所有刪除。

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

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

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

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

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

注意LTRIM命令和編程語言區間函數的區別

假如你有一個包含一百個元素的列表list，對該列表執行LTRIM list 0 10，結果是一個包含11個元素的列表，這代表stop下標也在LTRIM命令的取值範圍以內(閉區間)，這和某些語言的區間函數可能不一致，好比Ruby的Range.new、Array#slice和Python的range()函數。

超出範圍的下標

超出範圍的下標值不會引發錯誤。

若是start下標比列表的最大下標end(LLEN list減去1)還要大，或者start > stop，LTRIM返回一個空列表(由於LTRIM已經將整個列表清空)。

若是stop下標比end下標還要大，Redis將stop的值設置爲end。

時間複雜度:: O(N)， N爲被移除的元素的數量。
返回值:: 命令執行成功時，返回 ok。

LINDEX

LINDEX key index

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

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

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

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

時間複雜度：: O(N)， N爲到達下標 index過程當中通過的元素數量。

所以，對列表的頭元素和尾元素執行LINDEX命令，複雜度爲O(1)。
返回值:: 列表中下標爲 index的元素。

若是 index參數的值不在列表的區間範圍內(out of range)，返回 nil。

LINSERT

LINSERT key BEFORE|AFTER pivot value

將值value插入到列表key當中，位於值pivot以前或以後。

當pivot不存在於列表key時，不執行任何操做。

當key不存在時，key被視爲空列表，不執行任何操做。

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

時間複雜度:: O(N)， N爲尋找 pivot過程當中通過的元素數量。
返回值:: 若是命令執行成功，返回插入操做完成以後，列表的長度。

若是沒有找到 pivot，返回 -1。

若是 key不存在或爲空列表，返回 0。

RPOPLPUSH

RPOPLPUSH source destination

命令RPOPLPUSH在一個原子時間內，執行如下兩個動做：

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

將source彈出的元素插入到列表destination，做爲destination列表的的頭元素。

舉個例子，你有兩個列表source和destination，source列表有元素a, b, c，destination列表有元素x, y, z，執行RPOPLPUSH source destination以後，source列表包含元素a, b，destination列表包含元素c, x, y, z ，而且元素c被返回。

若是source不存在，值nil被返回，而且不執行其餘動做。

若是source和destination相同，則列表中的表尾元素被移動到表頭，並返回該元素，能夠把這種特殊狀況視做列表的旋轉(rotation)操做。

時間複雜度：: O(1)
返回值：: 被彈出的元素。

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

Redis的列表常常被用做隊列(queue)，用於在不一樣程序之間有序地交換消息(message)。一個程序(稱之爲生產者，producer)經過LPUSH命令將消息放入隊列中，而另外一個程序(稱之爲消費者，consumer)經過RPOP命令取出隊列中等待時間最長的消息。

不幸的是，在這個過程當中，一個消費者可能在得到一個消息以後崩潰，而未執行完成的消息也所以丟失。

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

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

BRPOPLPUSH

BRPOPLPUSH source destination timeout

BRPOPLPUSH是RPOPLPUSH的阻塞版本，當給定列表source不爲空時，BRPOPLPUSH的表現和RPOPLPUSH同樣。

當列表source爲空時，BRPOPLPUSH命令將阻塞鏈接，直到等待超時，或有另外一個客戶端對source執行LPUSH或RPUSH命令爲止。

超時參數timeout接受一個以秒爲單位的數字做爲值。超時參數設爲0表示阻塞時間能夠無限期延長(block indefinitely) 。

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

時間複雜度：: O(1)
返回值：: 假如在指定時間內沒有任何元素被彈出，則返回一個 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中都出現，那隻記錄一次便可。
union(A,B) = {'a', 'b', 'c', 'e', 'i', 'o', 'u'}

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

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

空集： 基數爲0的集合。

SADD

SADD key member [member ...]

將一個或多個member元素加入到集合key當中，已經存在於集合的member元素將被忽略。

假如key不存在，則建立一個只包含member元素做成員的集合。

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

時間複雜度:: O(N)， N是被添加的元素的數量。
返回值:: 被添加到集合中的新元素的數量，不包括被忽略的元素。

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

SREM

SREM key member [member ...]

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

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

時間複雜度:: O(N)， N爲給定 member元素的數量。
返回值:: 被成功移除的元素的數量，不包括被忽略的元素。

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

SMEMBERS

SMEMBERS key

返回集合key中的全部成員。

時間複雜度:: O(N)， N爲集合的基數。
返回值:: 集合中的全部成員。

SISMEMBER

SISMEMBER key member

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

時間複雜度:: O(1)
返回值:: 若是 member元素是集合的成員，返回 1。

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

SCARD

SCARD key

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

時間複雜度:: O(1)
返回值：: 集合的基數。

當 key不存在時，返回 0。

SMOVE

SMOVE source destination member

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

SMOVE是原子性操做。

若是source集合不存在或不包含指定的member元素，則SMOVE命令不執行任何操做，僅返回0。不然，member元素從source集合中被移除，並添加到destination集合中去。

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

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

時間複雜度:: O(1)
返回值:: 若是 member元素被成功移除，返回 1。

若是 member元素不是 source集合的成員，而且沒有任何操做對 destination集合執行，那麼返回 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被視爲空集。

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

時間複雜度:: O(N * M)， N爲給定集合當中基數最小的集合， M爲給定集合的個數。
返回值:: 交集成員的列表。

SINTERSTORE

SINTERSTORE destination key [key ...]

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

若是destination集合已經存在，則將其覆蓋。

destination能夠是key自己。

時間複雜度:: O(N * M)， N爲給定集合當中基數最小的集合， M爲給定集合的個數。
返回值:: 結果集中的成員數量。

SUNION

SUNION key [key ...]

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

不存在的key被視爲空集。

時間複雜度:: O(N)， N是全部給定集合的成員數量之和。
返回值:: 並集成員的列表。

SUNIONSTORE

SUNIONSTORE destination key [key ...]

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

若是destination已經存在，則將其覆蓋。

destination能夠是key自己。

時間複雜度:: O(N)， N是全部給定集合的成員數量之和。
返回值:: 結果集中的元素數量。

SDIFF

SDIFF key [key ...]

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

不存在的key被視爲空集。

時間複雜度:: O(N)， N是全部給定集合的成員數量之和。
返回值:: 交集成員的列表。

SDIFFSTORE

SDIFFSTORE destination key [key ...]

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

若是destination集合已經存在，則將其覆蓋。

destination能夠是key自己。

時間複雜度:: O(N)， N是全部給定集合的成員數量之和。
返回值:: 結果集中的元素數量。

有序集(Sorted Set)

ZADD

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

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

若是某個member已是有序集的成員，那麼更新這個member的score值，並經過從新插入這個member元素，來保證該member在正確的位置上。

score值能夠是整數值或雙精度浮點數。

若是key不存在，則建立一個空的有序集並執行ZADD操做。

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

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

時間複雜度:: O(M*log(N))， N是有序集的基數， M爲成功添加的新成員的數量。
返回值:: 被成功添加的新成員的數量，不包括那些被更新的、已經存在的成員。

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

ZREM

ZREM key member [member ...]

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

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

時間複雜度:: O(M*log(N))， N爲有序集的基數， M爲被成功移除的成員的數量。
返回值:: 被成功移除的成員的數量，不包括被忽略的成員。

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

ZCARD

ZCARD key

返回有序集key的基數。

時間複雜度:: O(1)
返回值:: 當 key存在且是有序集類型時，返回有序集的基數。

當 key不存在時，返回 0。

ZCOUNT

ZCOUNT key min max

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

關於參數min和max的詳細使用方法，請參考ZRANGEBYSCORE命令。

時間複雜度:: O(log(N)+M)， N爲有序集的基數， M爲值在 min和 max之間的元素的數量。
返回值:: score值在 min和 max之間的成員的數量。

ZSCORE

ZSCORE key member

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

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

時間複雜度:: O(1)
返回值:: member成員的 score值，以字符串形式表示。

ZINCRBY

ZINCRBY key increment member

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

你也能夠經過傳遞一個負數值increment，讓score減去相應的值，好比ZINCRBY key -5 member，就是讓member的score值減去5。

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

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

score值能夠是整數值或雙精度浮點數。

時間複雜度:: O(log(N))
返回值:: member成員的新 score值，以字符串形式表示。

ZRANGE

ZRANGE key start stop [WITHSCORES]

返回有序集key中，指定區間內的成員。

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

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

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

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

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

      超出範圍的下標並不會引發錯誤。 
    
      好比說，當 
     start的值比有序集的最大下標還要大，或是 
     start > stop時，ZRANGE命令只是簡單地返回一個空列表。 
    
      另外一方面，假如 
     stop參數的值比有序集的最大下標還要大，那麼Redis將 
     stop看成最大下標來處理。

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

客戶端庫可能會返回一些更復雜的數據類型，好比數組、元組等。

時間複雜度:: O(log(N)+M)， N爲有序集的基數，而 M爲結果集的基數。
返回值:: 指定區間內，帶有 score值(可選)的有序集成員的列表。

ZREVRANGE

ZREVRANGE key start stop [WITHSCORES]

返回有序集key中，指定區間內的成員。

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

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

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

時間複雜度:: O(log(N)+M)， N爲有序集的基數，而 M爲結果集的基數。
返回值:: 指定區間內，帶有 score值(可選)的有序集成員的列表。

ZRANGEBYSCORE

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

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

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

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

可選的 WITHSCORES參數決定結果集是單單返回有序集的成員，仍是將有序集成員及其 score值一塊兒返回。

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

區間及無限

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

默認狀況下，區間的取值使用閉區間(小於等於或大於等於)，你也能夠經過給參數前增長(符號來使用可選的開區間(小於或大於)。

舉個例子：

返回全部符合條件1 < score <= 5的成員；

返回全部符合條件5 < score < 10的成員。

時間複雜度:: O(log(N)+M)， N爲有序集的基數， M爲被結果集的基數。
返回值:: 指定區間內，帶有 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爲有序集的基數， M爲結果集的基數。
返回值:: 指定區間內，帶有 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)區間內的全部成員。

區間分別如下標參數start和stop指出，包含start和stop在內。

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

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

時間複雜度:: O(log(N)+M)， N爲有序集的基數，而 M爲被移除成員的數量。
返回值:: 被移除成員的數量。

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE key min max

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

自版本2.1.6開始，score值等於min或max的成員也能夠不包括在內，詳情請參見ZRANGEBYSCORE命令。

時間複雜度:: O(log(N)+M)， N爲有序集的基數，而 M爲被移除成員的數量。
返回值:: 被移除成員的數量。

ZINTERSTORE

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

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

默認狀況下，結果集中某個成員的score值是全部給定集下該成員score值之和。

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

時間複雜度:: O(N*K)+O(M*log(M))， N爲給定 key中基數最小的有序集， K爲給定有序集的數量， M爲結果集的基數。
返回值:: 保存到 destination的結果集的基數。

ZUNIONSTORE

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

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

默認狀況下，結果集中某個成員的score值是全部給定集下該成員score值之和。

WEIGHTS

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

若是沒有指定WEIGHTS選項，乘法因子默認設置爲1。

AGGREGATE

使用AGGREGATE選項，你能夠指定並集的結果集的聚合方式。

默認使用的參數SUM，能夠將全部集合中某個成員的score值之和做爲結果集中該成員的score值；使用參數MIN，能夠將全部集合中某個成員的最小score值做爲結果集中該成員的score值；而參數MAX則是將全部集合中某個成員的最大score值做爲結果集中該成員的score值。

時間複雜度:: O(N)+O(M log(M))， N爲給定有序集基數的總和， M爲結果集的基數。
返回值:: 保存到 destination的結果集的基數。

發佈/訂閱(Pub/Sub)

PUBLISH

PUBLISH channel message

將信息 message 發送到指定的頻道 channel 。

時間複雜度：: O(N+M)，其中 N 是頻道 channel 的訂閱者數量，而 M 則是使用模式訂閱(subscribed patterns)的客戶端的數量。
返回值：: 接收到信息 message 的訂閱者數量。

SUBSCRIBE channel [channel ...]

訂閱給定頻道的信息。

時間複雜度：: O(N)，其中 N 是訂閱的頻道的數量。
返回值：: 接收到的信息(請參見下面的代碼說明)。

PSUBSCRIBE

PSUBSCRIBE pattern [pattern ...]

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

每一個模式以 * 做爲匹配符，好比 huangz* 匹配全部以 huangz 開頭的頻道( huangzmsg 、 huangz-blog 、 huangz.tweets 等等)， news.* 匹配全部以 news. 開頭的頻道(news.it 、 news.global.today 等等)，諸如此類。

時間複雜度：: O(N)， N 是訂閱的模式的數量。
返回值：: 接收到的信息(請參見下面的代碼說明)。

UNSUBSCRIBE

警告:此命令在新版 Redis 中彷佛已經被廢棄？

PUNSUBSCRIBE

警告:此命令在新版 Redis 中彷佛已經被廢棄？

事務(Transaction)

WATCH

ATCH key [key ...]

監視一個(或多個) key ，若是在事務執行以前這個(或這些) key 被其餘命令所改動，那麼事務將被打斷。

時間複雜度：: O(1)。
返回值：: 老是返回 OK 。

UNWATCH

UNWATCH

取消 WATCH 命令對全部 key 的監視。

若是在執行 WATCH 命令以後， EXEC 命令或 DISCARD 命令先被執行了的話，那麼就不須要再執行 UNWATCH 了。

由於 EXEC 命令會執行事務，所以 WATCH 命令的效果已經產生了；而 DISCARD 命令在取消事務的同時也會取消全部對 key 的監視，所以這兩個命令執行以後，就沒有必要執行 UNWATCH 了。

時間複雜度：: O(1)
返回值：: 老是 OK 。

MULTI

MULTI

標記一個事務塊的開始。

事務塊內的多條命令會按照前後順序被放進一個隊列當中，最後由 EXEC 命令在一個原子時間內執行。

時間複雜度：: O(1)。
返回值：: 老是返回 OK 。

EXEC

EXEC

執行全部事務塊內的命令。

假如某個(或某些) key 正處於 WATCH 命令的監視之下，且事務塊中有和這個(或這些) key 相關的命令，那麼 EXEC 命令只在這個(或這些) key 沒有被其餘命令所改動的狀況下執行並生效，不然該事務被打斷(abort)。

時間複雜度：: 事務塊內全部命令的時間複雜度的總和。
返回值：: 事務塊內全部命令的返回值，按命令執行的前後順序排列。

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

DISCARD

DISCARD

取消事務，放棄執行事務塊內的全部命令。

若是正在使用 WATCH 命令監視某個(或某些) key ，那麼取消全部監視，等同於執行命令 UNWATCH 。

時間複雜度：: O(1)。
返回值：: 老是返回 OK 。

鏈接(Connection)

AUTH

AUTH password

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

若是開啓了密碼保護的話，在每次鏈接 Redis 服務器以後，就要使用 AUTH 命令解鎖，解鎖以後才能使用其餘 Redis 命令。

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

反之，若是密碼不匹配的話，服務器將返回一個錯誤，並要求客戶端需從新輸入密碼。

警告:由於 Redis 高性能的特色，在很短期內嘗試猜想很是多個密碼是有可能的，所以請確保使用的密碼足夠複雜和足夠長，以避免遭受密碼猜想攻擊。

時間複雜度：: O(1)
返回值：: 密碼匹配時返回 OK ，不然返回一個錯誤。

PING

PING

客戶端向服務器發送一個 PING ，而後服務器返回客戶端一個 PONG 。

一般用於測試與服務器的鏈接是否仍然生效，或者用於測量延遲值。

時間複雜度：: O(1)
返回值：: PONG

SELECT

SELECT index

切換到指定的數據庫，數據庫索引號用數字值指定，以 0 做爲起始索引值。

新的連接老是使用 0 號數據庫。

時間複雜度：: O(1)
返回值：: OK

ECHO

ECHO message

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

時間複雜度：: O(1)
返回值：: message 自身。

QUIT

QUIT

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

一旦全部等待中的回覆(若是有的話)順利寫入到客戶端，鏈接就會被關閉。

時間複雜度：: O(1)
返回值：: 老是返回 OK (可是不會被打印顯示，由於當時 Redis-cli 已經退出)。

服務器(Server)

BGREWRITEAOF

BGREWRITEAOF

異步(Asynchronously)重寫 AOF 文件以反應當前數據庫的狀態。

即便 BGREWRITEAOF 命令執行失敗，舊 AOF 文件中的數據也不會所以丟失或改變。

時間複雜度：: O(N)， N 爲要追加到 AOF 文件中的數據數量。
返回值：: 反饋信息。

BGSAVE

在後臺異步保存當前數據庫的數據到磁盤。

BGSAVE 命令執行以後當即返回 OK ，而後 Redis fork出一個新子進程，原來的 Redis 進程(父進程)繼續處理客戶端請求，而子進程則負責將數據保存到磁盤，而後退出。

客戶端能夠經過 LASTSAVE 命令查看相關信息，判斷 BGSAVE 命令是否執行成功。

時間複雜度：: O(N)， N 爲要保存到數據庫中的 key 的數量。
返回值：: 反饋信息。

SAVE

SAVE

同步保存當前數據庫的數據到磁盤。

時間複雜度：: O(N)， N 爲要保存到數據庫中的 key 的數量。
返回值：: 老是返回 OK 。

LASTSAVE

LASTSAVE

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

時間複雜度：: O(1)
返回值：: 一個 UNIX 時間戳。

DBSIZE

DBSIZE

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

時間複雜度：: O(1)
返回值：: 當前數據庫的 key 的數量。

SLAVEOF

SLAVEOF host port

SLAVEOF 命令用於在 Redis 運行時動態地修改複製(replication)功能的行爲。

經過執行 SLAVEOF host port 命令，能夠將當前服務器轉變爲指定服務器的從屬服務器(slave server)。

若是當前服務器已是某個主服務器(master server)的從屬服務器，那麼執行 SLAVEOF host port 將使當前服務器中止對舊主服務器的同步，丟棄舊數據集，轉而開始對新主服務器進行同步。

另外，對一個從屬服務器執行命令 SLAVEOF NO ONE 將使得這個從屬服務器關閉複製功能，並從從屬服務器轉變回主服務器，原來同步所得的數據集不會被丟棄。

利用「 SLAVEOF NO ONE 不會丟棄同步所得數據集」這個特性，能夠在主服務器失敗的時候，將從屬服務器用做新的主服務器，從而實現無間斷運行。

時間複雜度：: SLAVEOF host port ，O(N)， N 爲要同步的數據數量。

SLAVEOF NO ONE ， O(1) 。
返回值：: 老是返回 OK 。

FLUSHALL

FLUSHALL

清空整個 Redis 服務器的數據(刪除全部數據庫的全部 key)。

此命令從不失敗。

時間複雜度：: 還沒有明確
返回值：: 老是返回 OK 。

FLUSHDB

FLUSHDB

清空當前數據庫中的全部 key 。

此命令從不失敗。

時間複雜度：: O(1)
返回值：: 老是返回 OK 。

SHUTDOWN

SHUTDOWN

SHUTDOWN 命令執行如下操做：

中止全部客戶端
若是有最少一個保存點在等待，執行 SAVE 命令
若是 AOF 選項被打開，更新 AOF 文件
服務器關閉

若是持久化被打開的話， SHUTDOWN 命令會保證服務器正常關閉而不丟失任何數據。

假如只是單純地執行 SAVE 命令，而後再執行 QUIT 命令，則沒有這一保證 —— 由於在執行 SAVE 以後、執行 QUIT 以前的這段時間中間，其餘客戶端可能正在和服務器進行通信，這時若是執行 QUIT 就會形成數據丟失。

時間複雜度：: 不明確
返回值：: 執行失敗時返回錯誤。

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

SLOWLOG

SLOWLOG subcommand [argument]

什麼是 SLOWLOG

Slow log 是 Redis 用來記錄查詢執行時間的日誌系統。

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

另外，slow log 保存在內存裏面，讀寫速度很是快，所以你能夠放心地使用它，沒必要擔憂由於開啓 slow log 而損害 Redis 的速度。

設置 SLOWLOG

Slow log 的行爲由兩個配置參數(configuration parameter)指定，能夠經過改寫 redis.conf 文件或者用 CONFIG GET 和 CONFIG SET 命令對它們動態地進行修改。

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

好比執行如下命令將讓 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 則只打印指定數量的日誌。

最新的日誌會最早被打印：

日誌的惟一 id 只有在 Redis 服務器重啓的時候纔會重置，這樣能夠避免對日誌的重複處理(好比你可能會想在每次發現新的慢查詢時發郵件通知你)。

查看當前日誌的數量

使用命令 SLOWLOG LEN 能夠查看當前日誌的數量。

請注意這個值和 slower-max-len 的區別，它們一個是當前日誌的數量，一個是容許記錄的最大日誌的數量。

清空日誌

使用命令 SLOWLOG RESET 能夠清空 slow log 。

時間複雜度：O(1)

返回值：取決於不一樣命令，返回不一樣的值。

INFO

INFO

返回關於 Redis 服務器的各類信息和統計值。

時間複雜度：: O(1)
返回值：: 具體請參見下面的測試代碼。

CONFIG GET

CONFIG GET parameter

CONFIG GET 命令用於取得運行中的 Redis 服務器的配置參數(configuration parameters)，不過並不是全部配置參數都被 CONFIG GET 命令所支持。

CONFIG GET 接受單個參數 parameter 做爲搜索關鍵字，查找全部匹配的配置參數，其中參數和值以「鍵-值對」(key-value pairs)的方式排列。

好比執行 CONFIG GET s* 命令，服務器就會返回全部以 s 開頭的配置參數及參數的值：

若是你只是尋找特定的某個參數的話，你固然也能夠直接指定參數的名字：

使用命令 CONFIG GET * ，能夠列出 CONFIG GET 命令支持的全部參數：

全部被 CONFIG SET 所支持的配置參數均可以在配置文件 redis.conf 中找到，不過 CONFIG GET 和 CONFIG SET 使用的格式和 redis.conf 文件所使用的格式有如下兩點不一樣：

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

像 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 參數的三個值表示：在 900 秒內最少有 1 個 key 被改動，或者 300 秒內最少有 10 個 key 被改動，又或者 60 秒內最少有 1000 個 key 被改動，以上三個條件隨便知足一個，就觸發一次保存操做。

時間複雜度：: 不明確
返回值：: 給定配置參數的值。