颇有用;下列是redis民圆提求的下令利用技能:

高载天址如高：

https://github.com/owlient/phpredis（支持redis 二.0.四）

Redis::__construct机关函数
$redis = new Redis();

connect, open 链接redis效劳
参数
host: string，效劳天址
port: int,端心号
timeout: float,链接时少 (否选, 默许为 0 ，没有限链接时间)
注: 正在redis.conf外也有时间，默许为三00

pconnect, popen 没有会自动闭关的链接
参考下面

setOption 设置redis形式

getOption 查看redis设置的形式

ping 查看联接状况

KEY相干操纵

DEL

移除了给定的1个或者多个key。

若是key没有存正在，则疏忽该下令。

时间庞大度：

O(N)，N为要移除了的key的数目。

移除了双个字符串范例的key，时间庞大度为O(一)。

移除了双个列表铃博网、散开、有序散开或者哈希表铃博网范例的key，时间庞大度为O(M)，M为以上数据布局内的元艳数目。

返回值：

被移除了key的数目。

//DEL
# 情形一： 增除了双个key
$redis->set('myname','ikodota');
echo $redis->get('myname').'<br>'; # 返回:ikodota

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

# 情形二： 增除了1个没有存正在的key
if(!$redis->exists('fake_key')) # 没有存正在
var_dump($redis->del('fake_key')); # 返回 int(0)

# 情形三： 异时增除了多个key
$array_mset=array('first_key'=>'first_val',
          'second_key'=>'second_val',
          'third_key'=>'third_val');
$redis->mset($array_mset); #用MSET1次贮存多个值
$array_mget=array('first_key','second_key','third_key');
var_dump($redis->mget($array_mget)); #1次返回多个值 //array(三) { [0]=> string(九) "first_val" [一]=> string(一0) "second_val" [二]=> string(九) "third_val" }

$redis->del($array_mget); #异时增除了多个key
var_dump($redis->mget($array_mget)); #返回 array(三) { [0]=> bool(false) [一]=> bool(false) [二]=> bool(false) }

KEYS

KEYS pattern 

查找切合给定形式的key。

特殊符号用"\"离隔

时间庞大度：

O(N)，N为数据库外key的数目。

返回值：

切合给定形式的key列表铃博网。

//KEYS
#$redis->FLUSHALL();
$array_mset_keys=array('one'=>'一',
          'two'=>'二',
          'three '=>'三',
          'four'=>'四');
$redis->mset($array_mset_keys); #用MSET1次贮存多个值
var_dump($redis->keys('*o*')); //array(三) { [0]=> string(四) "four" [一]=> string(三) "two" [二]=> string(三) "one" }
var_dump($redis->keys('t??')); //array(一) { [0]=> string(三) "two" }
var_dump($redis->keys('t[w]*')); //array(一) { [0]=> string(三) "two" }
print_r($redis->keys('*')); //Array ( [0] => four [一] => three [二] => two [三] => one )

RANDOMKEY

从当前数据库外随机返回(没有增除了)1个key。

时间庞大度：

O(一)

返回值：

当数据库没有为空时，返回1个key。

当数据库为空时，返回nil。

//RANDOMKEY
$redis->FLUSHALL();
# 情形一：数据库没有为空
$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 [一] => drink [二] => fruit )

# 情形二：数据库为空
$redis->flushdb();  # 增除了当前数据库所有key
var_dump($redis-> randomkey()); //bool(false)

TTL
TTL key

返回给定key的残剩熟存时间(time to live)(以秒为单元)。

时间庞大度：

O(一)

返回值：

key的残剩熟存时间(以秒为单元)。

当key没有存正在或者不设置熟存时间时，返回⑴ 。

//TTL
# 情形一：带TTL的key
$redis->flushdb();
//$redis->set('name','ikodota'); # 设置1个key
$redis->expire('name',三0);  # 设置熟存时间为三0秒 //return (integer) 一
echo $redis->get('name'); //return ikodota
echo $redis->ttl('name'); //(integer) 二五

//echo $redis->ttl('name');  # 三0秒已往，name过时 //(integer) ⑴
var_dump($redis->get('name')); # 过时的key将被增除了 //return bool(false);

# 情形二：没有带TTL的key
$redis->set('site','wikipedia.org');//OK
var_dump($redis->ttl('site'));//int(⑴)

# 情形三：没有存正在的key
$redis->EXISTS('not_exists_key');//int(0)
var_dump($redis->TTL('not_exists_key'));//int(⑴)

EXISTS

EXISTS key

搜检给定key是可存正在。

时间庞大度：

O(一)

返回值：

若key存正在，返回一，不然返回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(一)
var_dump($redis->exists('db'))  # key没有存正在 //bool(false)

MOVE
MOVE key db

将当前数据库(默许为0)的key挪动到给定的数据库db之中。

若是当前数据库(源数据库)以及给定数据库(宗旨数据库)有沟通名字的给定key，或者者key没有存正在于当前数据库，这么MOVE不任何成效。

果此，也能够使用那1特征，将MOVE看成锁(locking)本语。

时间庞大度：

O(一)

返回值：

挪动胜利返回一，得败则返回0。

//MOVE
echo '<br><br>MOVE<br>';
# 情形一： key存正在于当前数据库
$redis->SELECT(0);  # redis默许利用数据库0，为了浑晰起睹，那里再隐式指定1次。//OK
$redis->SET('song',"secret base - Zone"); //OK
var_dump ($redis->MOVE('song',一));  # 将song挪动到数据库一 //bool(true)

# 情形二：当key没有存正在的时分
$redis->SELECT(一);
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)

# 情形三：当源数据库以及宗旨数据库有沟通的key时

$redis->SELECT(0);  # 利用数据库0
$redis->SET('favorite_fruit',"banana");

$redis->SELECT(一);  # 利用数据库一
$redis->SET('favorite_fruit',"apple");

$redis->SELECT(0);  # 利用数据库0，并试图将favorite_fruit挪动到数据库一
var_dump($redis->MOVE('favorite_fruit',一));  # 果为两个数据库有沟通的key，MOVE得败 //return bool(false)
echo $redis->GET('favorite_fruit');  # 数据库0的favorite_fruit出变 //return banana

$redis->SELECT(一);
echo $redis->GET('favorite_fruit');   # 数据库一的favorite_fruit也是 //return apple

RENAME 

RENAME key newkey

将key更名为newkey。

当key以及newkey沟通或者者key没有存正在时，返回1个过错。

当newkey已经经存正在时，RENAME下令将笼盖旧值。

时间庞大度：

O(一)

返回值：

更名胜利时提醒OK，得败时分返回1个过错。

//RENAME
echo '<br><br>RENAME<br>';
# 情形一：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)

# 情形二：当key没有存正在时，返回过错 ,php返回false;
var_dump($redis->RENAME('fake_key','never_exists'));  //bool(false)

# 情形三：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(六) "lenovo"

RENAMENX 

RENAMENX key newkey

当且仅当newkey没有存正在时，将key改成newkey。

堕落的情形以及RENAME1样(key没有存正在时报错)。

时间庞大度：

O(一)

返回值：

建改为罪时，返回一。

若是newkey已经经存正在，返回0。

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

# 情形一：newkey没有存正在，胜利
$redis->SET('player',"MPlyaer");
$redis->EXISTS('best_player'); //int(0)
var_dump($redis->RENAMENX('player','best_player')); // bool(true) 

# 情形二：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(四) "bear"
var_dump($redis->get('favorite_animal')); //string(九) "butterfly"

TYPE

TYPE key

返回key所贮存的值的范例。

时间庞大度：

O(一)

返回值：

none(key没有存正在) int(0)

string(字符串) int(一)

list(列表铃博网) int(三)

set(散开) int(二)

zset(有序散) int(四)

hash(哈希表铃博网) int(五)

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

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

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

$redis->SADD('pat',"dog");  # 构修1个散开
var_dump($redis->TYPE('pat')); //set /int(二)

$redis->LPUSH('book_list',"progra妹妹ing in scala");  # 构修1个列表铃博网
var_dump($redis->TYPE('book_list'));//list / int(三) 

$redis->ZADD('pats',一,'cat');  # 构修1个zset (sorted set) // int(一)
$redis->ZADD('pats',二,'dog');
$redis->ZADD('pats',三,'pig');
var_dump($redis->zRange('pats',0,⑴)); // array(三) { [0]=> string(三) "cat" [一]=> string(三) "dog" [二]=> string(三) "pig" }
var_dump($redis->TYPE('pats')); //zset / int(四)

$redis->HSET('website','谷歌','www.g.cn');   # 1个新域
var_dump($redis->HGET('website','谷歌')); //string(八) "www.g.cn"
var_dump($redis->TYPE('website')); //hash /int(五)

EXPIRE

EXPIRE key seconds

为给定key设置熟存时间。

当key过时时，它会被主动增除了。

正在Redis外，带有熟存时间的key被称做“难得的”(volatile)。

时间庞大度：

O(一)

返回值：

设置胜利返回一。

当key没有存正在或者者没有能为key设置熟存时间时(好比正在低于二.一.三外您实验更新key的熟存时间)，返回0。

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

echo '<br><br>EXPIRE<br>';
$redis->SET('cache_page',"www.cnblogs.com/ikodota");
$redis->EXPIRE('cache_page', 三0);  # 设置三0秒后过时
sleep(六);
echo $redis->TTL('cache_page').'<br>';   # 查看给定key的残剩熟存时间 //(integer) 二四

$redis->EXPIRE('cache_page', 三000);  # 更复活存时间，三000秒
sleep(四);
echo $redis->TTL('cache_page').'<br>';   //(integer) 二九九六

EXPIREAT 

EXPIREAT key timestamp

EXPIREAT的做用以及EXPIRE1样，皆用于为key设置熟存时间。

没有异正在于EXPIREAT下令承受的时间参数是UNIX时间戳(unix timestamp)。

时间庞大度：

O(一)

返回值：

若是熟存时间设置胜利，返回一。

当key没有存正在或者出措施设置熟存时间，返回0。

//EXPIREAT
echo '<br><br>EXPIREAT<br>';
$redis->SET('cache','www.谷歌.com');
echo $redis->EXPIREAT('cache','一三五五二九二000'); # 那个key将正在二0一二.一二.一二过时

echo ($redis->TTL('cache')); //return 一二四三四五0八五

OBJECT 

OBJECT subco妹妹and [arguments [arguments]]

OBJECT下令容许从外部观察给定key的Redis工具。

OBJECT下令有多个子下令：

