phpredis中文手冊——《redis中文手冊》 php版

redis中文手冊：http://readthedocs.org/docs/redis/en/latest/

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

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

Key	String	Hash	List	Set
鍵(Key) DEL KEYS RANDOMKEY TTL EXISTS MOVE RENAME RENAMENX TYPE EXPIRE EXPIREAT OBJECT PERSIST SORT	字符串(String) SET SETNX SETEX SETRANGE MSET MSETNX APPEND GET MGET GETRANGE GETSET STRLEN INCR INCRBY DECR DECRBY SETBIT GETBIT	哈希表(Hash) HSET HSETNX HMSET HGET HMGET HGETALL HDEL HLEN HEXISTS HINCRBY HKEYS HVALS	表(List) LPUSH LPUSHX RPUSH RPUSHX LPOP RPOP BLPOP BRPOP LLEN LRANGE LREM LSET LTRIM LINDEX LINSERT RPOPLPUSH BRPOPLPUSH	集合(Set) SADD SREM SMEMBERS SISMEMBER SCARD SMOVE SPOP SRANDMEMBER SINTER SINTERSTORE SUNION SUNIONSTORE SDIFF SDIFFSTORE

Sorted Set	Pub/Sub	Transaction	Connection	Server
有序集(Sorted Set) ZADD ZREM ZCARD ZCOUNT ZSCORE ZINCRBY ZRANGE ZREVRANGE ZRANGEBYSCORE ZREVRANGEBYSCORE ZRANK ZREVRANK ZREMRANGEBYRANK ZREMRANGEBYSCORE ZINTERSTORE ZUNIONSTORE	發佈/訂閱(Pub/Sub) PUBLISH SUBSCRIBE PSUBSCRIBE UNSUBSCRIBE PUNSUBSCRIBE	事務(Transaction) WATCH UNWATCH MULTI EXEC DISCARD	連接(Connection) AUTH PING SELECT ECHO QUIT	服務器(Server) BGREWRITEAOF BGSAVE SAVE LASTSAVE DBSIZE SLAVEOF FLUSHALL FLUSHDB SHUTDOWN SLOWLOG INFO CONFIG GET CONFIG SET CONFIG RESETSTAT DEBUG OBJECT DEBUG SEGFAULT MONITOR SYNC

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

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

下載地址如下：

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

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

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

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

setOption 設置redis模式

getOption 查看redis設置的模式

ping 查看連接狀態

KEY相關操作

DEL

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

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

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

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

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

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

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

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

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

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

特殊符號用"\"隔開

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

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

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

RANDOMKEY

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

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

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

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

TTL TTL key

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

時間複雜度：: O(1)
返回值：: key的剩餘生存時間(以秒爲單位)。
當key不存在或沒有設置生存時間時，返回-1 。

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

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

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

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

EXISTS
EXISTS key

檢查給定key是否存在。

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

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

MOVE
MOVE key db

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

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

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

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

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

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

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

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

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

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

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

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

RENAME

RENAME key newkey

將key改名爲newkey。

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

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

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

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

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

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

RENAMENX

RENAMENX key newkey

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

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

時間複雜度：: O(1)
返回值：: 修改成功時，返回1。
如果newkey已經存在，返回0。

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

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

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

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

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

TYPE
TYPE key

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

時間複雜度：: O(1)
返回值：: none(key不存在) int(0)
string(字符串) int(1)
list(列表) int(3)
set(集合) int(2)
zset(有序集) int(4)
hash(哈希表) int(5)

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

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

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

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

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

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

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

EXPIRE

EXPIRE key seconds

爲給定key設置生存時間。

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

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

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

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

時間複雜度：: O(1)
返回值：: 設置成功返回1。
當key不存在或者不能爲key設置生存時間時(比如在低於2.1.3中你嘗試更新key的生存時間)，返回0。

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

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

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

EXPIREAT
EXPIREAT key timestamp

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

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

