phpredis是redis的php的一個擴展，效率是相當高有鏈表排序功能，對創(chuàng)建內存級的模塊業(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ù)結構內的元素數(shù)量。
返回值：
? ? 被移除key的數(shù)量。


?








//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 *命中數(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)。


?








//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


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


時間復雜度：
? ? O(1)
返回值：
? ? 當數(shù)據(jù)庫不為空時，返回一個key。
? ? 當數(shù)據(jù)庫為空時，返回nil。


?








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


# 情況2：數(shù)據(jù)庫為空
$redis->flushdb(); ?# 刪除當前數(shù)據(jù)庫全部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


將當前數(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。










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


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


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


# 情況3：當源數(shù)據(jù)庫和目標數(shù)據(jù)庫有同樣的key時


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


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


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


$redis->SELECT(1);
echo $redis->GET('favorite_fruit'); ? # 數(shù)據(jù)庫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命令接受的時間參數(shù)是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)或者了解為了節(jié)省空間而對key使用特殊編碼的情況。
當將Redis用作緩存程序時，你也能夠通過OBJECT命令中的信息，決定key的驅趕策略(eviction policies)。


OBJECT命令有多個子命令：


? ? OBJECT REFCOUNT <key>返回給定key引用所儲存的值的次數(shù)。此命令主要用于除錯。
? ? OBJECT ENCODING <key>返回給定key鎖儲存的值所使用的內部表示(representation)。
? ? OBJECT IDLETIME <key>返回給定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返回對應的編碼類型。










//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)狀態(tài) ?//return WOW
//echo $redis->OBJECT('IDLETIME','game'); ?# 不再處于空轉 //(integer) 0
var_dump($redis->OBJECT('ENCODING','game')); ?# 字符串的編碼方式 //string(3) "raw"
$redis->SET('phone',15820123123); ?# 大的數(shù)字也被編碼為字符串
var_dump($redis->OBJECT('ENCODING','phone')); //string(3) "raw"
$redis->SET('age',20); ?# 短數(shù)字被編碼為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]


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


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中經過排序的元素。


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


?


一般SORT使用方法


最簡單的SORT用法是SORT key。


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


?








# 將數(shù)據(jù)一一增加到列表中
$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" }










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








# 將數(shù)據(jù)一一增加到列表中
$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環(huán)境變量的話，Redis能識別UTF-8編碼。
排序之后返回的元素數(shù)量能夠通過LIMIT修飾符進行限制。
LIMIT修飾符接受兩個參數(shù)：offset和count。
offset指定要跳過的元素數(shù)量，count指定跳過offset個指定的元素之后，要返回多少個對象。


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








# 將數(shù)據(jù)一一增加到列表中
$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)數(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中。








# 先將要使用的數(shù)據(jù)增加到數(shù)據(jù)庫中


# 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相應的username，這樣更友好一點，使用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。


比方你不但希望獲取username，還希望連用戶的password也一并列出，能夠使用下面命令：


?








# 先加入一些測試數(shù)據(jù)
$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" ? ? ? # username
#2) "hey,im in" ? ?# password
#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另一個特殊的規(guī)則——"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參數(shù)，不排序，僅僅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作為參數(shù)，排序結果將以列表的形式被保存到這個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操作。


有時候為了正確實現(xiàn)這一使用方法，你可能須要加鎖以避免多個client同一時候進行緩存重建(也就是多個client，同一時間進行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"










?


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


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


時間復雜度：
? ? O(N+M*log(M))，N為要排序的列表或集合內的元素數(shù)量，M為要返回的元素數(shù)量。
? ? 假設僅僅是使用SORT命令的GET選項獲取數(shù)據(jù)而沒有進行排序，時間復雜度O(N)。
返回值：
? ? 沒有使用STORE參數(shù)，返回列表形式的排序結果。
? ? 使用STORE參數(shù)，返回排序結果的元素數(shù)量。


?
字符串(String)


SET


SET key value


將字符串值value關聯(lián)到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)。比方說，要對keyword(key)foo加鎖，client能夠嘗試下面方式：


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


假設SETNX返回1，說明client已經獲得了鎖，key設置的unix時間則指定了鎖失效的時間。之后client能夠通過DEL lock.foo來釋放鎖。


假設SETNX返回0，說明key已經被其它client上鎖了。假設鎖是非堵塞(non blocking lock)的，我們能夠選擇返回調用，或者進入一個重試循環(huán)，直到成功獲得鎖或重試超時(timeout)。


處理死鎖(deadlock)


上面的鎖算法有一個問題：假設由于client失敗、崩潰或其它原因導致沒有辦法釋放鎖的話，怎么辦？


這樣的狀況能夠通過檢測發(fā)現(xiàn)——由于上鎖的key保存的是unix時間戳，假如key值的時間戳小于當前的時間戳，表示鎖已經不再有效。


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


? ? C1和C2讀取lock.foo并檢查時間戳，SETNX都返回0，由于它已經被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兩個都獲得了鎖。


幸好，下面算法能夠避免以上問題。來看看我們聰明的C4client怎么辦：


? ? C4向lock.foo發(fā)送SETNX命令。
? ? 由于崩潰掉的C3還鎖著lock.foo，所以Redis向C4返回0。
? ? C4向lock.foo發(fā)送GET命令，查看lock.foo的鎖是否過期。假設不，則休眠(sleep)一段時間，并在之后重試。
? ? 還有一方面，假設lock.foo內的unix時間戳比當前時間戳老，C4運行下面命令：


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


? ? 由于GETSET的作用，C4能夠檢查看GETSET的返回值，確定lock.foo之前儲存的舊值仍是那個過期時間戳，假設是的話，那么C4獲得鎖。
? ? 假設其它client，比方C5，比C4更快地運行了GETSET操作并獲得鎖，那么C4的GETSET操作返回的就是一個未過期的時間戳(C5設置的時間戳)。C4僅僅好從第一步開始重試。


注意，即便C4的GETSET操作對key進行了改動，這對未來也沒什么影響。
(這里是不是有點問題？C4的確是能夠重試，但C5怎么辦？它的鎖的過期被C4改動了。——譯注)


? ? ?警告


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


?


SETEX
SETEX key seconds value


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


假設key 已經存在，SETEX命令將覆寫舊值。


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


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 設置成功時返回OK。
? ? 當seconds參數(shù)不合法時，返回一個錯誤。










# 情況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參數(shù)覆寫(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參數(shù)的長度。
返回值：
? ? 被SETRANGE改動之后，字符串的長度。


? ? ?警告


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


模式


由于有了SETRANGE和GETRANGE命令，你能夠將Redis字符串用作具有O(1)隨機訪問時間的線性數(shù)組。這在非常多真有用例中都是非常高速且高效的儲存方式。








# 情況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對。


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


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


時間復雜度：
? ? O(N)，N為要設置的key數(shù)量。
返回值：
? ? 總是返回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的數(shù)量。
返回值：
? ? 當全部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所關聯(lián)的字符串值。


假設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在內)。


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


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>'; ?# 負數(shù)索引 //"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組合使用，實現(xiàn)一個有原子性(atomic)復位操作的計數(shù)器(counter)。


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