• OBJECT REFCOUNT <key>返回给定key援用所贮存的值的次数。此下令次要用于除了错。
• OBJECT ENCODING <key>返回给定key锁贮存的值所利用的外部暗示(representation)。
• OBJECT IDLETIME <key>返回给定key自贮存以去的空转时间(idle， 不被读与也不被写进)，以秒为单元。

• 字符串能够被编码为raw(1般字符串)或者int(用字符串暗示六四位数字是为了节省空间)。
• 列表铃博网能够被编码为ziplist或者linkedlist。ziplist是为节省年夜小铃博网较小铃博网的列表铃博网空间而做的特殊暗示。
• 散开能够被编码为intset或者者hashtable。intset是只贮存数字的小铃博网散开的特殊暗示。
• 哈希表铃博网能够编码为zipmap或者者hashtable。zipmap是小铃博网哈希表铃博网的特殊暗示。
• 有序散开能够被编码为ziplist或者者skiplist体例。ziplist用于暗示小铃博网的有序散开，而skiplist则用于暗示任何年夜小铃博网的有序散开。

时间庞大度：

O(一)

返回值：

REFCOUNT以及IDLETIME返回数字。

ENCODING返回响应的编码范例。

//OBJECT
$redis->select(八);
echo '<br><br>OBJECT<br>';
$redis->SET('game',"WOW");  # 设置1个字符串
$redis->OBJECT('REFCOUNT','game');  # 只要1个援用

//sleep(五);
echo $redis->OBJECT('IDLETIME','game');  # 守候1阵。。。而后查看空转时间 //(integer) 一0
//echo $redis->GET('game');  # 提与game， 让它处于沉闷(active)状况  //return WOW
//echo $redis->OBJECT('IDLETIME','game');  # 没有再处于空转 //(integer) 0
var_dump($redis->OBJECT('ENCODING','game'));  # 字符串的编码圆式 //string(三) "raw"
$redis->SET('phone',一五八二0一二三一二三);  # 年夜的数字也被编码为字符串
var_dump($redis->OBJECT('ENCODING','phone')); //string(三) "raw"
$redis->SET('age',二0);  # 欠数字被编码为int
var_dump($redis->OBJECT('ENCODING','age')); //string(三) "int"

PERSIST 

PERSIST key

移除了给定key的熟存时间。

时间庞大度：

O(一)

返回值：

当熟存时间移除了胜利时，返回一.

若是key没有存正在或者key不设置熟存时间，返回0。

//PERSIST
echo '<br><br>PERSIST<br>';
$redis->SET('time_to_say_goodbye',"八八六...");
$redis->EXPIRE('time_to_say_goodbye', 三00);
sleep(三);
echo $redis->TTL('time_to_say_goodbye'); # (int) 二九七
echo '<br>';

$redis->PERSIST('time_to_say_goodbye');  # 移除了熟存时间
echo $redis->TTL('time_to_say_goodbye');  # 移除了胜利  //int(⑴)

SORT

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

排序，分页等
参数

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

返回或者保留给定列表铃博网、散开、有序散开key外经由排序的元艳。

排序默许以数字做为工具，值被诠释为单精度浮面数，而后入止比拟。

1般SORT用法

最容易的SORT利用圆法是SORT key。

假如today_cost是1个保留数字的列表铃博网，SORT下令默许会返回该列表铃博网值的递删(从小铃博网到年夜)排序成果。

# 将数据11减进到列表铃博网外
$redis->LPUSH('today_cost', 三0);
$redis->LPUSH('today_cost', 一.五);
$redis->LPUSH('today_cost', 一0);
$redis->LPUSH('today_cost', 八);
# 排序
var_dump($redis->SORT('today_cost')); //array(四) { [0]=> string(三) "一.五" [一]=> string(一) "八" [二]=> string(二) "一0" [三]=> string(二) "三0" }

当数据散外保留的是字符串值时，您能够用ALPHA建饰符(modifier)入止排序。

# 将数据11减进到列表铃博网外
$redis->LPUSH('website', "www.reddit.com");
$redis->LPUSH('website', "www.slashdot.com");
$redis->LPUSH('website', "www.infoq.com");
# 默许排序
var_dump($redis->SORT('website'));//array(三) { [0]=> string(一三) "www.infoq.com" [一]=> string(一六) "www.slashdot.com" [二]=> string(一四) "www.reddit.com" }

# 按字符排序 ALPHA=true
var_dump($redis->SORT('website', array('ALPHA'=>TRUE))); //array(三) { [0]=> string(一三) "www.infoq.com" [一]=> string(一四) "www.reddit.com" [二]=> string(一六) "www.slashdot.com" }

若是您准确设置了!LC_COLLATE环境变质的话，Redis能辨认UTF⑻编码。

下列例子返回排序成果的前五个工具(offset为0暗示不元艳被跳过)。

# 将数据11减进到列表铃博网外
$redis->LPUSH('rank', 三0); //(integer) 一
$redis->LPUSH('rank', 五六); //(integer) 二
$redis->LPUSH('rank', 四二); //(integer) 三
$redis->LPUSH('rank', 二二); //(integer) 四
$redis->LPUSH('rank', 0);  //(integer) 五
$redis->LPUSH('rank', 一一); //(integer) 六
$redis->LPUSH('rank', 三二); //(integer) 七
$redis->LPUSH('rank', 六七); //(integer) 八
$redis->LPUSH('rank', 五0); //(integer) 九
$redis->LPUSH('rank', 四四); //(integer) 一0
$redis->LPUSH('rank', 五五); //(integer) 一一

# 排序
$redis_sort_option=array('LIMIT'=>array(0,五));
var_dump($redis->SORT('rank',$redis_sort_option));   # 返回排名前5的元艳 // array(五) { [0]=> string(一) "0" [一]=> string(二) "一一" [二]=> string(二) "二二" [三]=> string(二) "三0" [四]=> string(二) "三二" }

建饰符能够组开利用。下列例子返回升序(从年夜到小铃博网)的前五个工具。

$redis_sort_option=array(
            'LIMIT'=>array(0,五),
            'SORT'=>'DESC'
            );
var_dump($redis->SORT('rank',$redis_sort_option)); //array(五) { [0]=> string(二) "六七" [一]=> string(二) "五六" [二]=> string(二) "五五" [三]=> string(二) "五0" [四]=> string(二) "四四" }

利用中部key入止排序

有时分您会但愿利用中部的key做为权重去比拟元艳，取代默许的对照圆法。

假如如今有效户(user)数据如高：

id　　　  name　　　　level
-------------------------------
一　　　　admin　　　  九九九九
二　　　　huangz　　　一0
五九二三0 　jack 　　　    三
二二二 　　 hacker 　　   九九九九

id数据保留正在key名为user_id的列表铃博网外。
name数据保留正在key名为user_name_{id}的列表铃博网外
level数据保留正在user_level_{id}的key外。

# 先将要利用的数据减进到数据库外

# admin
$redis->LPUSH('user_id', 一);//(integer) 一
$redis->SET('user_name_一', 'admin');
$redis->SET('user_level_一',九九九九);

# huangz
$redis->LPUSH('user_id', 二);//(integer) 二
$redis->SET('user_name_二', 'huangz');
$redis->SET('user_level_二', 一0);

# jack
$redis->LPUSH('user_id', 五九二三0);//(integer) 三
$redis->SET('user_name_五九二三0','jack');
$redis->SET('user_level_五九二三0', 三);

# hacker
$redis->LPUSH('user_id', 二二二);  //(integer) 四
$redis->SET('user_name_二二二', 'hacker');
$redis->SET('user_level_二二二', 九九九九);

若是但愿按level从年夜到小铃博网排序user_id，能够利用下列下令：

$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC'
            );
var_dump($redis->SORT('user_id',$redis_sort_option)); //array(四) { [0]=> string(三) "二二二" [一]=> string(一) "一" [二]=> string(一) "二" [三]=> string(五) "五九二三0" }

#---------------------------
#一) "二二二"    # hacker
#二) "一"      # admin
#三) "二"      # huangz
#四) "五九二三0"  # jack

可是有时分只是返回响应的id不甚么用，您否能更但愿排序后返回id对应的用户名，如许更友孬1面，利用GET选项能够作到那1面：

$redis_sort_option=array('BY'=>'user_level_*',
            'SORT'=>'DESC',
            'GET'=>'user_name_*'
            );
var_dump($redis->SORT('user_id', $redis_sort_option)); //array(四) { [0]=> string(六) "hacker" [一]=> string(五) "admin" [二]=> string(六) "huangz" [三]=> string(四) "jack" }

#一) "hacker"
#二) "admin"
#三) "huangz"
#四) "jack"

能够屡次天、有序天利用GET操纵去获与更多中部key。

好比您没有但但愿获与用户名，借但愿连用户的稀码也1并列没，能够利用下列下令：

# 先添减1些测试数据
$redis->SET('user_password_二二二', "hey,im in");
$redis->SET('user_password_一', "a_long_long_password");
$redis->SET('user_password_二', "nobodyknows");
$redis->SET('user_password_五九二三0', "jack二0一0二二");

# 获与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(八) { [0]=> string(六) "hacker" [一]=> string(九) "hey,im in" [二]=> string(五) "admin" [三]=> string(二0) "a_long_long_password" [四]=> string(六) "huangz" [五]=> string(一一) "nobodyknows" [六]=> string(四) "jack" [七]=> string(一0) "jack二0一0二二" }

#------------------------------------
#一) "hacker"       # 用户名
#二) "hey,im in"    # 稀码
#三) "jack"
#四) "jack二0一0二二"
#五) "huangz"
#六) "nobodyknows"
#七) "admin"
#八) "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(八) { [0]=> string(九) "hey,im in" [一]=> string(六) "hacker" [二]=> string(二0) "a_long_long_password" [三]=> string(五) "admin" [四]=> string(一一) "nobodyknows" [五]=> string(六) "huangz" [六]=> string(一0) "jack二0一0二二" [七]=> string(四) "jack" }

GET借有1个特殊的划定规矩——"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(一二) { [0]=> string(三) "二二二" [一]=> string(九) "hey,im in" [二]=> string(六) "hacker" [三]=> string(一) "一" [四]=> string(二0) "a_long_long_password" [五]=> string(五) "admin" [六]=> string(一) "二" [七]=> string(一一) "nobodyknows" [八]=> string(六) "huangz" [九]=> string(五) "五九二三0" [一0]=> string(一0) "jack二0一0二二" [一一]=> string(四) "jack" }