時間複雜度：: O(1)
返回值：: 如果生存時間設置成功，返回1。
當key不存在或沒辦法設置生存時間，返回0。

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

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

OBJECT
OBJECT subcommand [arguments [arguments]]

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

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

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

OBJECT命令有多個子命令：

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

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

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

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

時間複雜度：: O(1)
返回值：: REFCOUNT和IDLETIME返回數字。
ENCODING返回相應的編碼類型。

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

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

PERSIST
PERSIST key

移除給定key的生存時間。

時間複雜度：: O(1)
返回值：: 當生存時間移除成功時，返回1.
如果key不存在或key沒有設置生存時間，返回0。

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

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

SORT

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

排序，分頁等
參數

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

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

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

一般SORT用法

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

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

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

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

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

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

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

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

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

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

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

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

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

使用外部key進行排序

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

假設現在有用戶(user)數據如下：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

只獲取對象而不排序

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

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

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

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

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

保存排序結果

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

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

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

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

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

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

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

在GET和BY中使用哈希表

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

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

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

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

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

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

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

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

時間複雜度：: O(N+M*log(M))，N爲要排序的列表或集合內的元素數量，M爲要返回的元素數量。
如果只是使用SORT命令的GET選項獲取數據而沒有進行排序，時間複雜度O(N)。
返回值：: 沒有使用STORE參數，返回列表形式的排序結果。
使用STORE參數，返回排序結果的元素數量。

字符串(String)

SET

SET key value

將字符串值value關聯到key。

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

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

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

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

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

SETNX

SETNX key value

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

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

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

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

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

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

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

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

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

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

處理死鎖(deadlock)

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

這種狀況可以通過檢測發現——因爲上鎖的key保存的是unix時間戳，假如key值的時間戳小於當前的時間戳，表示鎖已經不再有效。

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

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

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

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

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

因爲GETSET的作用，C4可以檢查看GETSET的返回值，確定lock.foo之前儲存的舊值仍是那個過期時間戳，如果是的話，那麼C4獲得鎖。
如果其他客戶端，比如C5，比C4更快地執行了GETSET操作並獲得鎖，那麼C4的GETSET操作返回的就是一個未過期的時間戳(C5設置的時間戳)。C4只好從第一步開始重試。

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

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

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

SETEX

SETEX key seconds value

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

如果key 已經存在，SETEX命令將覆寫舊值。

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

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

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

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

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

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

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

SETRANGE

SETRANGE key offset value

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

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

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

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

時間複雜度：: 對小(small)的字符串，平攤複雜度O(1)。(關於什麼字符串是”小”的，請參考APPEND命令)
否則爲O(M)，M爲value參數的長度。
返回值：: 被SETRANGE修改之後，字符串的長度。

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

模式

因爲有了SETRANGE和GETRANGE命令，你可以將Redis字符串用作具有O(1)隨機訪問時間的線性數組。這在很多真實用例中都是非常快速且高效的儲存方式。

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

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

MSET
MSET key value [key value ...]

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

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

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

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

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

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

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

MSETNX

MSETNX key value [key value ...]

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

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

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

時間複雜度：: O(N)，N爲要設置的key的數量。
返回值：: 當所有key都成功設置，返回1。
如果所有key都設置失敗(最少有一個key已經存在)，那麼返回0。

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


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

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

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

APPEND

APPEND key value

如果key已經存在並且是一個字符串，APPEND命令將value追加到key原來的值之後。

如果key不存在，APPEND就簡單地將給定key設爲value，就像執行SET key value一樣。

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

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

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

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

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

GET

GET key

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

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

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

時間複雜度：: O(1)
返回值：: key的值。
如果key不存在，返回nil。

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

MGET

MGET key [key ...]

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

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

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

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

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

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

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

GETRANGE

GETRANGE key start end

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

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

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

時間複雜度：: O(N)，N爲要返回的字符串的長度。
複雜度最終由返回值長度決定，但因爲從已有字符串中建立子字符串的操作非常廉價(cheap)，所以對於長度不大的字符串，該操作的複雜度也可看作O(1)。
返回值：: 截取得出的子字符串。

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

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