能夠用命令GETSET mycounter 0來實現(xiàn)這一目標。








$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中儲存的數(shù)字值增一。


假設key不存在，以0為key的初始值，然后運行INCR操作。


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 運行INCR命令之后key的值。


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


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




INCRBY


INCRBY key increment


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


假設key不存在，以0為key的初始值，然后運行INCRBY命令。


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


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 加上increment之后，key的值。










//INCRBY
echo '<br><br>INCRBY<br>';
# 情況1：key存在且是數(shù)字值
$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不是數(shù)字值
$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中儲存的數(shù)字值減一。


假設key不存在，以0為key的初始值，然后運行DECR操作。


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


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 運行DECR命令之后key的值。










//DECR
$redis->SELECT(3);
$redis->flushdb();
echo '<br><br>DECR<br>';
# 情況1：對存在的數(shù)字值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：對存在但不是數(shù)值的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操作。


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


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 減去decrement之后，key的值。










# 情況1：對存在的數(shù)值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參數(shù)，能夠是0也能夠是1。


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


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


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


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


? ? 警告:對使用大的offset的SETBIT操作來說，內存分配可能造成Redisserver被堵塞。詳細參考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不存在，一個新的哈希表被創(chuàng)建并進行HSET操作。


假設域field已經存在于哈希表中，舊值將被覆蓋。