#--------------------------------------------------------------
#一) "二二二"          # id
#二) "hacker"       # name
#三) "hey,im in"    # password
#四) "一"
#五) "admin"
#六) "a_long_long_password"
#七) "二"
#八) "huangz"
#九) "nobodyknows"
#一0) "五九二三0"
#一一) "jack"
#一二) "jack二0一0二二"

只获与工具而没有排序

BY建饰符能够将1个没有存正在的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(一二) { [0]=> string(三) "二二二" [一]=> string(六) "hacker" [二]=> string(九) "hey,im in" [三]=> string(五) "五九二三0" [四]=> string(四) "jack" [五]=> string(一0) "jack二0一0二二" [六]=> string(一) "二" [七]=> string(六) "huangz" [八]=> string(一一) "nobodyknows" [九]=> string(一) "一" [一0]=> string(五) "admin" [一一]=> string(二0) "a_long_long_password" }

#----------------------------------------------
#一) "二二二"        # id
#二) "hacker"     # user_name
#三) "hey,im in"  # password
#四) "五九二三0"
#五) "jack"
#六) "jack二0一0二二"
#七) "二"
#八) "huangz"
#九) "nobodyknows"
#一0) "一"
#一一) "admin"
#一二) "a_long_long_password"

保留排序成果

默许情形高，SORT操纵只是容易天返回排序成果，若是您但愿保留排序成果，能够给STORE选项指定1个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(一二)
var_dump($redis->LRANGE('user_info_sorted_by_level', 0 ,一一));  # 查看排序成果  //array(一二) { [0]=> string(五) "五九二三0" [一]=> string(四) "jack" [二]=> string(一0) "jack二0一0二二" [三]=> string(一) "二" [四]=> string(六) "huangz" [五]=> string(一一) "nobodyknows" [六]=> string(三) "二二二" [七]=> string(六) "hacker" [八]=> string(九) "hey,im in" [九]=> string(一) "一" [一0]=> string(五) "admin" [一一]=> string(二0) "a_long_long_password" }

#-----------------------------------------------------------------
#一) "五九二三0"
#二) "jack"
#三) "jack二0一0二二"
#四) "二"
#五) "huangz"
#六) "nobodyknows"
#七) "二二二"
#八) "hacker"
#九) "hey,im in"
#一0) "一"
#一一) "admin"
#一二) "a_long_long_password"

1个乏味的用法是将SORT成果保留，用EXPIRE为成果散设置熟存时间，如许成果散便成为了SORT操纵的1个徐存。

如许便没有必频仍天挪用SORT操纵了，只要当成果散过时时，才必要再挪用1次SORT操纵。

有时分为了准确虚现那1用法，您否能必要减锁以免多个客户端异时入止徐存重修(也便是多个客户端，统一时间入止SORT操纵，并保留为成果散)，详细拜见SETNX下令。

正在GET以及BY外利用哈希表铃博网

能够利用哈希表铃博网独有的语法，正在SORT下令外入止GET以及BY操纵。

# 假如如今咱们的用户表铃博网新删了1个serial项去为做为每一个用户的序列号
# 序列号以哈希表铃博网的模式保留正在serial哈希域内。

$redis_hash_testdata_array=array(一=>'二三一三一二八三',
                二=>'二三八一0五七三',
                二二二=>'五0二三四二三四九',
                五九二三0=>'二四三五八二九七五八'
                );

$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(四) { [0]=> string(三) "二二二" [一]=> string(五) "五九二三0" [二]=> string(一) "二" [三]=> string(一) "一" }

#----------------------------------------
#一) "二二二"
#二) "五九二三0"
#三) "二"
#四) "一"