GETSET

GETSET key value

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

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

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

//GETSET
echo '<br><br>GETSET<br>';
var_dump($redis->EXISTS('mail'));//return bool(false);
var_dump($redis->GETSET('mail','[email protected]'));  # 因爲mail之前不存在，沒有舊值，返回nil ,#(nil)   //bool(false)

var_dump($redis->GETSET('mail','[email protected]'));  # mail被更新，舊值被返回 //string(14) "[email protected]"

設計模式

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

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

可以用命令GETSET mycounter 0來實現這一目標。

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

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

STRLEN

STRLEN key

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

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

複雜度：: O(1)
返回值：: 字符串值的長度。
當 key不存在時，返回0。

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

INCR

INCR key

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

如果key不存在，以0爲key的初始值，然後執行INCR操作。

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

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

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

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

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

INCRBY

INCRBY key increment

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

如果key不存在，以0爲key的初始值，然後執行INCRBY命令。

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

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

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

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

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

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

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

DECR


DECR key

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

如果key不存在，以0爲key的初始值，然後執行DECR操作。

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

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

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

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

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

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

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

DECRBY

DECRBY key decrement

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

如果key不存在，以0爲key的初始值，然後執行DECRBY操作。

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

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

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

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

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

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

SETBIT

SETBIT key offset value

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

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

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

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

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

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

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

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

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

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

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

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

GETBIT

GETBIT key offset

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

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

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

#參見SETBIT的示例

哈希表(Hash)

HSET

HSET key field value

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

如果key不存在，一個新的哈希表被創建並進行HSET操作。

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

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

HSETNX

HSETNX key field value

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

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

如果key不存在，一個新哈希表被創建並執行HSETNX命令。

時間複雜度：: O(1)
返回值：: 設置成功，返回1。
如果給定域已經存在且沒有操作被執行，返回0。

HMSET

HMSET key field value [field value ...]

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

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

如果key不存在，一個空哈希表被創建並執行HMSET操作。

時間複雜度：: O(N)，N爲field - value對的數量。
返回值：: 如果命令執行成功，返回OK。
當key不是哈希表(hash)類型時，返回一個錯誤。

HGET

HGET key field

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

時間複雜度：: O(1)
返回值：: 給定域的值。
當給定域不存在或是給定key不存在時，返回nil。

HMGET

HMGET key field [field ...]

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

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

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

時間複雜度：: O(N)，N爲給定域的數量。
返回值：: 一個包含多個給定域的關聯值的表，表值的排列順序和給定域參數的請求順序一樣。

HGETALL

HGETALL key

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

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

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

HDEL

HDEL key field [field ...]

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

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

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

HLEN

HLEN key

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

時間複雜度：: O(1)
返回值：: 哈希表中域的數量。
當key不存在時，返回0。

HEXISTS

HEXISTS key field

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

時間複雜度：: O(1)
返回值：: 如果哈希表含有給定域，返回1。
如果哈希表不含有給定域，或key不存在，返回0。

HINCRBY

HINCRBY key field increment

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

增量也可以爲負數，相當於對給定域進行減法操作。

如果key不存在，一個新的哈希表被創建並執行HINCRBY命令。

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

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

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

時間複雜度：: O(1)
返回值：: 執行HINCRBY命令之後，哈希表key中域field的值。

HKEYS

HKEYS key

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

時間複雜度：: O(N)，N爲哈希表的大小。
返回值：: 一個包含哈希表中所有域的表。
當key不存在時，返回一個空表。

HVALS

HVALS key

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

時間複雜度：: O(N)，N爲哈希表的大小。
返回值：: 一個包含哈希表中所有值的表。
當key不存在時，返回一個空表。

表(List)

頭元素和尾元素

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

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

空列表

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

LPUSH

LPUSH key value [value ...]

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

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