時間復雜度：
? ? O(1)
返回值：
? ? 假設field是哈希表中的一個新建域，而且值設置成功，返回1。
? ? 假設哈希表中域field已經存在且舊值已被新值覆蓋，返回0。


?
HSETNX


HSETNX key field value


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


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


假設key不存在，一個新哈希表被創(chuàng)建并運行HSETNX命令。


時間復雜度：
? ? O(1)
返回值：
? ? 設置成功，返回1。
? ? 假設給定域已經存在且沒有操作被運行，返回0。


?
HMSET


HMSET key field value [field value ...]


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


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


假設key不存在，一個空哈希表被創(chuàng)建并運行HMSET操作。


時間復雜度：
? ? O(N)，N為field - value對的數(shù)量。
返回值：
? ? 假設命令運行成功，返回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每次僅僅能刪除單個域，假設你須要在一個原子時間內刪除多個域，請將命令包括在MULTI/ EXEC塊內。


?
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)建并運行HINCRBY命令。


假設域field不存在，那么在運行命令前，域的值被初始化為0。


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


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


時間復雜度：
? ? 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不存在，一個空列表會被創(chuàng)建并運行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不存在，一個空列表會被創(chuàng)建并運行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命令堵塞，直到等待超時或發(fā)現(xiàn)可彈出元素為止。


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


非堵塞行為


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


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


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


BLPOP job command request 0


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


?


?


堵塞行為


假設全部給定key都不存在或包括空列表，那么BLPOP命令將堵塞連接，直到等待超時，或有還有一個client對給定key的隨意一個運行LPUSH或RPUSH命令為止。


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


?


?


同樣的key被多個client同一時候堵塞
同樣的key能夠被多個client同一時候堵塞。
不同的client被放進一個隊列中，按”先堵塞先服務”(first-BLPOP，first-served)的順序為key運行BLPOP命令。


在MULTI/EXEC事務中的BLPOP


BLPOP能夠用于流水線(pipline,批量地發(fā)送多個命令并讀入多個回復)，但把它用在MULTI/EXEC塊其中沒有意義。由于這要求整個server被堵塞以保證塊運行時的原子性，該行為阻止了其它client運行LPUSH或RPUSH命令。


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


?


?


時間復雜度：O(1)返回值：
假設列表為空，返回一個nil。
反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的key，第二個元素是被彈出元素的值。


?


?
BRPOP


BRPOP key [key ...] timeout


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


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


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


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


時間復雜度：
? ? O(1)
返回值：
? ? 假如在指定時間內沒有不論什么元素被彈出，則返回一個nil和等待時長。
? ? 反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的key，第二個元素是被彈出元素的值。


?
LLEN


LLEN key


返回列表key的長度。


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


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


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


?
LRANGE


LRANGE key start stop


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


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


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


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


假如你有一個包括一百個元素的列表，對該列表運行LRANGE list 0 10，結果是一個包括11個元素的列表，這表明stop下標也在LRANGE命令的取值范圍之內(閉區(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ū)間內元素的數(shù)量。
返回值:
? ? 一個列表，包括指定區(qū)間內的元素。


?
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ū)間內的元素，不在指定區(qū)間之內的元素都將被刪除。


舉個樣例，運行命令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ù)的差別


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


超出范圍的下標


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


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


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


時間復雜度:
? ? O(N)，N為被移除的元素的數(shù)量。
返回值:
? ? 命令運行成功時，返回ok。


?


?
LINDEX


LINDEX key index


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


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


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


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


時間復雜度：
? ? O(N)，N為到達下標index過程中經過的元素數(shù)量。
? ? 因此，對列表的頭元素和尾元素運行LINDEX命令，復雜度為O(1)。
返回值:
? ? 列表中下標為index的元素。
? ? 假設index參數(shù)的值不在列表的區(qū)間范圍內(out of range)，返回nil。


?
LINSERT


LINSERT key BEFORE|AFTER pivot value


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


當pivot不存在于列表key時，不運行不論什么操作。


當key不存在時，key被視為空列表，不運行不論什么操作。


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