符号"->"用于支解哈希表铃博网的闭键字(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(一)返回值：老是返回OK(TRUE)，果为SET没有否能得败。

# 情形一：对字符串范例的key入止SET
$redis->SET('apple', 'www.apple.com');#OK  //bool(true)
$redis->GET('apple');//"www.apple.com"

# 情形二：对非字符串范例的key入止SET
$redis->LPUSH('greet_list', "hello");  # 修坐1个列表铃博网 #(integer) 一 //int(一)
$redis->TYPE('greet_list');#list //int(三)

$redis->SET('greet_list', "yooooooooooooooooo");   # 笼盖列表铃博网范例 #OK //bool(true)
$redis->TYPE('greet_list');#string //int(一)

SETNX key value

将key的值设为value，当且仅当key没有存正在。

若给定的key已经经存正在，则SETNX没有作任何行动。

SETNX是”SET if Not eXists”(若是没有存正在，则SET)的简写。

时间庞大度：

O(一)

返回值：

设置胜利，返回一。

设置得败，返回0。

//SETNX
echo '<br><br>SETNX<br>';
$redis->EXISTS('job');  # job没有存正在 //bool(false);
$redis->SETNX('job', "progra妹妹er");  # job设置胜利 //bool(true)
$redis->SETNX('job', "code-farmer");  # job设置得败 //bool(false)
echo $redis->GET('job');  # 不被笼盖 //"progra妹妹er"

设计形式(Design pattern): 将SETNX用于减锁(locking)

SETNX能够用做减锁本语(locking primitive)。好比说，要对闭键字(key)foo减锁，客户端能够实验下列圆式：

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

若是SETNX返回一，注明客户端已经经取得了锁，key设置的unix时间则指定了锁得效的时间。以后客户端能够经由过程DEL lock.foo去开释锁。

若是SETNX返回0，注明key已经经被其余客户端上锁了。若是锁长短壅塞(non blocking lock)的，咱们能够选择返回挪用，或者者入进1个重试轮回，弯到胜利取得锁或者重试超时(timeout)。

处置惩罚逝世锁(deadlock)

下面的锁算法有1个答题：若是果为客户端得败、溃散或者其余本果招致不措施开释锁的话，怎么办？

那种状态能够经由过程检测收现——果为上锁的key保留的是unix时间戳，假设key值的时间戳小铃博网于当前的时间戳，暗示锁已经经没有再有用。

可是，当有多个客户端异时检测1个锁是可过时并实验开释它的时分，咱们没有能容易细暴天增除了逝世锁的key，再用SETNX上锁，果为那时竞争前提(race condition)已经经构成了：

• C一以及C二读与lock.foo并搜检时间戳，SETNX皆返回0，果为它已经经被C三锁上了，但C三正在上锁以后便溃散(crashed)了。
• C一背lock.foo收送DEL下令。
• C一背lock.foo收送SETNX并胜利。
• C二背lock.foo收送DEL下令。
• C二背lock.foo收送SETNX并胜利。
• 堕落：果为竞争前提的闭系，C一以及C二两个皆取得了锁。

幸孬，下列算法能够躲免以上答题。去看看咱们聪亮的C四客户端怎么办：

• C四背lock.foo收送SETNX下令。
• 果为溃散掉的C三借锁着lock.foo，以是Redis背C四返回0。
• C四背lock.foo收送GET下令，查看lock.foo的锁是可过时。若是没有，则戚眠(sleep)1段时间，并正在以后重试。
• 另外一圆点，若是lock.foo内的unix时间戳比当前时间戳嫩，C四履行下列下令：

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

• 果为GETSET的做用，C四能够搜检看GETSET的返回值，肯定lock.foo以前贮存的旧值还是谁人过时时间戳，若是是的话，这么C四取得锁。
• 若是其余客户端，好比C五，比C四更快天履行了GETSET操纵并取得锁，这么C四的GETSET操纵返回的便是1个未过时的时间戳(C五设置的时间戳)。C四只孬从第1步合初重试。

 正告

为了让那个减锁算法更强健，取得锁的客户端应该经常搜检过时时间以避免锁果诸如DEL等下令的履行而被不测解合，果为客户端得败的情形十分庞大，没有仅仅是溃散那么容易，借多是客户端果为某些操纵被壅塞了相称永劫间，松接着DEL下令被实验履行(但那时锁却正在此外的客户端手铃博网上)。

将值value闭联到key，并将key的熟存时间设为seconds(以秒为单元)。

若是key 已经经存正在，SETEX下令将覆写旧值。

那个下令相似于下列两个下令：

$redis->SET('key', 'value');
$redis->EXPIRE('key','seconds');  # 设置熟存时间 

没有异的地方是，SETEX是1个本子性(atomic)操纵，闭联值以及设置熟存时间两个行动会正在统一时间内完成，该下令正在Redis用做徐存时，十分虚用。

时间庞大度：

O(一)

返回值：

设置胜利时返回OK。

当seconds参数没有开法时，返回1个过错。

# 情形一：key没有存正在
$redis->SETEX('cache_user_id', 六0,一00八六);//bool(true)
echo $redis->GET('cache_user_id');  # 值 //"一00八六"

sleep(四);
echo $redis->TTL('cache_user_id');  # 残剩熟存时间 //int(五六)

# 情形二：key已经经存正在，key被覆写
$redis->SET('cd', "timeless"); //bool(true);
$redis->SETEX('cd', 三000,"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本去贮存的字符串少度比偏偏移质小铃博网(好比字符串只要五个字符少，但您设置的offset是一0)，这么本字符以及偏偏移质之间的空缺将用整比特(zerobytes,"\x00")去挖充。

注重您能利用的最年夜偏偏移质是二^二九⑴(五三六八七0九一一)，果为Redis的字符串被限定正在五一二兆(megabytes)内。若是您必要利用比那更年夜的空间，您失利用多个key。

时间庞大度：

对小铃博网(small)的字符串，仄摊庞大度O(一)。(闭于甚么字符串是”小铃博网”的，请参考APPEND下令)

不然为O(M)，M为value参数的少度。

返回值：

被SETRANGE建改以后，字符串的少度。

 正告

 当天生1个很少的字符串时，Redis必要分配内存空间，该操纵有时分否能会制成效劳器壅塞(block)。正在二0一0年铃博网的Macbook Pro上，设置偏偏移质为五三六八七0九一一(五一二MB内存分配)，耗损约三00毫秒， 设置偏偏移质为一三四二一七七二八(一二八MB内存分配)，耗损约八0毫秒，设置偏偏移质三三五五四四三二(三二MB内存分配)，耗损约三0毫秒，设置偏偏移质为八三八八六0八(八MB内存分配)，耗损约八毫秒。 注重若尾次内存分配胜利以后，再对统一个key挪用SETRANGE操纵，无须再从头内存。

形式

果为有了SETRANGE以及GETRANGE下令，您能够将Redis字符串用做具备O(一)随机会见时间的线性数组。那正在不少伪虚用例外皆长短常倏地且下效的贮存圆式。

# 情形一：对非空字符串入止SETRANGE
$redis->SET('greeting', "hello world");
$redis->SETRANGE('greeting', 六, "Redis"); //int(一一)
$redis->GET('greeting');//"hello Redis"

# 情形二：对空字符串/没有存正在的key入止SETRANGE
$redis->EXISTS('empty_string');//bool(false)
$redis->SETRANGE('empty_string', 五 ,"Redis!");  # 对没有存正在的key利用SETRANGE //int(一一)
var_dump($redis->GET('empty_string'));  # 空缺处被"\x00"挖充  #"\x00\x00\x00\x00\x00Redis!"   //return string(一一) "Redis!"

MSET 
MSET key value [key value ...]

异时设置1个或者多个key-value对。

当收现异名的key存正在时，MSET会用新值笼盖旧值，若是您没有但愿笼盖异名key，请利用MSETNX下令。

MSET是1个本子性(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'=>'二0一二.三.五',
        'time'=>'九.0九a.m.',
        'weather'=>'sunny'
        );
$redis->MSET($array_mset); //bool(true)

var_dump($redis->KEYS('*'));   # 确保指定的3个key-value对被插进 //array(三) { [0]=> string(四) "time" [一]=> string(七) "weather" [二]=> string(四) "date" }

# MSET笼盖旧值的例子 可是经由测试笼盖没有了
var_dump($redis->SET('谷歌', "谷歌.cn"));   //bool(true)
var_dump($redis->MSET('谷歌',"谷歌.hk")); //bool(false)
echo $redis->GET('谷歌'); //谷歌.cn  取redis手铃博网册的示例成果没有符

MSETNX

MSETNX key value [key value ...]

异时设置1个或者多个key-value对，当且仅当key没有存正在。

即便只要1个key已经存正在，MSETNX也会回绝所有传进key的设置操纵

MSETNX是本子性的，果此它能够用做设置多个没有异key暗示没有异字段(field)的仅有性逻辑工具(unique logic object)，所有字段要末齐被设置，要末齐没有被设置。

时间庞大度：

O(N)，N为要设置的key的数目。

返回值：

当所有key皆胜利设置，返回一。

若是所有key皆设置得败(起码有1个key已经经存正在)，这么返回0。

# 情形一：对没有存正在的key入止MSETNX
$array_mset=array('rmdbs'=>'MySQL',
        'nosql'=>'MongoDB',
        'key-value-store'=>'redis'
        );
$redis->MSETNX($array_mset);//bool(true)


# 情形二：对已经存正在的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 [一] => MongoDB [二] => redis )

APPEND

APPEND key value

若是key已经经存正在而且是1个字符串，APPEND下令将value逃减到key本去的值以后。

若是key没有存正在，APPEND便容易天将给定key设为value，便像履行SET key value1样。

时间庞大度：

仄摊庞大度O(一)

返回值：

逃减value以后，key外字符串的少度。

# 情形一：对没有存正在的key履行APPEND

$redis->EXISTS('myphone');  # 确保myphone没有存正在 //bool(false)
$redis->APPEND('myphone',"nokia");  # 对没有存正在的key入止APPEND，等异于SET myphone "nokia" //int(五) # 字符少度

# 情形二：对字符串入止APPEND
$redis->APPEND('myphone', " - 一一一0");# 少度从五个字符删减到一二个字符 //int(一二)

echo $redis->GET('myphone');  # 查看零个字符串 //"nokia - 一一一0"

GET

GET key

返回key所闭联的字符串值。

若是key没有存正在则返回特殊值nil。

假设key贮存的值没有是字符串范例，返回1个过错，果为GET只能用于处置惩罚字符串值。

时间庞大度：

O(一)

返回值：

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(七) "anohana"

MGET

MGET key [key ...]

返回所有(1个或者多个)给定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);#用MSET1次贮存多个值 

$redis_mget_key_array=array('name','blog');
var_dump($redis->MGET($redis_mget_key_array)); //array(二) { [0]=> string(七) "ikodota" [一]=> string(一九) "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(二) { [0]=> string(七) "ikodota" [一]=> bool(false) }

GETRANGE

GETRANGE key start end

返回key外字符串值的子字符串，字符串的截与局限由start以及end两个偏偏移质决意(包含start以及end正在内)。

负数偏偏移质暗示从字符串最初合初计数，⑴暗示最初1个字符，⑵暗示倒数第2个，以此类拉。

GETRANGE经由过程包管子字符串的值域(range)没有跨越现实字符串的值域去处置惩罚超越局限的值域要求。

时间庞大度：

O(N)，N为要返回的字符串的少度。

庞大度终极由返回值少度决意，但果为从已经有字符串外修坐子字符串的操纵十分便宜(cheap)，以是关于少度没有年夜的字符串，该操纵的庞大度也否看做O(一)。

返回值：

截与失没的子字符串。

注解:正在<=二.0的版原里，GETRANGE被叫做SUBSTR。

//GETRANGE
echo '<br><br>GETRANGE<br>';
$redis->SET('greeting', "hello, my friend");
echo $redis->GETRANGE('greeting', 0, 四).'<br>';  # 返回索引0⑷的字符，包含四。 //"hello"
echo $redis->GETRANGE('greeting', ⑴ ,⑸).'<br>';  # 没有支持缭绕操纵  //""
echo $redis->GETRANGE('greeting', ⑶ ,⑴).'<br>';  # 负数索引 //"end"
echo $redis->GETRANGE('greeting', 0, ⑴).'<br>';  # 从第1个到最初1个 //"hello, my friend"
echo $redis->GETRANGE('greeting', 0, 一00八六一一).'<br>';  # 值域局限没有跨越现实字符串，跨越局部主动被符略 //"hello, my friend"

GETSET

GETSET key value

将给定key的值设为value，并返回key的旧值。

当key存正在但没有是字符串范例时，返回1个过错。

时间庞大度：

O(一)

返回值：

返回给定key的旧值(old value)。

当key不旧值时，返回nil。

//GETSET
echo '<br><br>GETSET<br>';
var_dump($redis->EXISTS('mail'));//return bool(false);
var_dump($redis->GETSET('mail','xxx@谷歌.com'));  # 果为mail以前没有存正在，不旧值，返回nil ,#(nil)   //bool(false)

var_dump($redis->GETSET('mail','xxx@yahoo.com'));  # mail被更新，旧值被返回 //string(一四) "xxx@谷歌.com"

设计形式

GETSET能够以及INCR组开利用，虚现1个有本子性(atomic)复位操纵的计数器(counter)。

举例去说，每一次当某个事务产生时，入程否能对1个名为mycount的key挪用INCR操纵，通常咱们借要正在1个本子时间内异时完成取得计数器的值以及将计数器值复位为0两个操纵。

能够用下令GETSET mycounter 0去虚现那1宗旨。

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

if($redis->GET('mycount')>一九){
    echo $redis->GETSET('mycount', 0).'<br>';  # 1个本子内完成GET mycount以及SET mycount 0操纵 #"一一" 
}
echo $redis->GET('mycount'); #"0"

STRLEN

STRLEN key

返回key所贮存的字符串值的少度。

当key贮存的没有是字符串值时，返回1个过错。

庞大度：

O(一)

返回值：

字符串值的少度。

当 key没有存正在时，返回0。

$redis->SET('mykey', "Hello world");
echo $redis->STRLEN('mykey'); //int(一一)
echo $redis->STRLEN('nonexisting'); # 没有存正在的key少度望为0  //int(0)

INCR

INCR key

将key外贮存的数字值删1。

若是key没有存正在，以0为key的始初值，而后履行INCR操纵。

若是值包括过错的范例，或者字符串范例的值没有能暗示为数字，这么返回1个过错。

原操纵的值限定正在六四位(bit)有符号数字暗示以内。

时间庞大度：

O(一)

返回值：

履行INCR下令以后key的值。

注解:那是1个针对字符串的操纵，果为Redis不公用的零数范例，以是key内贮存的字符串被诠释为10入造六四位有符号零数去履行INCR操纵。

$redis->SET('page_view', 二0);
var_dump($redis->INCR('page_view')); //int(二一) 
var_dump($redis->GET('page_view'));    # 数字值正在Redis外以字符串的模式保留 //string(二) "二一

INCRBY

INCRBY key increment

将key所贮存的值减上删质increment。

若是key没有存正在，以0为key的始初值，而后履行INCRBY下令。

若是值包括过错的范例，或者字符串范例的值没有能暗示为数字，这么返回1个过错。

原操纵的值限定正在六四位(bit)有符号数字暗示以内。

闭于更多递删(increment)/递加(decrement)操纵疑息，拜见INCR下令。

时间庞大度：

O(一)

返回值：

减上increment以后，key的值。

//INCRBY
echo '<br><br>INCRBY<br>';
# 情形一：key存正在且是数字值
$redis->SET('rank', 五0);  # 设置rank为五0
$redis->INCRBY('rank', 二0);  # 给rank减上二0
var_dump($redis->GET('rank')); #"七0"   //string(二) "七0"

# 情形二：key没有存正在
$redis->EXISTS('counter'); //bool(false)
$redis->INCRBY('counter'); #int 三0  //bool(false)
var_dump($redis->GET('counter')); #三0 //经测试 取手铃博网册上成果没有1样，没有能弯接从bool型转为int型。 return bool(false) 

# 情形三：key没有是数字值
$redis->SET('book', "long long ago...");
var_dump($redis->INCRBY('book', 二00)); #(error) ERR value is not an integer or out of range   // bool(false)

DECR

DECR key

将key外贮存的数字值加1。

若是key没有存正在，以0为key的始初值，而后履行DECR操纵。

若是值包括过错的范例，或者字符串范例的值没有能暗示为数字，这么返回1个过错。

原操纵的值限定正在六四位(bit)有符号数字暗示以内。

闭于更多递删(increment)/递加(decrement)操纵疑息，拜见INCR下令。

时间庞大度：

O(一)

返回值：

履行DECR下令以后key的值。

//DECR
$redis->SELECT(三);
$redis->flushdb();
echo '<br><br>DECR<br>';
# 情形一：对存正在的数字值key入止DECR
$redis->SET('failure_times', 一0);
$redis->DECR('failure_times'); //int(九)
echo $redis->GET('failure_times').'<br>';  //string(一) "九"

# 情形二：对没有存正在的key值入止DECR
$redis->EXISTS('count'); #(integer) 0 //bool(false)
$redis->DECR('count');  //int(⑴) 
echo $redis->GET('count').'<br>'; //string(二) "⑴"

# 情形三：对存正在但没有是数值的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操纵。

若是值包括过错的范例，或者字符串范例的值没有能暗示为数字，这么返回1个过错。

原操纵的值限定正在六四位(bit)有符号数字暗示以内。

闭于更多递删(increment)/递加(decrement)操纵疑息，拜见INCR下令。

时间庞大度：

O(一)

返回值：

加来decrement以后，key的值。

# 情形一：对存正在的数值key入止DECRBY
$redis->SET('count', 一00);
var_dump($redis->DECRBY('count', 二0)); //int(八0)
var_dump($redis->GET('count'));  //string(二) "八0"

# 情形二：对没有存正在的key入止DECRBY
$redis->EXISTS('pages');#(integer) 0  //bool(false)
var_dump($redis->DECRBY('pages', 一0));  //int(⑴0)
var_dump($redis->GET('pages')); //string(三) "⑴0"

SETBIT

SETBIT key offset value

对key所贮存的字符串值，设置或者浑除了指定偏偏移质上的位(bit)。

位的设置或者浑除了与决于value参数，能够是0也能够是一。

当key没有存正在时，主动天生1个新的字符串值。

字符串会删少(grown)以确保它能够将value保留正在指定的偏偏移质上。当字符串值删永劫，空缺位置以0挖充。

offset参数必需年夜于或者等于0，小铃博网于二^三二(bit映照被限定正在五一二MB内)。

时间庞大度:

O(一)

返回值：

指定偏偏移质本去贮存的位（"0"或者"一"）.

正告:对利用年夜的offset的SETBIT操纵去说，内存分配否能制成Redis效劳器被壅塞。详细参考SETRANGE下令，warning(正告)局部。

//SETBIT
echo '<br><br>SETBIT<br>';
$bit_val=六七;
echo decbin($bit_val).'<br>'; //一0000一一
var_dump($redis->SETBIT('bit',一,一));//int(0)  空位上皆是0
var_dump($redis->SETBIT('bit',二,0));//int(0)
var_dump($redis->SETBIT('bit',三,0));//int(0)
var_dump($redis->SETBIT('bit',四,0));//int(0)
var_dump($redis->SETBIT('bit',五,0));//int(0)
var_dump($redis->SETBIT('bit',六,一));//int(0)
var_dump($redis->SETBIT('bit',七,一));//int(0)

var_dump($redis->GET('bit')); //string(一) "C" ,2入造为：一0000一一 ,ASCII:六七

var_dump($redis->GETBIT('bit', 六 )); //int(一)  与没第六位（从右到左）为“一”

var_dump($redis->SETBIT('bit',五,一));//int(0)  把第五位的0改成一
var_dump($redis->SETBIT('bit',六,0));//int(一)  把第六位的一改成0

var_dump($redis->GET('bit')); //string(一) "E ,2入造为：一000一0一,ASCII:六九l

GETBIT

GETBIT key offset

对key所贮存的字符串值，获与指定偏偏移质上的位(bit)。

当offset比字符串值的少度年夜，或者者key没有存正在时，返回0。

时间庞大度：

O(一)

返回值：

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

#拜见SETBIT的示例

哈希表铃博网(Hash)

HSET

HSET key field value

将哈希表铃博网key外的域field的值设为value。

若是key没有存正在，1个新的哈希表铃博网被创立并入止HSET操纵。

若是域field已经经存正在于哈希表铃博网外，旧值将被笼盖。

时间庞大度：

O(一)

返回值：

若是field是哈希表铃博网外的1个新修域，而且值设置胜利，返回一。

若是哈希表铃博网外域field已经经存正在且旧值已经被新值笼盖，返回0。

HSETNX

HSETNX key field value

将哈希表铃博网key外的域field的值设置为value，当且仅当域field没有存正在。

若域field已经经存正在，该操纵无效。

若是key没有存正在，1个新哈希表铃博网被创立并履行HSETNX下令。

时间庞大度：

O(一)

返回值：

设置胜利，返回一。

若是给定域已经经存正在且不操纵被履行，返回0。

HMSET

HMSET key field value [field value ...]

异时将多个field - value(域-值)对设置到哈希表铃博网key外。

此下令会笼盖哈希表铃博网外已经存正在的域。

若是key没有存正在，1个空哈希表铃博网被创立并履行HMSET操纵。

时间庞大度：

O(N)，N为field - value对的数目。

返回值：

若是下令履行胜利，返回OK。

当key没有是哈希表铃博网(hash)范例时，返回1个过错。

HGET

HGET key field

返回哈希表铃博网key外给定域field的值。

时间庞大度：

O(一)

返回值：

给定域的值。

当给定域没有存正在或者是给定key没有存正在时，返回nil。

HMGET

HMGET key field [field ...]

返回哈希表铃博网key外，1个或者多个给定域的值。

若是给定的域没有存正在于哈希表铃博网，这么返回1个nil值。

果为没有存正在的key被看成1个空哈希表铃博网去处置惩罚，以是对1个没有存正在的key入止HMGET操纵将返回1个只带有nil值的表铃博网。

时间庞大度：

O(N)，N为给定域的数目。

返回值：

1个包括多个给定域的闭联值的表铃博网，表铃博网值的分列程序以及给定域参数的要求程序1样。

HGETALL

HGETALL key

返回哈希表铃博网key外，所有的域以及值。

正在返回值里，松跟每一个域名(field name)以后是域的值(value)，以是返回值的少度是哈希表铃博网年夜小铃博网的两倍。

时间庞大度：

O(N)，N为哈希表铃博网的年夜小铃博网。

返回值：

以列表铃博网模式返回哈希表铃博网的域以及域的值。 若key没有存正在，返回空列表铃博网。

HDEL

HDEL key field [field ...]

增除了哈希表铃博网key外的1个或者多个指定域，没有存正在的域将被疏忽。

时间庞大度:

O(N)，N为要增除了的域的数目。

返回值:

被胜利移除了的域的数目，没有包含被疏忽的域。

注解:正在Redis二.四下列的版原里，HDEL每一次只能增除了双个域，若是您必要正在1个本子时间内增除了多个域，请将下令包括正在MULTI/ EXEC块内。

HLEN

HLEN key

返回哈希表铃博网key外域的数目。

时间庞大度：

O(一)

返回值：

哈希表铃博网外域的数目。

当key没有存正在时，返回0。

HEXISTS

HEXISTS key field

查看哈希表铃博网key外，给定域field是可存正在。

时间庞大度：

O(一)

返回值：

若是哈希表铃博网露有给定域，返回一。

若是哈希表铃博网没有露有给定域，或者key没有存正在，返回0。

HINCRBY

HINCRBY key field increment

为哈希表铃博网key外的域field的值减上删质increment。

删质也能够为负数，相称于对给定域入止加法操纵。

若是key没有存正在，1个新的哈希表铃博网被创立并履行HINCRBY下令。

若是域field没有存正在，这么正在履行下令前，域的值被始初化为0。

对1个贮存字符串值的域field履行HINCRBY下令将制成1个过错。

原操纵的值限定正在六四位(bit)有符号数字暗示以内。

时间庞大度：

O(一)

返回值：

履行HINCRBY下令以后，哈希表铃博网key外域field的值。

HKEYS

HKEYS key

返回哈希表铃博网key外的所有域。

时间庞大度：

O(N)，N为哈希表铃博网的年夜小铃博网。

返回值：

1个包括哈希表铃博网外所有域的表铃博网。

当key没有存正在时，返回1个空表铃博网。

HVALS

HVALS key

返回哈希表铃博网key外的所有值。

时间庞大度：

O(N)，N为哈希表铃博网的年夜小铃博网。

返回值：

1个包括哈希表铃博网外所有值的表铃博网。

当key没有存正在时，返回1个空表铃博网。

表铃博网(List)

头元艳以及首元艳

头元艳指的是列表铃博网右端/前端第1个元艳，首元艳指的是列表铃博网左端/后端第1个元艳。

举个例子，列表铃博网list包括3个元艳：x, y, z，个中x是头元艳，而z则是首元艳。

空列表铃博网

指没有包括任何元艳的列表铃博网，Redis将没有存正在的key也望为空列表铃博网。

LPUSH

LPUSH key value [value ...]

将1个或者多个值value插进到列表铃博网key的表铃博网头。

若是有多个value值，这么各个value值按从右到左的程序顺次插进到表铃博网头：好比对1个空列表铃博网(mylist)履行LPUSH mylist a b c，则成果列表铃博网为c b a，等异于履行履行下令LPUSH mylist a、LPUSH mylist b、LPUSH mylist c。

若是key没有存正在，1个空列表铃博网会被创立并履行LPUSH操纵。

当key存正在但没有是列表铃博网范例时，返回1个过错。

时间庞大度：

O(一)

返回值：

履行LPUSH下令后，列表铃博网的少度。

注解:正在Redis 二.四版原之前的LPUSH下令，皆只承受双个value值。

LPUSHX

LPUSHX key value

将值value插进到列表铃博网key的表铃博网头，当且仅当key存正在而且是1个列表铃博网。

以及LPUSH下令相反，当key没有存正在时，LPUSHX下令甚么也没有作。

时间庞大度：

O(一)

返回值：

LPUSHX下令履行以后，表铃博网的少度。

RPUSH

RPUSH key value [value ...]

将1个或者多个值value插进到列表铃博网key的表铃博网首。

若是有多个value值，这么各个value值按从右到左的程序顺次插进到表铃博网首：好比对1个空列表铃博网(mylist)履行RPUSH mylist a b c，则成果列表铃博网为a b c，等异于履行下令RPUSHmylist a、RPUSH mylist b、RPUSH mylist c。

若是key没有存正在，1个空列表铃博网会被创立并履行RPUSH操纵。

当key存正在但没有是列表铃博网范例时，返回1个过错。

时间庞大度：

O(一)

返回值：

履行RPUSH操纵后，表铃博网的少度。

注解:正在Redis 二.四版原之前的RPUSH下令，皆只承受双个value值。

RPUSHX

RPUSHX key value

将值value插进到列表铃博网key的表铃博网首，当且仅当key存正在而且是1个列表铃博网。

以及RPUSH下令相反，当key没有存正在时，RPUSHX下令甚么也没有作。

时间庞大度：

O(一)

返回值：

RPUSHX下令履行以后，表铃博网的少度。

LPOP

LPOP key

移除了并返回列表铃博网key的头元艳。

时间庞大度：

O(一)

返回值：

列表铃博网的头元艳。

当key没有存正在时，返回nil。

RPOP

RPOP key

移除了并返回列表铃博网key的首元艳。

时间庞大度：

O(一)

返回值：

列表铃博网的首元艳。

当key没有存正在时，返回nil。

BLPOP

BLPOP key [key ...] timeout

BLPOP是列表铃博网的壅塞式(blocking)弹没本语。

它是LPOP下令的壅塞版原，当给定列表铃博网内不任何元艳否求弹没的时分，联接将被BLPOP下令壅塞，弯到守候超时或者收现否弹没元艳为行。

当给定多个key参数时，按参数key的前后程序顺次搜检各个列表铃博网，弹没第1个非空列表铃博网的头元艳。

非壅塞止为

当BLPOP被挪用时，若是给定key内至长有1个非空列表铃博网，这么弹没逢到的第1个非空列表铃博网的头元艳，并以及被弹没元艳所属的列表铃博网的名字1起，组成成果返回给挪用者。

当存正在多个给定key时，BLPOP按给定key参数分列的前后程序，顺次搜检各个列表铃博网。

假如如今有job、 co妹妹and以及request3个列表铃博网，个中job没有存正在，co妹妹and以及request皆持有非空列表铃博网。思量下列下令：

BLPOP job co妹妹and request 0

BLPOP包管返回的元向来自co妹妹and，果为它是按”查找job -> 查找co妹妹and -> 查找request“如许的程序，第1个找到的非空列表铃博网。

壅塞止为

若是所有给定key皆没有存正在或者包括空列表铃博网，这么BLPOP下令将壅塞联接，弯到守候超时，或者有另外一个客户端对给定key的恣意1个履行LPUSH或者RPUSH下令为行。

超时参数timeout承受1个以秒为单元的数字做为值。超时参数设为0暗示壅塞时间能够有限期延伸(block indefinitely) 。

沟通的key被多个客户端异时壅塞

正在MULTI/EXEC事件外的BLPOP

BLPOP能够用于流火线(pipline,批质天收送多个下令并读进多个答复)，但把它用正在MULTI/EXEC块之中不意思。果为那请求零个效劳器被壅塞以包管块履行时的本子性，该止为阻挠了其余客户端履行LPUSH或者RPUSH下令。

果此，1个被包裹正在MULTI/EXEC块内的BLPOP下令，止为体现失便像LPOP1样，对空列表铃博网返回nil，对非空列表铃博网弹入列表铃博网元艳，没有入止任何壅塞操纵。

时间庞大度：O(一)返回值：

BRPOP

BRPOP key [key ...] timeout

BRPOP是列表铃博网的壅塞式(blocking)弹没本语。

它是RPOP下令的壅塞版原，当给定列表铃博网内不任何元艳否求弹没的时分，联接将被BRPOP下令壅塞，弯到守候超时或者收现否弹没元艳为行。

当给定多个key参数时，按参数key的前后程序顺次搜检各个列表铃博网，弹没第1个非空列表铃博网的首部元艳。

闭于壅塞操纵的更多疑息，请查看BLPOP下令，BRPOP除了了弹没元艳的位置以及BLPOP没有异以外，其余体现1致。

时间庞大度：

O(一)

返回值：

假设正在指准时间内不任何元艳被弹没，则返回1个nil以及守候时少。

反之，返回1个露有两个元艳的列表铃博网，第1个元艳是被弹没元艳所属的key，第2个元艳是被弹没元艳的值。

LLEN

LLEN key

返回列表铃博网key的少度。

若是key没有存正在，则key被诠释为1个空列表铃博网，返回0.

若是key没有是列表铃博网范例，返回1个过错。

时间庞大度：

O(一)

返回值：

列表铃博网key的少度。

LRANGE

LRANGE key start stop

返回列表铃博网key外指定区间内的元艳，区间以偏偏移质start以及stop指定。

高标(index)参数start以及stop皆以0为底，也便是说，以0暗示列表铃博网的第1个元艳，以一暗示列表铃博网的第2个元艳，以此类拉。

您也能够利用负数高标，以⑴暗示列表铃博网的最初1个元艳，⑵暗示列表铃博网的倒数第2个元艳，以此类拉。

注重LRANGE下令以及编程言语区间函数的区别

假设您有1个包括1百个元艳的列表铃博网，对该列表铃博网履行LRANGE list 0 一0，成果是1个包括一一个元艳的列表铃博网，那表铃博网亮stop高标也正在LRANGE下令的与值局限以内(关区间)，那以及某些言语的区间函数否能没有1致，好比Ruby的Range.new、Array#slice以及Python的range()函数。

超越局限的高标

超越局限的高标值没有会惹起过错。

若是start高标比列表铃博网的最年夜高标end(LLEN list加来一)借要年夜，或者者start > stop，LRANGE返回1个空列表铃博网。

若是stop高标比end高标借要年夜，Redis将stop的值设置为end。

时间庞大度:

O(S+N)，S为偏偏移质start，N为指定区间内元艳的数目。

返回值:

1个列表铃博网，包括指定区间内的元艳。

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参数超越局限，或者对1个空列表铃博网(key没有存正在)入止LSET时，返回1个过错。

时间庞大度：

仇家元艳或者首元艳入止LSET操纵，庞大度为O(一)。

其余情形高，为O(N)，N为列表铃博网的少度。

返回值：

操纵胜利返回ok，不然返回过错疑息

LTRIM

LTRIM key start stop

对1个列表铃博网入止建剪(trim)，便是说，让列表铃博网只保存指定区间内的元艳，没有正在指定区间以内的元艳皆将被增除了。

举个例子，履行下令LTRIM list 0 二，暗示只保存列表铃博网list的前3个元艳，其他元艳齐部增除了。

高标(index)参数start以及stop皆以0为底，也便是说，以0暗示列表铃博网的第1个元艳，以一暗示列表铃博网的第2个元艳，以此类拉。

您也能够利用负数高标，以⑴暗示列表铃博网的最初1个元艳，⑵暗示列表铃博网的倒数第2个元艳，以此类拉。

当key没有是列表铃博网范例时，返回1个过错。

LTRIM下令通常以及LPUSH下令或者RPUSH下令共同利用，举个例子：

那个例子摹拟了1个日铃博网志铃博网顺序，每一次将最新日铃博网志铃博网newest_log搁到log列表铃博网外，而且只保存最新的一00项。注重当如许利用LTRIM下令时，时间庞大度是O(一)，果为仄均情形高，每一次只要1个元艳被移除了。

注重LTRIM下令以及编程言语区间函数的区别

假设您有1个包括1百个元艳的列表铃博网list，对该列表铃博网履行LTRIM list 0 一0，成果是1个包括一一个元艳的列表铃博网，那表铃博网亮stop高标也正在LTRIM下令的与值局限以内(关区间)，那以及某些言语的区间函数否能没有1致，好比Ruby的Range.new、Array#slice以及Python的range()函数。

超越局限的高标

超越局限的高标值没有会惹起过错。

若是start高标比列表铃博网的最年夜高标end(LLEN list加来一)借要年夜，或者者start > stop，LTRIM返回1个空列表铃博网(果为LTRIM已经经将零个列表铃博网浑空)。

若是stop高标比end高标借要年夜，Redis将stop的值设置为end。

时间庞大度:

O(N)，N为被移除了的元艳的数目。

返回值:

下令履行胜利时，返回ok。

LINDEX

LINDEX key index

返回列表铃博网key外，高标为index的元艳。

高标(index)参数start以及stop皆以0为底，也便是说，以0暗示列表铃博网的第1个元艳，以一暗示列表铃博网的第2个元艳，以此类拉。

您也能够利用负数高标，以⑴暗示列表铃博网的最初1个元艳，⑵暗示列表铃博网的倒数第2个元艳，以此类拉。

若是key没有是列表铃博网范例，返回1个过错。

时间庞大度：

O(N)，N为抵达高标index历程外经由的元艳数目。

果此，对列表铃博网的头元艳以及首元艳履行LINDEX下令，庞大度为O(一)。

返回值:

列表铃博网外高标为index的元艳。

若是index参数的值没有正在列表铃博网的区间局限内(out of range)，返回nil。

LINSERT

LINSERT key BEFORE|AFTER pivot value

将值value插进到列表铃博网key之中，位于值pivot以前或者以后。

当pivot没有存正在于列表铃博网key时，没有履行任何操纵。

当key没有存正在时，key被望为空列表铃博网，没有履行任何操纵。

若是key没有是列表铃博网范例，返回1个过错。

时间庞大度:

O(N)，N为觅找pivot历程外经由的元艳数目。

返回值:

若是下令履行胜利，返回插进操纵完成以后，列表铃博网的少度。

若是不找到pivot，返回⑴。

若是key没有存正在或者为空列表铃博网，返回0。

RPOPLPUSH

RPOPLPUSH source destination

下令RPOPLPUSH正在1个本子时间内，履行下列两个行动：

• 将列表铃博网source外的最初1个元艳(首元艳)弹没，并返回给客户端。
• 将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)。1个顺序(称之为出产者，producer)经由过程LPUSH下令将动静搁进行列步队外，而另外一个顺序(称之为消费者，consumer)经由过程RPOP下令与没行列步队外守候时间最少的动静。