如果key不存在，一個空列表會被創建並執行LPUSH操作。

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

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

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

LPUSHX

LPUSHX key value

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

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

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

RPUSH

RPUSH key value [value ...]

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

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

如果key不存在，一個空列表會被創建並執行RPUSH操作。

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

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

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

RPUSHX

RPUSHX key value

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

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

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

LPOP

LPOP key

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

時間複雜度：: O(1)
返回值：: 列表的頭元素。
當key不存在時，返回nil。

RPOP

RPOP key

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

時間複雜度：: O(1)
返回值：: 列表的尾元素。
當key不存在時，返回nil。

BLPOP

BLPOP key [key ...] timeout

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

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

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

非阻塞行爲

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

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

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

BLPOP job command request 0

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

阻塞行爲

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

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

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

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

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

在MULTI/EXEC事務中的BLPOP

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

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

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

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

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

BRPOP

BRPOP key [key ...] timeout

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

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

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

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

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

LLEN

LLEN key

返回列表key的長度。

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

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

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

LRANGE

LRANGE key start stop

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

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

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

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

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

超出範圍的下標

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

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

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

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

LREM

LREM key count value

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

count的值可以是以下幾種：

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

時間複雜度：

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

返回值：

被移除元素的數量。

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

LSET

LSET key index value

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

更多信息請參考LINDEX操作。

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

時間複雜度：: 對頭元素或尾元素進行LSET操作，複雜度爲O(1)。
其他情況下，爲O(N)，N爲列表的長度。
返回值：: 操作成功返回ok，否則返回錯誤信息

LTRIM

LTRIM key start stop

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

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

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

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

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

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

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

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

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

超出範圍的下標

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

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

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

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

LINDEX

LINDEX key index

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

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

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

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

時間複雜度：: O(N)，N爲到達下標index過程中經過的元素數量。
因此，對列表的頭元素和尾元素執行LINDEX命令，複雜度爲O(1)。
返回值:: 列表中下標爲index的元素。
如果index參數的值不在列表的區間範圍內(out of range)，返回nil。

LINSERT

LINSERT key BEFORE|AFTER pivot value

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

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

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

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

時間複雜度:: O(N)，N爲尋找pivot過程中經過的元素數量。
返回值:: 如果命令執行成功，返回插入操作完成之後，列表的長度。
如果沒有找到pivot，返回-1。
如果key不存在或爲空列表，返回0。

RPOPLPUSH

RPOPLPUSH source destination

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

將列表source中的最後一個元素(尾元素)彈出，並返回給客戶端。
將source彈出的元素插入到列表destination，作爲destination列表的的頭元素。

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

如果source不存在，值nil被返回，並且不執行其他動作。

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

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

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

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

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

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

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

BRPOPLPUSH

BRPOPLPUSH source destination timeout

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

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

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

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

時間複雜度：: O(1)
返回值：: 假如在指定時間內沒有任何元素被彈出，則返回一個nil和等待時長。
反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素的值，第二個元素是等待時長。

集合(Set)

附錄，常用集合運算：

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

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

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

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

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

空集： 基數爲0的集合。

SADD

SADD key member [member ...]

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

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

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

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

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

SREM

SREM key member [member ...]

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

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

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

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

SMEMBERS

SMEMBERS key

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

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

SISMEMBER

SISMEMBER key member

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

時間複雜度:: O(1)
返回值:: 如果member元素是集合的成員，返回1。
如果member元素不是集合的成員，或key不存在，返回0。

SCARD

SCARD key

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

時間複雜度:: O(1)
返回值：: 集合的基數。
當key不存在時，返回0。

SMOVE

SMOVE source destination member

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

SMOVE是原子性操作。

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

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

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

時間複雜度:: O(1)
返回值:: 如果member元素被成功移除，返回1。
如果member元素不是source集合的成員，並且沒有任何操作對destination集合執行，那麼返回0。

SPOP

SPOP key

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