時間復雜度:
? ? O(N)，N為尋找pivot過程中經過的元素數(shù)量。
返回值:
? ? 假設命令運行成功，返回插入操作完畢之后，列表的長度。
? ? 假設沒有找到pivot，返回-1。
? ? 假設key不存在或為空列表，返回0。


?


?
RPOPLPUSH


RPOPLPUSH source destination


命令RPOPLPUSH在一個原子時間內，運行下面兩個動作：


? ? ? ? 將列表source中的最后一個元素(尾元素)彈出，并返回給client。
? ? ? ? 將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)程序能夠通過監(jiān)視備份表，將超過一定處理時限的消息又一次放入隊列中去(負責處理該消息的消費者可能已經崩潰)，這樣就不會丟失不論什么消息了。


?
BRPOPLPUSH


BRPOPLPUSH source destination timeout


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


當列表source為空時，BRPOPLPUSH命令將堵塞連接，直到等待超時，或有還有一個client對source運行LPUSH或RPUSH命令為止。


超時參數(shù)timeout接受一個以秒為單位的數(shù)字作為值。超時參數(shù)設為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中都出現(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其中，已經存在于集合的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命令不運行不論什么操作，僅返回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被視為空集。


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


時間復雜度:
? ? O(N * M)，N為給定集合其中基數(shù)最小的集合，M為給定集合的個數(shù)。
返回值:
? ? 交集成員的列表。


?


?
SINTERSTORE


SINTERSTORE destination key [key ...]


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


假設destination集合已經存在，則將其覆蓋。


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已經存在，則將其覆蓋。


destination能夠是key本身。


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


?


?
SDIFF


SDIFF key [key ...]


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


不存在的key被視為空集。


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


?


?
SDIFFSTORE


SDIFFSTORE destination key [key ...]


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


假設destination集合已經存在，則將其覆蓋。


destination能夠是key本身。


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


?


?
有序集(Sorted Set)
ZADD


?


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


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


假設某個member已經是有序集的成員，那么更新這個member的score值，并通過又一次插入這個member元素，來保證該member在正確的位置上。


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


假設key不存在，則創(chuàng)建一個空的有序集并運行ZADD操作。


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


對有序集的很多其它介紹請參見sorted set。


時間復雜度:
? ? O(M*log(N))，N是有序集的基數(shù)，M為成功加入的新成員的數(shù)量。
返回值:
? ? 被成功加入的新成員的數(shù)量，不包含那些被更新的、已經存在的成員。


?


? ? ?


? ? 注解:在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ū)間內的成員。


當中成員的位置按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的格式表示。
client庫可能會返回一些更復雜的數(shù)據(jù)類型，比方數(shù)組、元組等。


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


?
ZREVRANGE


ZREVRANGE key start stop [WITHSCORES]


返回有序集key中，指定區(qū)間內的成員。
當中成員的位置按score值遞減(從大到小)來排列。
具有同樣score值的成員按字典序的反序(reverse lexicographical order)排列。


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


時間復雜度:
? ? O(log(N)+M)，N為有序集的基數(shù)，而M為結果集的基數(shù)。
返回值:
? ? 指定區(qū)間內，帶有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ū)間內，帶有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ū)間內，帶有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ū)間內的全部成員。


區(qū)間分別下面標參數(shù)start和stop指出，包括start和stop在內。
下標參數(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的成員也能夠不包含在內，詳情請參見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ù)。


?


?
公布/訂閱(Pub/Sub)
PUBLISH


PUBLISH channel message


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