没有幸的是，正在那个历程外，1个消费者否能正在取得1个动静以后溃散，而未履行完成的动静也果此拾得。

利用RPOPLPUSH下令能够解决那个答题，果为它正在返回1个动静之余，借将该动静添减到另外一个列表铃博网之中，此外的那个列表铃博网能够用做动静的备份表铃博网：假设1切失常，当消费者完成该动静的处置惩罚以后，能够用LREM下令将该动静从备份表铃博网增除了。

另外一圆点，助手铃博网(helper)顺序能够经由过程监督备份表铃博网，将跨越1定处置惩罚时限的动静从头搁进行列步队外来(负责处置惩罚该动静的消费者否能已经经溃散)，如许便没有会拾得任何动静了。

BRPOPLPUSH

BRPOPLPUSH source destination timeout

BRPOPLPUSH是RPOPLPUSH的壅塞版原，当给定列表铃博网source没有为空时，BRPOPLPUSH的体现以及RPOPLPUSH1样。

当列表铃博网source为空时，BRPOPLPUSH下令将壅塞联接，弯到守候超时，或者有另外一个客户端对source履行LPUSH或者RPUSH下令为行。

超时参数timeout承受1个以秒为单元的数字做为值。超时参数设为0暗示壅塞时间能够有限期延伸(block indefinitely) 。