時間複雜度:: O(1)
返回值:: 被移除的隨機元素。
當key不存在或key是空集時，返回nil。

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

SRANDMEMBER

SRANDMEMBER key

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

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

時間複雜度:: O(1)
返回值:: 被選中的隨機元素。當key不存在或key是空集時，返回nil。

SINTER

SINTER key [key ...]

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

不存在的key被視爲空集。

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

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

SINTERSTORE

SINTERSTORE destination key [key ...]

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

如果destination集合已經存在，則將其覆蓋。

destination可以是key本身。

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

SUNION

SUNION key [key ...]

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

不存在的key被視爲空集。

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

SUNIONSTORE

SUNIONSTORE destination key [key ...]

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

如果destination已經存在，則將其覆蓋。

destination可以是key本身。

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

SDIFF

SDIFF key [key ...]

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

不存在的key被視爲空集。

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

SDIFFSTORE

SDIFFSTORE destination key [key ...]

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

如果destination集合已經存在，則將其覆蓋。

destination可以是key本身。

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

有序集(Sorted Set)

ZADD

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

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

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

score值可以是整數值或雙精度浮點數。

如果key不存在，則創建一個空的有序集並執行ZADD操作。

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

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

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

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

ZREM

ZREM key member [member ...]

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

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

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

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

ZCARD

ZCARD key

返回有序集key的基數。

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

ZCOUNT

ZCOUNT key min max

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

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

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

ZSCORE

ZSCORE key member

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

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

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

ZINCRBY

ZINCRBY key increment member

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

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

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

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

score值可以是整數值或雙精度浮點數。

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

ZRANGE

ZRANGE key start stop [WITHSCORES]

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

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

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

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

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

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

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

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

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

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

ZREVRANGE

ZREVRANGE key start stop [WITHSCORES]

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

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

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

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

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

ZRANGEBYSCORE

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

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

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

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

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

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

區間及無限

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

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

舉個例子：

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

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

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

ZREVRANGEBYSCORE

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

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

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

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

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

ZRANK

ZRANK key member

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

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

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

時間複雜度:: O(log(N))
返回值:: 如果member是有序集key的成員，返回member的排名。
如果member不是有序集key的成員，返回nil。

ZREVRANK

ZREVRANK key member

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

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

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

時間複雜度:: O(log(N))
返回值:: 如果member是有序集key的成員，返回member的排名。
如果member不是有序集key的成員，返回nil。

ZREMRANGEBYRANK

ZREMRANGEBYRANK key start stop

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

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

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

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

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

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE key min max

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

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

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

ZINTERSTORE

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

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

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

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

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

ZUNIONSTORE

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

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

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

WEIGHTS

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

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

AGGREGATE

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

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

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

發佈/訂閱(Pub/Sub)

PUBLISH

PUBLISH channel message

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

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

SUBSCRIBE channel [channel ...]

訂閱給定頻道的信息。

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

PSUBSCRIBE

PSUBSCRIBE pattern [pattern ...]

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

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

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

UNSUBSCRIBE

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

PUNSUBSCRIBE

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

事務(Transaction)

WATCH

ATCH key [key ...]

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

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

UNWATCH

取消 WATCH 命令對所有 key 的監視。

如果在執行 WATCH 命令之後， EXEC 命令或 DISCARD 命令先被執行了的話，那麼就不需要再執行 UNWATCH 了。

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

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

MULTI

標記一個事務塊的開始。

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

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

EXEC

執行所有事務塊內的命令。

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

時間複雜度：: 事務塊內所有命令的時間複雜度的總和。
返回值：: 事務塊內所有命令的返回值，按命令執行的先後順序排列。
當操作被打斷時，返回空值 nil 。

DISCARD

取消事務，放棄執行事務塊內的所有命令。

如果正在使用 WATCH 命令監視某個(或某些) key ，那麼取消所有監視，等同於執行命令 UNWATCH 。

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

連接(Connection)

AUTH

AUTH password

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

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

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

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

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

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