時間復雜度：
? ? O(N+M)，當中 N 是頻道 channel 的訂閱者數(shù)量，而 M 則是使用模式訂閱(subscribed patterns)的client的數(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 中似乎已經被廢棄？


PUNSUBSCRIBE


? ? 警告:此命令在新版 Redis 中似乎已經被廢棄？


?
事務(Transaction)
WATCH


ATCH key [key ...]


監(jiān)視一個(或多個) key ，假設在事務運行之前這個(或這些) key 被其它命令所修改，那么事務將被打斷。


時間復雜度：
? ? O(1)。
返回值：
? ? 總是返回 OK 。


?
UNWATCH


UNWATCH


取消 WATCH 命令對全部 key 的監(jiān)視。


假設在運行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被運行了的話，那么就不須要再運行 UNWATCH 了。


由于 EXEC 命令會運行事務，因此 WATCH 命令的效果已經產生了；而 DISCARD 命令在取消事務的同一時候也會取消全部對 key 的監(jiān)視，因此這兩個命令運行之后，就沒有必要運行 UNWATCH 了。


時間復雜度：
? ? O(1)
返回值：
? ? 總是 OK 。


?
MULTI


MULTI


標記一個事務塊的開始。


事務塊內的多條命令會依照先后順序被放進一個隊列其中，最后由 EXEC 命令在一個原子時間內運行。


時間復雜度：
? ? O(1)。
返回值：
? ? 總是返回 OK 。


?


?
EXEC


EXEC


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


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


時間復雜度：
? ? 事務塊內全部命令的時間復雜度的總和。
返回值：
? ? 事務塊內全部命令的返回值，按命令運行的先后順序排列。
? ? 當操作被打斷時，返回空值 nil 。


?


?
DISCARD


DISCARD


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


假設正在使用 WATCH 命令監(jiān)視某個(或某些) key ，那么取消全部監(jiān)視，等同于運行命令 UNWATCH 。


時間復雜度：
? ? O(1)。
返回值：
? ? 總是返回 OK 。


?


?
連接(Connection)
AUTH


AUTH password


通過設置配置文件里 requirepass 項的值(使用命令 CONFIG SET requirepass password )，能夠使用密碼來保護 Redis server。


假設開啟了password保護的話，在每次連接 Redis server之后，就要使用 AUTH 命令解鎖，解鎖之后才干使用其它 Redis 命令。


假設 AUTH 命令給定的password password 和配置文件里的password相符的話，server會返回 OK 并開始接受命令輸入。


反之，假設password不匹配的話，server將返回一個錯誤，并要求client需又一次輸入password。


?


? ? 警告:由于 Redis 高性能的特點，在非常短時間內嘗試推測非常多個password是有可能的，因此請確保使用的password足夠復雜和足夠長，以免遭受password推測攻擊。


時間復雜度：
? ? O(1)
返回值：
? ? password匹配時返回 OK ，否則返回一個錯誤。


?
PING


PING


client向server發(fā)送一個 PING ，然后server返回client一個 PONG 。


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


時間復雜度：
? ? 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


請求server關閉與當前client的連接。


一旦全部等待中的回復(假設有的話)順利寫入到client，連接就會被關閉。


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


?


?
server(Server)
BGREWRITEAOF


BGREWRITEAOF


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


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


時間復雜度：
? ? O(N)， N 為要追加到 AOF 文件里的數(shù)據(jù)數(shù)量。
返回值：
? ? 反饋信息。


?
BGSAVE


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


BGSAVE 命令運行之后馬上返回 OK ，然后 Redis fork出一個新子進程，原來的 Redis 進程(父進程)繼續(xù)處理client請求，而子進程則負責將數(shù)據(jù)保存到磁盤，然后退出。


client能夠通過 LASTSAVE 命令查看相關信息，推斷 BGSAVE 命令是否運行成功。


時間復雜度：
? ? O(N)， N 為要保存到數(shù)據(jù)庫中的 key 的數(shù)量。
返回值：
? ? 反饋信息。


?
SAVE


SAVE


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


時間復雜度：
? ? O(N)， N 為要保存到數(shù)據(jù)庫中的 key 的數(shù)量。
返回值：
? ? 總是返回 OK 。


?


?
LASTSAVE


LASTSAVE


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


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


?


?
DBSIZE


DBSIZE


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


時間復雜度：
? ? O(1)
返回值：
? ? 當前數(shù)據(jù)庫的 key 的數(shù)量。


?


?
SLAVEOF


SLAVEOF host port


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


通過運行 SLAVEOF host port 命令，能夠將當前server轉變?yōu)橹付╯erver的從屬server(slave server)。


假設當前server已經是某個主server(master server)的從屬server，那么運行 SLAVEOF host port 將使當前server停止對舊主server的同步，丟棄舊數(shù)據(jù)集，轉而開始對新主server進行同步。


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


利用“ SLAVEOF NO ONE 不會丟棄同步所得數(shù)據(jù)集”這個特性，能夠在主server失敗的時候，將從屬server用作新的主server，從而實現(xiàn)無間斷執(zhí)行。


