phpredis中文手册——《redis中文手册》 php版
redis中文手冊：http://readthedocs.org/docs/redis/en/latest/?
本文是參考《redis中文手冊》，將示例代碼用php來實現，注意php-redis與redis_cli的區別（主要是返回值類型和參數用法）。
目錄(使用CTRL+F快速查找命令)：
|
|
|
|
|
|
|
|
|
|
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不存在，則忽略該命令。
時間復雜度：?
//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) }
?
KEYSKEYS pattern?查找符合給定模式的key。 KEYS?*命中數據庫中所有key。 KEYS?h?llo命中hello，?hallo?and?hxllo等。 KEYS?h*llo命中hllo和heeeeello等。 KEYS?h[ae]llo命中hello和hallo，但不命中hillo。特殊符號用"\"隔開
時間復雜度：警告 :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。
時間復雜度：?
//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)
?
TTLTTL key
返回給定key的剩余生存時間(time to live)(以秒為單位)。
時間復雜度：?
//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)
?
EXISTSEXISTS key檢查給定key是否存在。
時間復雜度：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)原語。
時間復雜度：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命令將覆蓋舊值。
時間復雜度：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不存在時報錯)。
時間復雜度：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"
TYPETYPE key
返回key所儲存的值的類型。
時間復雜度：?
//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)。?
時間復雜度：$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 timestampEXPIREAT的作用和EXPIRE一樣，都用于為key設置生存時間。
不同在于EXPIREAT命令接受的時間參數是UNIX時間戳(unix timestamp)。
時間復雜度：?
//EXPIREATecho '<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->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的生存時間。
?
時間復雜度：?
//PERSISTecho '<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操作和上面介紹的其他數據結構(列表、集合、有序集合)沒有什么不同。
時間復雜度：?
字符串(String)
SET
SET key value將字符串值value關聯到key。
如果key已經持有其他值，SET就覆寫舊值，無視類型。
時間復雜度：O(1)返回值：總是返回OK(TRUE)，因為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)的簡寫。
時間復雜度：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只好從第一步開始重試。
?警告
為了讓這個加鎖算法更健壯，獲得鎖的客戶端應該常常檢查過期時間以免鎖因諸如DEL等命令的執行而被意外解開，因為客戶端失敗的情況非常復雜，不僅僅是崩潰這么簡單，還可能是客戶端因為某些操作被阻塞了相當長時間，緊接著DEL命令被嘗試執行(但這時鎖卻在另外的客戶端手上)。
SETEX SETEX key seconds value將值value關聯到key，并將key的生存時間設為seconds(以秒為單位)。
如果key?已經存在，SETEX命令將覆寫舊值。
這個命令類似于以下兩個命令：
$redis->SET('key', 'value');$redis->EXPIRE('key','seconds'); # 設置生存時間
不同之處是，SETEX是一個原子性(atomic)操作，關聯值和設置生存時間兩個動作會在同一時間內完成，該命令在Redis用作緩存時，非常實用。
時間復雜度：$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。
時間復雜度：?警告
?當生成一個很長的字符串時，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沒有改變的情況，不可能發生。
時間復雜度：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)，所有字段要么全被設置，要么全不被設置。
時間復雜度：$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一樣。
時間復雜度：$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只能用于處理字符串值。
時間復雜度：?
//GETvar_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。因此，該命令永不失敗。
時間復雜度: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)不超過實際字符串的值域來處理超出范圍的值域請求。
時間復雜度：注解:在<=2.0的版本里，GETRANGE被叫作SUBSTR。
//GETRANGEecho '<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存在但不是字符串類型時，返回一個錯誤。
時間復雜度：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儲存的不是字符串值時，返回一個錯誤。
復雜度：echo $redis->STRLEN('mykey'); //int(11)
echo $redis->STRLEN('nonexisting'); # 不存在的key長度視為0 //int(0)
INCR
INCR key將key中儲存的數字值增一。
如果key不存在，以0為key的初始值，然后執行INCR操作。
如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤。
本操作的值限制在64位(bit)有符號數字表示之內。
時間復雜度：注解:這是一個針對字符串的操作，因為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命令。
時間復雜度：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命令。
時間復雜度：$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命令。
時間復雜度：$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內)。
時間復雜度:警告:對使用大的offset的SETBIT操作來說，內存分配可能造成Redis服務器被阻塞。具體參考SETRANGE命令，warning(警告)部分。
//SETBITecho '<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。
時間復雜度：?
哈希表(Hash)
HSET
HSET key field value將哈希表key中的域field的值設為value。
如果key不存在，一個新的哈希表被創建并進行HSET操作。
如果域field已經存在于哈希表中，舊值將被覆蓋。
時間復雜度：?
HSETNX
HSETNX key field value將哈希表key中的域field的值設置為value，當且僅當域field不存在。
若域field已經存在，該操作無效。
如果key不存在，一個新哈希表被創建并執行HSETNX命令。
時間復雜度：?
HMSET
HMSET key field value [field value ...]同時將多個field?-?value(域-值)對設置到哈希表key中。
此命令會覆蓋哈希表中已存在的域。
如果key不存在，一個空哈希表被創建并執行HMSET操作。
時間復雜度：?
?
HGET
HGET key field返回哈希表key中給定域field的值。
時間復雜度：?
HMGET
HMGET key field [field ...]返回哈希表key中，一個或多個給定域的值。
如果給定的域不存在于哈希表，那么返回一個nil值。
因為不存在的key被當作一個空哈希表來處理，所以對一個不存在的key進行HMGET操作將返回一個只帶有nil值的表。
時間復雜度：?
?
HGETALL
HGETALL key返回哈希表key中，所有的域和值。
在返回值里，緊跟每個域名(field name)之后是域的值(value)，所以返回值的長度是哈希表大小的兩倍。
時間復雜度：?
?
HDEL
HDEL key field [field ...]刪除哈希表key中的一個或多個指定域，不存在的域將被忽略。
時間復雜度:注解:在Redis2.4以下的版本里，HDEL每次只能刪除單個域，如果你需要在一個原子時間內刪除多個域，請將命令包含在MULTI/?EXEC塊內。
?
HLEN
HLEN key返回哈希表key中域的數量。
時間復雜度：?
HEXISTS
HEXISTS key field查看哈希表key中，給定域field是否存在。
時間復雜度：?
HINCRBY
HINCRBY key field increment為哈希表key中的域field的值加上增量increment。
增量也可以為負數，相當于對給定域進行減法操作。
如果key不存在，一個新的哈希表被創建并執行HINCRBY命令。
如果域field不存在，那么在執行命令前，域的值被初始化為0。
對一個儲存字符串值的域field執行HINCRBY命令將造成一個錯誤。
本操作的值限制在64位(bit)有符號數字表示之內。
時間復雜度：?
HKEYS
HKEYS key返回哈希表key中的所有域。
時間復雜度：?
HVALS
HVALS key返回哈希表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存在但不是列表類型時，返回一個錯誤。
時間復雜度：?
注解:在Redis 2.4版本以前的LPUSH命令，都只接受單個value值。
?
LPUSHX
LPUSHX key value將值value插入到列表key的表頭，當且僅當key存在并且是一個列表。
和LPUSH命令相反，當key不存在時，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存在但不是列表類型時，返回一個錯誤。
時間復雜度：注解:在Redis 2.4版本以前的RPUSH命令，都只接受單個value值。
?
RPUSHX
RPUSHX key value將值value插入到列表key的表尾，當且僅當key存在并且是一個列表。
和RPUSH命令相反，當key不存在時，RPUSHX命令什么也不做。
時間復雜度：?
LPOP
LPOP key移除并返回列表key的頭元素。
時間復雜度：?
RPOP
RPOP key移除并返回列表key的尾元素。
時間復雜度：?
BLPOP
BLPOP key [key ...] timeoutBLPOP是列表的阻塞式(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 ...] timeoutBRPOP是列表的阻塞式(blocking)彈出原語。
它是RPOP命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，連接將被BRPOP命令阻塞，直到等待超時或發現可彈出元素為止。
當給定多個key參數時，按參數key的先后順序依次檢查各個列表，彈出第一個非空列表的尾部元素。
關于阻塞操作的更多信息，請查看BLPOP命令，BRPOP除了彈出元素的位置和BLPOP不同之外，其他表現一致。
時間復雜度：?
LLEN
LLEN key返回列表key的長度。
如果key不存在，則key被解釋為一個空列表，返回0.
如果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。
時間復雜度:?
LREM
LREM key count value根據參數count的值，移除列表中與參數value相等的元素。
count的值可以是以下幾種：- count?>?0: 從表頭開始向表尾搜索，移除與value相等的元素，數量為count。
- count?<?0: 從表尾開始向表頭搜索，移除與value相等的元素，數量為count的絕對值。
- count?=?0: 移除表中所有與value相等的值。
?
LSET
LSET key index value將列表key下標為index的元素的值甚至為value。
更多信息請參考LINDEX操作。
當index參數超出范圍，或對一個空列表(key不存在)進行LSET時，返回一個錯誤。
時間復雜度：?
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。
時間復雜度:?
?
LINDEX
LINDEX key index返回列表key中，下標為index的元素。
下標(index)參數start和stop都以0為底，也就是說，以0表示列表的第一個元素，以1表示列表的第二個元素，以此類推。
你也可以使用負數下標，以-1表示列表的最后一個元素，-2表示列表的倒數第二個元素，以此類推。
如果key不是列表類型，返回一個錯誤。
時間復雜度：?
LINSERT
LINSERT key BEFORE|AFTER pivot value將值value插入到列表key當中，位于值pivot之前或之后。
當pivot不存在于列表key時，不執行任何操作。
當key不存在時，key被視為空列表，不執行任何操作。
如果key不是列表類型，返回一個錯誤。
時間復雜度:?
?
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)操作。
時間復雜度：?
設計模式： 一個安全的隊列
Redis的列表經常被用作隊列(queue)，用于在不同程序之間有序地交換消息(message)。一個程序(稱之為生產者，producer)通過LPUSH命令將消息放入隊列中，而另一個程序(稱之為消費者，consumer)通過RPOP命令取出隊列中等待時間最長的消息。
不幸的是，在這個過程中，一個消費者可能在獲得一個消息之后崩潰，而未執行完成的消息也因此丟失。
使用RPOPLPUSH命令可以解決這個問題，因為它在返回一個消息之余，還將該消息添加到另一個列表當中，另外的這個列表可以用作消息的備份表：假如一切正常，當消費者完成該消息的處理之后，可以用LREM命令將該消息從備份表刪除。
另一方面，助手(helper)程序可以通過監視備份表，將超過一定處理時限的消息重新放入隊列中去(負責處理該消息的消費者可能已經崩潰)，這樣就不會丟失任何消息了。
?
BRPOPLPUSH
BRPOPLPUSH source destination timeoutBRPOPLPUSH是RPOPLPUSH的阻塞版本，當給定列表source不為空時，BRPOPLPUSH的表現和RPOPLPUSH一樣。
當列表source為空時，BRPOPLPUSH命令將阻塞連接，直到等待超時，或有另一個客戶端對source執行LPUSH或RPUSH命令為止。
超時參數timeout接受一個以秒為單位的數字作為值。超時參數設為0表示阻塞時間可以無限期延長(block indefinitely) 。
更多相關信息，請參考RPOPLPUSH命令。
時間復雜度：?
?
集合(Set)
?附錄，常用集合運算：
? ?A = {'a', 'b', 'c'}
B = {'a', 'e', 'i', 'o', 'u'}
?
SADD
SADD key member [member ...]將一個或多個member元素加入到集合key當中，已經存在于集合的member元素將被忽略。
假如key不存在，則創建一個只包含member元素作成員的集合。
當key不是集合類型時，返回一個錯誤。
時間復雜度:注解:在Redis2.4版本以前，SADD只接受單個member值。
?
?
SREM
SREM key member [member ...]移除集合key中的一個或多個member元素，不存在的member元素會被忽略。
當key不是集合類型，返回一個錯誤。
時間復雜度:注解:在Redis2.4版本以前，SREM只接受單個member值。
?
?
SMEMBERS
SMEMBERS key返回集合key中的所有成員。
時間復雜度:?
?
SISMEMBER
SISMEMBER key member判斷member元素是否是集合key的成員。
時間復雜度:?
?
SCARD
SCARD key返回集合key的基數(集合中元素的數量)。
時間復雜度:?
?
SMOVE
SMOVE source destination member將member元素從source集合移動到destination集合。
SMOVE是原子性操作。
如果source集合不存在或不包含指定的member元素，則SMOVE命令不執行任何操作，僅返回0。否則，member元素從source集合中被移除，并添加到destination集合中去。
當destination集合已經包含member元素時，SMOVE命令只是簡單地將source集合中的member元素刪除。
當source或destination不是集合類型時，返回一個錯誤。
時間復雜度:?
?
SPOP
SPOP key移除并返回集合中的一個隨機元素。
時間復雜度:?
?
也可以參考:如果只想獲取一個隨機元素，但不想該元素從集合中被移除的話，可以使用SRANDMEMBER命令。
?
SRANDMEMBER
SRANDMEMBER key返回集合中的一個隨機元素。
該操作和SPOP相似，但SPOP將隨機元素從集合中移除并返回，而SRANDMEMBER則僅僅返回隨機元素，而不對集合進行任何改動。
時間復雜度:?
?
SINTER
SINTER key [key ...]返回一個集合的全部成員，該集合是所有給定集合的交集。
不存在的key被視為空集。
當給定集合當中有一個空集時，結果也為空集(根據集合運算定律)。
時間復雜度:?
?
SINTERSTORE
SINTERSTORE destination key [key ...]此命令等同于SINTER，但它將結果保存到destination集合，而不是簡單地返回結果集。
如果destination集合已經存在，則將其覆蓋。
destination可以是key本身。
時間復雜度:?
?
SUNION
SUNION key [key ...]返回一個集合的全部成員，該集合是所有給定集合的并集。
不存在的key被視為空集。
時間復雜度:?
?
SUNIONSTORE
SUNIONSTORE destination key [key ...]此命令等同于SUNION，但它將結果保存到destination集合，而不是簡單地返回結果集。
如果destination已經存在，則將其覆蓋。
destination可以是key本身。
時間復雜度:?
?
SDIFF
SDIFF key [key ...]返回一個集合的全部成員，該集合是所有給定集合的差集?。
不存在的key被視為空集。
時間復雜度:?
?
SDIFFSTORE
SDIFFSTORE destination key [key ...]此命令等同于SDIFF，但它將結果保存到destination集合，而不是簡單地返回結果集。
如果destination集合已經存在，則將其覆蓋。
destination可以是key本身。
時間復雜度:?
?
有序集(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。
時間復雜度:?
?
注解:在Redis2.4版本以前，ZADD每次只能添加一個元素。
?
?
ZREM
ZREM key member [member ...]移除有序集key中的一個或多個成員，不存在的成員將被忽略。
當key存在但不是有序集類型時，返回一個錯誤。
時間復雜度:注解：在Redis2.4版本以前，ZREM每次只能刪除一個元素。
?
?
ZCARD
ZCARD key返回有序集key的基數。
時間復雜度:?
ZCOUNT
ZCOUNT key min max返回有序集key中，score值在min和max之間(默認包括score值等于min或max)的成員。
關于參數min和max的詳細使用方法，請參考ZRANGEBYSCORE命令。
時間復雜度:?
ZSCORE
ZSCORE key member返回有序集key中，成員member的score值。
如果member元素不是有序集key的成員，或key不存在，返回nil。
時間復雜度:?
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值可以是整數值或雙精度浮點數。
時間復雜度:?
?
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的格式表示。 客戶端庫可能會返回一些更復雜的數據類型，比如數組、元組等。 時間復雜度:?
ZREVRANGE
ZREVRANGE key start stop [WITHSCORES]返回有序集key中，指定區間內的成員。
其中成員的位置按score值遞減(從大到小)來排列。 具有相同score值的成員按字典序的反序(reverse lexicographical order)排列。除了成員按score值遞減的次序排列這一點外，ZREVRANGE命令的其他方面和ZRANGE命令一樣。
時間復雜度:?
?
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的成員。
時間復雜度:?
?
ZREVRANGEBYSCORE
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]返回有序集key中，score值介于max和min之間(默認包括等于max或min)的所有的成員。有序集成員按score值遞減(從大到小)的次序排列。
具有相同score值的成員按字典序的反序(reverse lexicographical order)排列。
除了成員按score值遞減的次序排列這一點外，ZREVRANGEBYSCORE命令的其他方面和ZRANGEBYSCORE命令一樣。
時間復雜度:?
?
ZRANK
ZRANK key member返回有序集key中成員member的排名。其中有序集成員按score值遞增(從小到大)順序排列。
排名以0為底，也就是說，score值最小的成員排名為0。
使用ZREVRANK命令可以獲得成員按score值遞減(從大到小)排列的排名。
時間復雜度:?
ZREVRANK
ZREVRANK key member返回有序集key中成員member的排名。其中有序集成員按score值遞減(從大到小)排序。
排名以0為底，也就是說，score值最大的成員排名為0。
使用ZRANK命令可以獲得成員按score值遞增(從小到大)排列的排名。
時間復雜度:?
?
ZREMRANGEBYRANK
ZREMRANGEBYRANK key start stop移除有序集key中，指定排名(rank)區間內的所有成員。
區間分別以下標參數start和stop指出，包含start和stop在內。
下標參數start和stop都以0為底，也就是說，以0表示有序集第一個成員，以1表示有序集第二個成員，以此類推。 你也可以使用負數下標，以-1表示最后一個成員，-2表示倒數第二個成員，以此類推。 時間復雜度:?
?
ZREMRANGEBYSCORE
ZREMRANGEBYSCORE key min max移除有序集key中，所有score值介于min和max之間(包括等于min或max)的成員。
自版本2.1.6開始，score值等于min或max的成員也可以不包括在內，詳情請參見ZRANGEBYSCORE命令。
時間復雜度:?
?
ZINTERSTORE
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]計算給定的一個或多個有序集的交集，其中給定key的數量必須以numkeys參數指定，并將該交集(結果集)儲存到destination。
默認情況下，結果集中某個成員的score值是所有給定集下該成員score值之和。
關于WEIGHTS和AGGREGATE選項的描述，參見ZUNIONSTORE命令。
時間復雜度:?
?
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值。
時間復雜度:?
?
發布/訂閱(Pub/Sub)
PUBLISH
PUBLISH channel message將信息?message?發送到指定的頻道?channel?。
時間復雜度：?
?
SUBSCRIBE
SUBSCRIBE channel [channel ...]訂閱給定頻道的信息。
時間復雜度：?
?
PSUBSCRIBE
PSUBSCRIBE pattern [pattern ...]訂閱符合給定模式的頻道。
每個模式以?*?作為匹配符，比如?huangz*?匹配所有以?huangz?開頭的頻道(?huangzmsg?、?huangz-blog?、?huangz.tweets?等等)，?news.*?匹配所有以?news.?開頭的頻道(news.it?、?news.global.today?等等)，諸如此類。
時間復雜度：?
?
UNSUBSCRIBE
警告:此命令在新版 Redis 中似乎已經被廢棄？
PUNSUBSCRIBE
警告:此命令在新版 Redis 中似乎已經被廢棄？
?
事務(Transaction)
WATCH
ATCH key [key ...]監視一個(或多個) key ，如果在事務執行之前這個(或這些) key 被其他命令所改動，那么事務將被打斷。
時間復雜度：?
UNWATCH
UNWATCH
取消?WATCH?命令對所有 key 的監視。
如果在執行?WATCH?命令之后，?EXEC?命令或?DISCARD?命令先被執行了的話，那么就不需要再執行?UNWATCH?了。
因為?EXEC?命令會執行事務，因此?WATCH?命令的效果已經產生了；而?DISCARD?命令在取消事務的同時也會取消所有對 key 的監視，因此這兩個命令執行之后，就沒有必要執行?UNWATCH?了。
時間復雜度：?
MULTI
MULTI
標記一個事務塊的開始。
事務塊內的多條命令會按照先后順序被放進一個隊列當中，最后由?EXEC?命令在一個原子時間內執行。
時間復雜度：?
?
EXEC
EXEC
執行所有事務塊內的命令。
假如某個(或某些) key 正處于?WATCH?命令的監視之下，且事務塊中有和這個(或這些) key 相關的命令，那么?EXEC?命令只在這個(或這些) key 沒有被其他命令所改動的情況下執行并生效，否則該事務被打斷(abort)。
時間復雜度：?
?
DISCARD
DISCARD
取消事務，放棄執行事務塊內的所有命令。
如果正在使用?WATCH?命令監視某個(或某些) key ，那么取消所有監視，等同于執行命令?UNWATCH?。
時間復雜度：?
?
連接(Connection)
AUTH
AUTH password通過設置配置文件中?requirepass?項的值(使用命令?CONFIG?SET?requirepass?password?)，可以使用密碼來保護 Redis 服務器。
如果開啟了密碼保護的話，在每次連接 Redis 服務器之后，就要使用?AUTH?命令解鎖，解鎖之后才能使用其他 Redis 命令。
如果?AUTH?命令給定的密碼?password?和配置文件中的密碼相符的話，服務器會返回?OK?并開始接受命令輸入。
反之，如果密碼不匹配的話，服務器將返回一個錯誤，并要求客戶端需重新輸入密碼。
?
警告:因為 Redis 高性能的特點，在很短時間內嘗試猜測非常多個密碼是有可能的，因此請確保使用的密碼足夠復雜和足夠長，以免遭受密碼猜測攻擊。
時間復雜度：?
PING
PING
客戶端向服務器發送一個?PING?，然后服務器返回客戶端一個?PONG?。
通常用于測試與服務器的連接是否仍然生效，或者用于測量延遲值。
時間復雜度：?
?
SELECT
SELECT index切換到指定的數據庫，數據庫索引號用數字值指定，以?0?作為起始索引值。
新的鏈接總是使用?0?號數據庫。
時間復雜度：?
ECHO
ECHO message打印一個特定的信息?message?，測試時使用。
時間復雜度：?
?
QUIT
QUIT
請求服務器關閉與當前客戶端的連接。
一旦所有等待中的回復(如果有的話)順利寫入到客戶端，連接就會被關閉。
時間復雜度：?
?
服務器(Server)
BGREWRITEAOF
BGREWRITEAOF
異步(Asynchronously)重寫 AOF 文件以反應當前數據庫的狀態。
即使?BGREWRITEAOF?命令執行失敗，舊 AOF 文件中的數據也不會因此丟失或改變。
時間復雜度：?
BGSAVE
在后臺異步保存當前數據庫的數據到磁盤。
BGSAVE?命令執行之后立即返回?OK?，然后 Redis fork出一個新子進程，原來的 Redis 進程(父進程)繼續處理客戶端請求，而子進程則負責將數據保存到磁盤，然后退出。
客戶端可以通過?LASTSAVE?命令查看相關信息，判斷?BGSAVE?命令是否執行成功。
時間復雜度：?
SAVE
SAVE
同步保存當前數據庫的數據到磁盤。
時間復雜度：?
?
LASTSAVE
LASTSAVE
返回最近一次 Redis 成功執行保存操作的時間點(?SAVE?、?BGSAVE?等)，以 UNIX 時間戳格式表示。
時間復雜度：?
?
DBSIZE
DBSIZE
返回當前數據庫的 key 的數量。
時間復雜度：?
?
SLAVEOF
SLAVEOF host portSLAVEOF?命令用于在 Redis 運行時動態地修改復制(replication)功能的行為。
通過執行?SLAVEOF?host?port?命令，可以將當前服務器轉變為指定服務器的從屬服務器(slave server)。
如果當前服務器已經是某個主服務器(master server)的從屬服務器，那么執行?SLAVEOF?host?port?將使當前服務器停止對舊主服務器的同步，丟棄舊數據集，轉而開始對新主服務器進行同步。
另外，對一個從屬服務器執行命令?SLAVEOF?NO?ONE?將使得這個從屬服務器關閉復制功能，并從從屬服務器轉變回主服務器，原來同步所得的數據集不會被丟棄。
利用“?SLAVEOF?NO?ONE?不會丟棄同步所得數據集”這個特性，可以在主服務器失敗的時候，將從屬服務器用作新的主服務器，從而實現無間斷運行。
時間復雜度：?
?
FLUSHALL
FLUSHALL
清空整個 Redis 服務器的數據(刪除所有數據庫的所有 key)。
此命令從不失敗。
時間復雜度：?
?
FLUSHDB
FLUSHDB
清空當前數據庫中的所有 key 。
此命令從不失敗。
時間復雜度：?
?
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 服務器的各種信息和統計值。
時間復雜度：?
?
CONFIG GET
CONFIG GET parameterCONFIG 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 被改動，以上三個條件隨便滿足一個，就觸發一次保存操作。
?
CONFIG SET
CONFIG SET parameter valueCONFIG SET?命令可以動態地調整 Redis 服務器的配置(configuration)而無須重啟。
你可以使用它修改配置參數，或者改變 Redis 的持久化(Persistence)方式。
CONFIG SET?可以修改的配置參數可以使用命令?CONFIG?GET?*?來列出，所有被?CONFIG SET?修改的配置參數都會立即生效。
關于?CONFIG SET?命令的更多消息，請參見命令?CONFIG GET?的說明。
關于如何使用?CONFIG SET?命令修改 Redis 持久化方式，請參見?Redis Persistence?。
時間復雜度：?
CONFIG RESETSTAT
CONFIG RESETSTAT重置?INFO?命令中的某些統計數據，包括：
- Keyspace hits (鍵空間命中次數)
- Keyspace misses (鍵空間不命中次數)
- Number of commands processed (執行命令的次數)
- Number of connections received (連接服務器的次數)
- Number of expired keys (過期key的數量)
?
DEBUG OBJECT
DEBUG OBJECT key返回給定?key?的調試信息。
時間復雜度：?
DEBUG SEGFAULT
DEBUG SEGFAULT令 Redis 服務器崩潰，調試用。
時間復雜度：?
MONITOR
MONITOR
實時打印出 Redis 服務器接收到的命令，調試用。
時間復雜度：?
SYNC
YNC
用于復制功能(replication)的內部命令。
時間復雜度：轉載于:https://www.cnblogs.com/zcy_soft/archive/2012/09/21/2697006.html
總結
以上是生活随笔為你收集整理的phpredis中文手册——《redis中文手册》 php版的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 包有钱上征信吗
- 下一篇： 特斯拉市值破6千亿美元 超3个丰田汽