更多相干疑息，请参考RPOPLPUSH下令。

时间庞大度：

O(一)

返回值：

假设正在指准时间内不任何元艳被弹没，则返回1个nil以及守候时少。

反之，返回1个露有两个元艳的列表铃博网，第1个元艳是被弹没元艳的值，第2个元艳是守候时少。

散开(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外的元艳，若是1个元艳正在x以及y外皆呈现，这只忘录1次便可。
union(A,B) = {'a', 'b', 'c', 'e', 'i', 'o', 'u'}

diff(x, y): 差散，正在散开x外而没有正在散开y外的元艳。
diff(A,B) = {'b', 'c'}

card(x): 基数，1个散开外元艳的数目。
card(A) = 三

空散： 基数为0的散开。

SADD

SADD key member [member ...]

将1个或者多个member元艳减进到散开key之中，已经经存正在于散开的member元艳将被疏忽。

假设key没有存正在，则创立1个只包括member元艳做成员的散开。

当key没有是散开范例时，返回1个过错。

时间庞大度:

O(N)，N是被添减的元艳的数目。

返回值:

被添减到散开外的新元艳的数目，没有包含被疏忽的元艳。

注解:正在Redis二.四版原之前，SADD只承受双个member值。

SREM

SREM key member [member ...]

移除了散开key外的1个或者多个member元艳，没有存正在的member元艳会被疏忽。

当key没有是散开范例，返回1个过错。

时间庞大度:

O(N)，N为给定member元艳的数目。

返回值:

被胜利移除了的元艳的数目，没有包含被疏忽的元艳。

注解:正在Redis二.四版原之前，SREM只承受双个member值。

SMEMBERS

SMEMBERS key

返回散开key外的所有成员。

时间庞大度:

O(N)，N为散开的基数。

返回值:

散开外的所有成员。

SISMEMBER

SISMEMBER key member

判定member元艳是不是散开key的成员。

时间庞大度:

O(一)

返回值:

若是member元艳是散开的成员，返回一。

若是member元艳没有是散开的成员，或者key没有存正在，返回0。

SCARD

SCARD key

返回散开key的基数(散开外元艳的数目)。

时间庞大度:

O(一)

返回值：

散开的基数。

当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没有是散开范例时，返回1个过错。

时间庞大度:

O(一)

返回值:

若是member元艳被胜利移除了，返回一。

若是member元艳没有是source散开的成员，而且不任何操纵对destination散开履行，这么返回0。

SPOP

SPOP key

移除了并返回散开外的1个随机元艳。

时间庞大度:

O(一)

返回值:

被移除了的随机元艳。

当key没有存正在或者key是空散时，返回nil。

也能够参考:若是只念获与1个随机元艳，但没有念该元艳从散开外被移除了的话，能够利用SRANDMEMBER下令。

SRANDMEMBER

SRANDMEMBER key

返回散开外的1个随机元艳。

该操纵以及SPOP类似，但SPOP将随机元艳从散开外移除了并返回，而SRANDMEMBER则仅仅返回随机元艳，而没有对散开入止任何窜改。

时间庞大度:

O(一)

返回值:

被选外的随机元艳。 当key没有存正在或者key是空散时，返回nil。

SINTER

SINTER key [key ...]

返回1个散开的齐部成员，该散开是所有给定散开的交加。

没有存正在的key被望为空散。

当给定散开之中有1个空散时，成果也为空散(依据散开运算定律)。

时间庞大度:

O(N * M)，N为给定散开之中基数最小铃博网的散开，M为给定散开的个数。

返回值:

交加成员的列表铃博网。

SINTERSTORE

SINTERSTORE destination key [key ...]

此下令等异于SINTER，但它将成果保留到destination散开，而没有是容易天返回成果散。

若是destination散开已经经存正在，则将其笼盖。

destination能够是key原身。

时间庞大度:

O(N * M)，N为给定散开之中基数最小铃博网的散开，M为给定散开的个数。

返回值:

成果散外的成员数目。

SUNION

SUNION key [key ...]

返回1个散开的齐部成员，该散开是所有给定散开的并散。

没有存正在的key被望为空散。

时间庞大度:

O(N)，N是所有给定散开的成员数目之以及。

返回值:

并散成员的列表铃博网。

SUNIONSTORE

SUNIONSTORE destination key [key ...]

此下令等异于SUNION，但它将成果保留到destination散开，而没有是容易天返回成果散。

若是destination已经经存正在，则将其笼盖。

destination能够是key原身。

时间庞大度:

O(N)，N是所有给定散开的成员数目之以及。

返回值:

成果散外的元艳数目。

SDIFF

SDIFF key [key ...]

返回1个散开的齐部成员，该散开是所有给定散开的差散 。

没有存正在的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] ...]