時間復雜度：
? ? SLAVEOF host port ，O(N)， N 為要同步的數(shù)據(jù)數(shù)量。
? ? SLAVEOF NO ONE ， O(1) 。
返回值：
? ? 總是返回 OK 。


?


?
FLUSHALL


FLUSHALL


清空整個 Redis server的數(shù)據(jù)(刪除全部數(shù)據(jù)庫的全部 key)。


此命令從不失敗。


時間復雜度：
? ? 尚未明白
返回值：
? ? 總是返回 OK 。


?


?
FLUSHDB


FLUSHDB


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


此命令從不失敗。


時間復雜度：
? ? O(1)
返回值：
? ? 總是返回 OK 。


?


?
SHUTDOWN


SHUTDOWN


SHUTDOWN 命令運行下面操作：


? ? 停止全部client
? ? 假設有最少一個保存點在等待，運行 SAVE 命令
? ? 假設 AOF 選項被打開，更新 AOF 文件
? ? server關閉


假設持久化被打開的話， SHUTDOWN 命令會保證server正常關閉而不丟失不論什么數(shù)據(jù)。


假如僅僅是單純地運行 SAVE 命令，然后再運行 QUIT 命令，則沒有這一保證 —— 由于在運行 SAVE 之后、運行 QUIT 之前的這段時間中間，其它client可能正在和server進行通訊，這時假設運行 QUIT 就會造成數(shù)據(jù)丟失。


時間復雜度：
? ? 不明白
返回值：
? ? 運行失敗時返回錯誤。
? ? 運行成功時不返回不論什么信息，server和client的連接斷開，client自己主動退出。


?


?
SLOWLOG


SLOWLOG subcommand [argument]


什么是 SLOWLOG


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


查詢運行時間指的是不包含像client響應(talking)、發(fā)送回復等 IO 操作，而單單是運行一個查詢命令所耗費的時間。


另外，slow log 保存在內存里面，讀寫速度很快，因此你能夠放心地使用它，不必操心由于開啟 slow log 而損害 Redis 的速度。


設置 SLOWLOG


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


第一個選項是 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 則僅僅打印指定數(shù)量的日志。


最新的日志會最先被打印：


?


?


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


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


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


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


?


清空日志


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


?


?


時間復雜度：O(1)


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


?
INFO


INFO


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


時間復雜度：
? ? O(1)
返回值：
? ? 詳細請參見以下的測試代碼。


?


?
CONFIG GET


CONFIG GET parameter


CONFIG GET 命令用于取得執(zhí)行中的 Redis server的配置參數(shù)(configuration parameters)，只是并不是全部配置參數(shù)都被 CONFIG GET 命令所支持。


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


比方運行 CONFIG GET s* 命令，server就會返回全部以 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 秒內最少有 1 個 key 被修改，或者 300 秒內最少有 10 個 key 被修改，又或者 60 秒內最少有 1000 個 key 被修改，以上三個條件隨便滿足一個，就觸發(fā)一次保存操作。


時間復雜度：
? ? 不明白
返回值：
? ? 給定配置參數(shù)的值。


?
CONFIG SET


CONFIG SET parameter value


CONFIG SET 命令能夠動態(tài)地調整 Redis server的配置(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 (運行命令的次數(shù))
? ? Number of connections received (連接server的次數(shù))
? ? Number of expired keys (過期key的數(shù)量)


時間復雜度：
? ? O(1)
返回值：
? ? 總是返回 OK 。


?
DEBUG OBJECT


DEBUG OBJECT key


返回給定 key 的調試信息。


時間復雜度：
? ? O(1)
返回值：
? ? 當 key 存在時，返回有關信息。
? ? 當 key 不存在時，返回一個錯誤。


?
DEBUG SEGFAULT


DEBUG SEGFAULT


令 Redis server崩潰，調試用。


時間復雜度：
? ? 不明白
返回值：
? ? 無


?
MONITOR


MONITOR


實時打印出 Redis server接收到的命令，調試用。


時間復雜度：
? ? 不明白
返回值：
? ? 總是返回 OK 。


?
SYNC


YNC


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


時間復雜度：
? ? 不明白
返回值：
? ? 不明白