PING

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

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

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

SELECT

SELECT index

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

新的鏈接總是使用 0 號數據庫。

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

ECHO

ECHO message

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

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

QUIT

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

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

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

服務器(Server)

BGREWRITEAOF

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

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

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

BGSAVE

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

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

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

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

SAVE

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

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

LASTSAVE

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

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

DBSIZE

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

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

SLAVEOF

SLAVEOF host port

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

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

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

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

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

時間複雜度：: SLAVEOF host port ，O(N)， N 爲要同步的數據數量。
SLAVEOF NO ONE ， O(1) 。
返回值：: 總是返回 OK 。

FLUSHALL

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

此命令從不失敗。

時間複雜度：: 尚未明確
返回值：: 總是返回 OK 。

FLUSHDB

清空當前數據庫中的所有 key 。

此命令從不失敗。

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

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

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

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

CONFIG GET

CONFIG GET parameter

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

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

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

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

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

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

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

像 CONFIG SET xxx 1k 這樣的命令是錯誤的，正確的格式是 CONFIG SET xxx 1000 。
save 選項在 redis.conf 中是用多行文字儲存的，但在 CONFIG GET 命令中，它只打印一行文字。

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

save 900 1
save 300 10
save 60 10000

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

redis> CONFIG GET save
1) "save"
2) "900 1 300 10 60 10000"

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

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

CONFIG SET

CONFIG SET parameter value

CONFIG SET 命令可以動態地調整 Redis 服務器的配置(configuration)而無須重啓。

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

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

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

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

時間複雜度：: 不明確
返回值：: 當設置成功時返回 OK ，否則返回一個錯誤。

CONFIG RESETSTAT

CONFIG RESETSTAT

重置 INFO 命令中的某些統計數據，包括：

Keyspace hits (鍵空間命中次數)
Keyspace misses (鍵空間不命中次數)
Number of commands processed (執行命令的次數)
Number of connections received (連接服務器的次數)
Number of expired keys (過期key的數量)

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

DEBUG OBJECT

DEBUG OBJECT key

返回給定 key 的調試信息。

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

DEBUG SEGFAULT

DEBUG SEGFAULT

令 Redis 服務器崩潰，調試用。

時間複雜度：: 不明確
返回值：: 無

MONITOR

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

時間複雜度：: 不明確
返回值：: 總是返回 OK 。

SYNC

YNC

用於複製功能(replication)的內部命令。

時間複雜度：: 不明確
返回值：: 不明確

(結束)

PHP Redis使用手冊

redis中文手冊：http://readthedocs.org/docs/redis/en/latest/

字符串(String)

MSETNX

APPEND

GET

MGET

GETRANGE

GETSET

STRLEN

INCR

INCRBY

DECR

DECRBY

SETBIT

GETBIT

哈希表(Hash)

HSET

HSETNX

HMSET

HGET

HMGET

HGETALL

HDEL

HLEN

HEXISTS

HINCRBY

HKEYS

HVALS

表(List)

LPUSH

LPUSHX

RPUSH

RPUSHX

LPOP

RPOP

BLPOP

BRPOP

LLEN

LRANGE

LREM

LSET

LTRIM

LINDEX

LINSERT

RPOPLPUSH

BRPOPLPUSH

集合(Set)

SADD

SREM

SMEMBERS

SISMEMBER

SCARD

SMOVE

SPOP

SRANDMEMBER

SINTER

SINTERSTORE

SUNION

SUNIONSTORE

SDIFF

SDIFFSTORE

有序集(Sorted Set)

ZADD

ZREM

ZCARD

ZCOUNT

ZSCORE

ZINCRBY

ZRANGE

ZREVRANGE

ZRANGEBYSCORE

ZREVRANGEBYSCORE

ZRANK

ZREVRANK

ZREMRANGEBYRANK

ZREMRANGEBYSCORE

ZINTERSTORE

ZUNIONSTORE

發佈/訂閱(Pub/Sub)