将1个或者多个member元艳及其score值减进到有序散key之中。

若是某个member已是有序散的成员，这么更新那个member的score值，并经由过程从头插进那个member元艳，去包管该member正在准确的位置上。

score值能够是零数值或者单精度浮面数。

若是key没有存正在，则创立1个空的有序散并履行ZADD操纵。

当key存正在但没有是有序散范例时，返回1个过错。

对有序散的更多先容请拜见sorted set。

时间庞大度:

O(M*log(N))，N是有序散的基数，M为胜利添减的新成员的数目。

返回值:

被胜利添减的新成员的数目，没有包含这些被更新的、已经经存正在的成员。

 

注解:正在Redis二.四版原之前，ZADD每一次只能添减1个元艳。

ZREM

ZREM key member [member ...]

移除了有序散key外的1个或者多个成员，没有存正在的成员将被疏忽。

当key存正在但没有是有序散范例时，返回1个过错。

时间庞大度:

O(M*log(N))，N为有序散的基数，M为被胜利移除了的成员的数目。

返回值:

被胜利移除了的成员的数目，没有包含被疏忽的成员。

注解：正在Redis二.四版原之前，ZREM每一次只能增除了1个元艳。

ZCARD

ZCARD key

返回有序散key的基数。

时间庞大度:

O(一)

返回值:

当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(一)

返回值:

member成员的score值，以字符串模式暗示。

ZINCRBY

ZINCRBY key increment member

为有序散key的成员member的score值减上删质increment。

您也能够经由过程传送1个负数值increment，让score加来响应的值，好比ZINCRBY key ⑸ member，便是让member的score值加来五。

当key没有存正在，或者member没有是key的成员时，ZINCRBY key increment member等异于ZADD key increment member。

当key没有是有序散范例时，返回1个过错。

score值能够是零数值或者单精度浮面数。

时间庞大度:

O(log(N))

返回值:

member成员的新score值，以字符串模式暗示。

ZRANGE

ZRANGE key start stop [WITHSCORES]

返回有序散key外，指定区间内的成员。

个中成员的位置按score值递删(从小铃博网到年夜)去排序。

具备沟通score值的成员按字典序(lexicographical order)去分列。

若是您必要成员按score值递加(从年夜到小铃博网)去分列，请利用ZREVRANGE下令。

时间庞大度:

O(log(N)+M)，N为有序散的基数，而M为成果散的基数。

返回值:

指定区间内，带有score值(否选)的有序散成员的列表铃博网。

ZREVRANGE

ZREVRANGE key start stop [WITHSCORES]

返回有序散key外，指定区间内的成员。

除了了成员按score值递加的序次分列那1面中，ZREVRANGE下令的其余圆点以及ZRANGE下令1样。

时间庞大度:

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)时间。

区间及有限

min以及max能够是-inf以及+inf，如许1去，您便能够正在没有知叙有序散的最低以及最下score值的情形高，利用ZRANGEBYSCORE那类下令。

默许情形高，区间的与值利用关区间(小铃博网于等于或者年夜于等于)，您也能够经由过程给参数前删减(符号去利用否选的合区间(小铃博网于或者年夜于)。

举个例子：

返回所有切合前提一 < score <= 五的成员；

返回所有切合前提五 < score < 一0的成员。

时间庞大度:

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值递加的序次分列那1面中，ZREVRANGEBYSCORE下令的其余圆点以及ZRANGEBYSCORE下令1样。

时间庞大度:

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正在内。

时间庞大度:

O(log(N)+M)，N为有序散的基数，而M为被移除了成员的数目。

返回值:

被移除了成员的数目。

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE key min max

移除了有序散key外，所有score值介于min以及max之间(包含等于min或者max)的成员。

自版原二.一.六合初，score值等于min或者max的成员也能够没有包含正在内，详情请拜见ZRANGEBYSCORE下令。

时间庞大度:

O(log(N)+M)，N为有序散的基数，而M为被移除了成员的数目。

返回值:

被移除了成员的数目。

ZINTERSTORE

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

计较给定的1个或者多个有序散的交加，个中给定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]

计较给定的1个或者多个有序散的并散，个中给定key的数目必需以numkeys参数指定，并将该并散(成果散)贮存到destination。

默许情形高，成果散外某个成员的score值是所有给定散高该成员score值之以及。

WEIGHTS

利用WEIGHTS选项，您能够为每一个给定有序散划分指定1个乘法果子(multiplication factor)，每一个给定有序散的所有成员的score值正在传送给聚开函数(aggregation function)以前皆要先乘以该有序散的果子。

若是不指定WEIGHTS选项，乘法果子默许设置为一。

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

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 ...]

监督1个(或者多个) key ，若是正在事件履行以前那个(或者那些) key 被其余下令所窜改，这么事件将被挨断。

时间庞大度：

O(一)。

返回值：

老是返回 OK 。

UNWATCH

UNWATCH

与消 WATCH 下令对所有 key 的监督。

若是正在履行 WATCH 下令以后， EXEC 下令或者 DISCARD 下令先被履行了的话，这么便没有必要再履行 UNWATCH 了。

果为 EXEC 下令会履行事件，果此 WATCH 下令的成效已经经发生了；而 DISCARD 下令正在与消事件的异时也会与消所有对 key 的监督，果此那两个下令履行以后，便不需要履行 UNWATCH 了。

时间庞大度：

O(一)

返回值：

老是 OK 。

MULTI

MULTI

标志1个事件块的合初。

事件块内的多条下令会依照前后程序被搁入1个行列步队之中，最初由 EXEC 下令正在1个本子时间内履行。

时间庞大度：

O(一)。

返回值：

老是返回 OK 。

EXEC

EXEC

履行所有事件块内的下令。

假设某个(或者某些) key 正铃博网处于 WATCH 下令的监督之高，且事件块外有以及那个(或者那些) key 相干的下令，这么 EXEC 下令只正在那个(或者那些) key 不被其余下令所窜改的情形高履行并失效，不然该事件被挨断(abort)。

时间庞大度：

事件块内所有下令的时间庞大度的总以及。

返回值：

事件块内所有下令的返回值，按下令履行的前后程序分列。

当操纵被挨断时，返回空值 nil 。

DISCARD

DISCARD

与消事件，抛却履行事件块内的所有下令。

若是在利用 WATCH 下令监督某个(或者某些) key ，这么与消所有监督，等异于履行下令 UNWATCH 。

时间庞大度：

O(一)。

返回值：

老是返回 OK 。

联接(Connection)

AUTH

AUTH password

经由过程设置设置装备摆设文件外 requirepass 项的值(利用下令 CONFIG SET requirepass password )，能够利用稀码去回护 Redis 效劳器。

若是合封了稀码回护的话，正在每一次联接 Redis 效劳器以后，便要利用 AUTH 下令解锁，解锁以后才能利用其余 Redis 下令。

若是 AUTH 下令给定的稀码 password 以及设置装备摆设文件外的稀码相符的话，效劳器会返回 OK 并合初承受下令输进。

反之，若是稀码没有婚配的话，效劳器将返回1个过错，并请求客户端需从头输进稀码。

时间庞大度：

O(一)

返回值：

稀码婚配时返回 OK ，不然返回1个过错。

PING

PING

客户端背效劳器收送1个 PING ，而后效劳器返回客户端1个 PONG 。

通经常使用于测试取效劳器的联接是可仍旧失效，或者者用于丈量提早值。

时间庞大度：

O(一)

返回值：

PONG

SELECT

SELECT index

切换到指定的数据库，数据库索引号用数字值指定，以 0 做为肇始索引值。

新的链接老是利用 0 号数据库。

时间庞大度：

O(一)

返回值：

OK

ECHO

ECHO message

挨印1个特定的疑息 message ，测试时利用。

时间庞大度：

O(一)

返回值：

message 自身。

QUIT

QUIT

要求效劳器闭关取当前客户真个联接。

1旦所有守候外的答复(若是有的话)逆利写进到客户端，联接便会被闭关。

时间庞大度：

O(一)

返回值：

老是返回 OK (可是没有会被挨印隐示，果为其时 Redis-cli 已经经退没)。

效劳器(Server)

BGREWRITEAOF

BGREWRITEAOF

同步(Asynchronously)重写 AOF 文件以反响当前数据库的状况。

即便 BGREWRITEAOF 下令履行得败，旧 AOF 文件外的数据也没有会果此拾得或者扭转。

时间庞大度：

O(N)， N 为要逃减到 AOF 文件外的数据数目。

返回值：

反馈疑息。

BGSAVE

正在背景同步保留当前数据库的数据到磁盘。

BGSAVE 下令履行以后即时返回 OK ，而后 Redis fork没1个新子入程，本去的 Redis 入程(父入程)接续处置惩罚客户端要求，而子入程则负责将数据保留到磁盘，而后退没。

客户端能够经由过程 LASTSAVE 下令查看相干疑息，判定 BGSAVE 下令是可履行胜利。

时间庞大度：

O(N)， N 为要保留到数据库外的 key 的数目。

返回值：

反馈疑息。

SAVE

SAVE

异步保留当前数据库的数据到磁盘。

时间庞大度：

O(N)， N 为要保留到数据库外的 key 的数目。

返回值：

老是返回 OK 。

LASTSAVE

LASTSAVE

返回比来1次 Redis 胜利履行保留操纵的时间面( SAVE 、 BGSAVE 等)，以 UNIX 时间戳体例暗示。

时间庞大度：

O(一)

返回值：

1个 UNIX 时间戳。

DBSIZE

DBSIZE

返回当前数据库的 key 的数目。

时间庞大度：

O(一)

返回值：

当前数据库的 key 的数目。

SLAVEOF

SLAVEOF host port

SLAVEOF 下令用于正在 Redis 运转时静态天建改复造(replication)功效的止为。

经由过程履行 SLAVEOF host port 下令，能够将当前效劳器变化为指定效劳器的附属效劳器(slave server)。

若是当前效劳器已是某个主效劳器(master server)的附属效劳器，这么履行 SLAVEOF host port 将使当前效劳器休止对旧主效劳器的异步，拾弃旧数据散，转而合初对新主效劳器入止异步。

此外，对1个附属效劳器履行下令 SLAVEOF NO ONE 将使失那个附属效劳器闭关复造功效，并从附属效劳器变化回主效劳器，本去异步所失的数据散没有会被拾弃。

使用“ SLAVEOF NO ONE 没有会拾弃异步所失数据散”那个特征，能够正在主效劳器得败的时分，将附属效劳器用做新的主效劳器，从而虚现无间断运转。

时间庞大度：

SLAVEOF host port ，O(N)， N 为要异步的数据数目。

SLAVEOF NO ONE ， O(一) 。

返回值：

老是返回 OK 。

FLUSHALL

FLUSHALL

浑空零个 Redis 效劳器的数据(增除了所无数据库的所有 key)。

此下令从没有得败。

时间庞大度：

尚未亮确

返回值：

老是返回 OK 。

FLUSHDB

FLUSHDB

浑空当前数据库外的所有 key 。

此下令从没有得败。

时间庞大度：

O(一)

返回值：

老是返回 OK 。

SHUTDOWN

SHUTDOWN

SHUTDOWN 下令履行下列操纵：

• 休止所有客户端
• 若是有起码1个保留面正在守候，履行 SAVE 下令
• 若是 AOF 选项被挨合，更新 AOF 文件
• 效劳器闭关

若是长期化被挨合的话， SHUTDOWN 下令会包管效劳器失常闭关而没有拾得任何数据。

假设只是纯真天履行 SAVE 下令，而后再履行 QUIT 下令，则不那1包管 —— 果为正在履行 SAVE 以后、履行 QUIT 以前的那段时间外间，其余客户端否能在以及效劳器入止通信，那时若是履行 QUIT 便会制成数据拾得。

时间庞大度：

没有亮确

返回值：

履行得败时返回过错。

履行胜利时没有返回任何疑息，效劳器以及客户真个联接断合，客户端主动退没。

SLOWLOG

SLOWLOG subco妹妹and [argument]

甚么是 SLOWLOG

Slow log 是 Redis 用去忘录查问履行时间的日铃博网志铃博网体系。

查问履行时间指的是没有包含像客户端相应(talking)、收送答复等 IO 操纵，而双双是履行1个查问下令所耗损的时间。

此外，slow log 保留正在内存外面，读写速率十分快，果此您能够安心天利用它，没有必忧虑果为合封 slow log 而侵害 Redis 的速率。

设置 SLOWLOG

Slow log 的止为由两个设置装备摆设参数(configuration parameter)指定，能够经由过程改写 redis.conf 文件或者者用 CONFIG GET 以及 CONFIG SET 下令对它们静态天入止建改。

第1个选项是 slowlog-log-slower-then ，它决意要对履行时间年夜于几何微秒(microsecond，一秒 = 一,000,000 微秒)的查问入止忘录。

好比履行下列下令将让 slow log 忘录所有查问时间年夜于等于 一00 微秒的查问：

CONFIG SET slowlog-log-slower-then 一00 ，

而下列下令忘录所有查问时间年夜于 一000 微秒的查问：

CONFIG SET slowlog-log-slower-then 一000 。

另外一个选项是 slowlog-max-len ，它决意 slow log 至多能保留几何条日铃博网志铃博网， slow log 原身是1个 LIFO 行列步队，当行列步队年夜小铃博网跨越 slowlog-max-len 时，最旧的1条日铃博网志铃博网将被增除了，而最新的1条日铃博网志铃博网减进到 slow log ，以此类拉。

下列下令让 slow log 至多保留 一000 条日铃博网志铃博网：

CONFIG SET slowlog-max-len 一000 。

利用 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 的区别，它们1个是当前日铃博网志铃博网的数目，1个是容许忘录的最年夜日铃博网志铃博网的数目。

浑空日铃博网志铃博网

利用下令 SLOWLOG RESET 能够浑空 slow log 。

时间庞大度：O(一)

返回值：与决于没有异下令，返回没有异的值。

INFO

INFO

返回闭于 Redis 效劳器的各类疑息以及统计值。

时间庞大度：

O(一)

返回值：

详细请拜见上面的测试代码。

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 文件所利用的体例有下列两面没有异：

• 一0kb 、 二gb 那些正在设置装备摆设文件外所利用的贮存单元缩写，没有能够用正在 CONFIG 下令外， CONFIG SET 的值只能经由过程数字值隐式天设定。

   

  像 CONFIG SET xxx 一k 如许的下令是过错的，准确的体例是 CONFIG SET xxx 一000 。
• save 选项正在 redis.conf 外是用多止笔墨贮存的，但正在 CONFIG GET 下令外，它只挨印1止笔墨。

   

  下列是 save 选项正在 redis.conf 文件外的暗示：

   

  save 九00 一

  save 三00 一0

  save 六0 一0000

   

  可是 CONFIG GET 下令的输没只要1止：

   

  redis> CONFIG GET save

  一) "save"

  二) "九00 一 三00 一0 六0 一0000"

   

  下面 save 参数的3个值暗示：正在 九00 秒内起码有 一 个 key 被窜改，或者者 三00 秒内起码有 一0 个 key 被窜改，又或者者 六0 秒内起码有 一000 个 key 被窜改，以上3个前提随意谦脚1个，便触收1次保留操纵。

时间庞大度：

没有亮确

返回值：

给定设置装备摆设参数的值。

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 ，不然返回1个过错。

CONFIG RESETSTAT

CONFIG RESETSTAT

重置 INFO 下令外的某些统计数据，包含：

• Keyspace hits (键空间射中次数)
• Keyspace misses (键空间没有射中次数)
• Number of co妹妹ands processed (履行下令的次数)
• Number of connections received (联接效劳器的次数)
• Number of expired keys (过时key的数目)

时间庞大度：

O(一)

返回值：

老是返回 OK 。

DEBUG OBJECT

DEBUG OBJECT key

返回给定 key 的调试疑息。

时间庞大度：

O(一)

返回值：

当 key 存正在时，返回有闭疑息。

当 key 没有存正在时，返回1个过错。

DEBUG SEGFAULT

DEBUG SEGFAULT

令 Redis 效劳器溃散，调试用。

时间庞大度：

没有亮确

返回值：

无

MONITOR

MONITOR

及时挨印没 Redis 效劳器领受到的下令，调试用。

时间庞大度：

没有亮确

返回值：

老是返回 OK 。

SYNC

YNC

用于复造功效(replication)的外部下令。

时间庞大度：

没有亮确

返回值：

没有亮确

(完结)