redis 在PHP中的应用 代码实例

 

<?php

/**
 * Redis::__construct构造函数
 * connect, open 链接redis服务
 * 参数：
 * 		host: string，服务地址
 * 		port: int，端口号
 * 		timeout: float，链接时长 (可选, 默认为 0 ，不限链接时间)
 * 	
 * 	注: 在redis.conf中也有时间，默认为300
 * 	pconnect, popen 不会主动关闭的链接
 * 	setOption 设置redis模式
 * 	getOption 查看redis设置的模式
 * 	ping 查看连接状态
 */
$redis = new Redis();

echo "<pre>";
$redis->connect("127.0.0.1","6379");  //php客户端设置的ip及端口

 

string类型

 

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */
/**
 * Redis::__construct构造函数
 * connect, open 链接redis服务
 * 参数：
 * 		host: string，服务地址
 * 		port: int，端口号
 * 		timeout: float，链接时长 (可选, 默认为 0 ，不限链接时间)
 * 	
 * 	注: 在redis.conf中也有时间，默认为300
 * 	pconnect, popen 不会主动关闭的链接
 * 	setOption 设置redis模式
 * 	getOption 查看redis设置的模式
 * 	ping 查看连接状态
 */

require_once('conn.php');

/**
 * key string 
 */

// 存储一个值
$redis->set("say", "Hello World!");
echo $redis->get('say')."\n";

// 存储多个值
$aArr = array(
		'first_key' => 'first value',
		'second_key' => 'second value',
		'third_key' => 'third value',
	);
$getArr = array(
		'first_key', 'second_key', 'third_key'
	);

$redis->mset($aArr);
print_r($redis->mget($getArr));

/**
 * setex 
 * 将值value关联到key，并将key的生存时间设为seconds(以秒为单位) 
 * 如果key 已经存在，SETEX命令将覆写旧值。
 * 类似于两行命令：
 * 		$redis->SET('key', 'value');
 * 		$redis->EXPIRE('key','seconds');  # 设置生存时间
 */
# 情况1：key不存在
$redis->setex('cache_user_id', 60,10086);//bool(true)
echo $redis->get('cache_user_id');  # 值 //"10086"
echo "\n";

// sleep(1);
echo $redis->ttl('cache_user_id');	# 剩余生存时间	//int(56)
echo "\n";

# 情况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"
echo "\n";

/**
 * setnx 
 * 将key的值设为value，当且仅当key不存在。
 * 若给定的key已经存在，则SETNX不做任何动作。
 * SETNX是”SET if Not eXists”(如果不存在，则SET)的简写。
 * 返回值：设置成功，返回1	设置失败，返回0
 */
echo '<br><br>SETNX<br>';
var_dump($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"
echo "\n";

/**
 * getset
 * 将给定key的值设为value，并返回key的旧值。
 * 当key存在但不是字符串类型时，返回一个错误。
 * 返回值：
 * 		返回给定key的旧值(old value)。
 * 		当key没有旧值时，返回nil。
 */
//GETSET
echo '<br><br>GETSET<br>';
var_dump($redis->exists('mail'));	//return bool(false);
var_dump($redis->getset('mail','xxx@google.com'));  # 因为mail之前不存在，没有旧值，返回nil ,#(nil)   //bool(false)
var_dump($redis->getset('mail','xxx@yahoo.com'));  # mail被更新，旧值被返回 //string(14) "xxx@google.com"
//设计模式
//GETSET可以和INCR组合使用，实现一个有原子性(atomic)复位操作的计数器(counter)。
//举例来说，每次当某个事件发生时，进程可能对一个名为mycount的key调用INCR操作，通常我们还要在一个原子时间内同时完成获得计数器的值和将计数器值复位为0两个操作。

// 切换到指定的数据库，数据库索引号用数字值指定，以 0 作为起始索引值。 
// 新的链接总是使用 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"

/**
 * incr
 * 将key中储存的数字值增一。
 * 如果key不存在，以0为key的初始值，然后执行INCR操作。
 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
 * 本操作的值限制在64位(bit)有符号数字表示之内。
 * 返回值：执行INCR命令之后key的值。
 * 注解:这是一个针对字符串的操作，因为Redis没有专用的整数类型，所以key内储存的字符串被解释为十进制64位有符号整数来执行INCR操作。
 */
echo '<br><br>INCR<br>';
$redis->set('page_view', 20);
var_dump($redis->incr('page_view')); //int(21) 
var_dump($redis->get('page_view'));    # 数字值在Redis中以字符串的形式保存 //string(2) "21

/**
 * incrby
 * 将key所储存的值加上增量increment。
 * 如果key不存在，以0为key的初始值，然后执行INCRBY命令。
 * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
 * 本操作的值限制在64位(bit)有符号数字表示之内。
 * 返回值：加上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', 30); #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)

/**
 * exist
 * 检查给定key是否存在。
 * 返回值：若key存在，返回1，否则返回0。
 */
// EXISTS
echo '<br><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)

/**
 * del
 * 移除给定的一个或多个key。
 * 如果key不存在，则忽略该命令。
 * 返回值：被移除key的数量。
 */
//DEL
// 情况1： 删除单个key
echo '<br><br>DEL<br>';
$redis->set('myname', 'ikodota');
echo $redis->get('myname').'';        // 返回:ikodota

echo "\n";
$redis->del('myname');                      // 返回 TRUE(1)
var_dump($redis->get('myname'));            // 返回 bool(false)

echo "\n";
// 情况2： 删除一个不存在的key
if(!$redis->exists('fake_key')){
    // 不存在
    var_dump($redis->del('fake_key'));      // 返回 int(0)
}

echo "\n";
// 情况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));        // 一次返回多个值

echo "\n";
$redis->del($array_mget);                   // 同时删除多个key
var_dump($redis->mget($array_mget));

/**
 * type
 * TYPE key，返回key所储存的值的类型
 * 返回值：
 * 		none(key不存在)：int(0)
 * 		string(字符串)：int(1)
 * 		set(集合)：int(2)
 * 		list(列表)：int(3)
 * 		zset(有序集)：int(4)
 * 		hash(哈希表)：int(5)
 */
echo '<br><br>DEL<br>';
// TYPE
$redis->flushALL();
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)

/**
 * append
 * 如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
 * 如果key不存在，APPEND就简单地将给定key设为value，就像执行SET key value一样。
 * 返回值：追加value之后，key中字符串的长度。
 */

echo '<br><br>APPEND<br>';
# 情况1：对不存在的key执行APPEND
$redis->exists('myphone');  # 确保myphone不存在 //bool(false)
$redis->append('myphone',"nokia");  # 对不存在的key进行APPEND，等同于SET myphone "nokia" //int(5) # 字符长度
echo $redis->get('myphone');
echo "\n";

# 情况2：对字符串进行APPEND
$redis->append('myphone', " - 1110");# 长度从5个字符增加到12个字符 //int(12)
echo $redis->get('myphone');  # 查看整个字符串 //"nokia - 1110"

/**
 * setrange
 * 用value参数覆写(Overwrite)给定key所储存的字符串值，从偏移量offset开始。
 * 不存在的key当作空白字符串处理。
 * SETRANGE命令会确保字符串足够长以便将value设置在指定的偏移量上，如果给定key原来储存的字符串长度比偏移量小(比如字符串只有5个字符长，但你设置的offset是10)，那么原字符和偏移量之间的空白将用零比特(zerobytes,"\x00")来填充。
 * 注意你能使用的最大偏移量是2^29-1(536870911)，因为Redis的字符串被限制在512兆(megabytes)内。如果你需要使用比这更大的空间，你得使用多个key。
 * 返回值：被SETRANGE修改之后，字符串的长度。
 * 警告：当生成一个很长的字符串时，Redis需要分配内存空间，该操作有时候可能会造成服务器阻塞(block)。在2010年的Macbook Pro上，设置偏移量为536870911(512MB内存分配)，耗费约300毫秒， 设置偏移量为134217728(128MB内存分配)，耗费约80毫秒，设置偏移量33554432(32MB内存分配)，耗费约30毫秒，设置偏移量为8388608(8MB内存分配)，耗费约8毫秒。 注意若首次内存分配成功之后，再对同一个key调用SETRANGE操作，无须再重新内存。
 */

echo '<br><br>SETRANGE<br>';
# 情况1：对非空字符串进行SETRANGE
$redis->set('greeting', "hello world");
$redis->setrange('greeting', 6, "Redis"); //int(11)
$redis->get('greeting');//"hello Redis"

echo "\n";
# 情况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!"

/**
 * substr
 * 截取字符串
 */
$redis->set('str', 'hello world');
echo $redis->substr('str',0,2);	//表示从第0个起，取到第2个字符，共3个，返回’abc’
/**
 * getrange
 * 返回key中字符串值的子字符串，字符串的截取范围由start和end两个偏移量决定(包括start和end在内)。
 * 负数偏移量表示从字符串最后开始计数，-1表示最后一个字符，-2表示倒数第二个，以此类推。
 * GETRANGE通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。
 * 返回值：截取得出的子字符串。
 * 注解:在<=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"

/**
 * setbit
 * 对key所储存的字符串值，设置或清除指定偏移量上的位(bit)。
 * 位的设置或清除取决于value参数，可以是0也可以是1。
 * 当key不存在时，自动生成一个新的字符串值。
 * 字符串会增长(grown)以确保它可以将value保存在指定的偏移量上。当字符串值增长时，空白位置以0填充。
 * offset参数必须大于或等于0，小于2^32(bit映射被限制在512MB内)。
 * 返回值：指定偏移量原来储存的位（”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


/**
 * 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。
 * 特殊符号用“\”隔开
 * 返回值：符合给定模式的key列表
 * 警告：KEYS的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合(Set)。
 */
echo '<br><br>KEYS<br>';
$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。
 * 返回值：
 * 		当数据库不为空时，返回一个key。
 * 		当数据库为空时，返回nil。
 */
echo '<br><br>RANDOMKEY<br>';
$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)

/**
 * rename
 * RENAME key newkey，将key改名为newkey：
 * 当key和newkey相同或者key不存在时，返回一个错误；
 * 当newkey已经存在时，RENAME命令将覆盖旧值
 */
// 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不存在时报错)。
 * 返回值：
 * 		修改成功时，返回1；
 * 		如果newkey已经存在，返回0
 */
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"

/**
 * expire
 * EXPIRE key seconds，为给定key设置生存时间；当key过期时，它会被自动删除。
 * 在Redis中，带有生存时间的key被称作“易失的”(volatile)。
 * 在低于2.1.3版本的Redis中，已存在的生存时间不可覆盖。从2.1.3版本开始，key的生存时间可以被更新，也可以被PERSIST命令移除。(详情参见 http://redis.io/topics/expire)。
 * 返回值：
 * 		设置成功返回1；
 * 		当key不存在或者不能为key设置生存时间时(比如在低于2.1.3中你尝试更新key的生存时间)，返回0
 */
echo '<br><br>EXPIRE<br>';
// EXPIRE
$redis->select(7);
// $redis->flushdb();
 
$redis->set('cache_page', 'http://www.youkuaiyun.com');
$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

/**
 * TTL、TTL key
 * 返回给定key的剩余生存时间(time to live)(以秒为单位)。
 * 返回值：
 * 		key的剩余生存时间(以秒为单位)。
 * 		当key不存在或没有设置生存时间时，返回-1 。
 */
echo '<br><br>TTL<br>';

// 情况1：带TTL的key
$redis->flushdb();

$redis->set('name','ikodota');              // 设置一个key
$redis->expire('name', 3);                 // 设置生存时间为30秒 return (integer) 1

var_dump($redis->get('name'));
var_dump($redis->ttl('name'));
sleep(4);
var_dump($redis->ttl('name'));	// 3秒过去，name过期 return (integer) -1

// 情况2：不带TTL的key
$redis->set('site', 'youkuaiyun.com');
var_dump($redis->ttl('site'));

// 情况3：不存在的key
$redis->exists('not exists_key');	// int(0)
var_dump($redis->ttl('not exists_key'));	// int(-1)

/**
 * dbsize
 * 返回当前数控的key的数量
 * 返回值：
 * 		当前数据库的key的数量
 */
echo $redis->dbsize();

 

 

 

 

 

list类型

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */

require_once('conn.php');

/**
 * 队列操作 list
 */

/**
 * lpush
 * 将一个或多个值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存在但不是列表类型时，返回一个错误。
 * 返回值：
 * 		执行LPUSH命令后，列表的长度。
 * 	注解：在Redis 2.4版本以前的LPUSH命令，都只接受单个value值。
 */

/**
 * rpush
 * 将一个或多个值value插入到列表key的表尾。
 * 如果有多个value值，那么各个value值按从左到右的顺序依次插入到表尾：比如对一个空列表(mylist)执行RPUSH mylist a b c，则结果列表为a b c，等同于执行命令
 * 如果key不存在，一个空列表会被创建并执行RPUSH操作。
 * 当key存在但不是列表类型时，返回一个错误。
 * 返回值：
 * 		执行RPUSH操作后，表的长度。
 * 	注解：在Redis 2.4版本以前的RPUSH命令，都只接受单个value值。
 */

/**
 * lpushx
 * 将值value插入到列表key的表头，当且仅当key存在并且是一个列表。
 * 和LPUSH命令相反，当key不存在时，LPUSHX命令什么也不做。
 * 返回值：
 * 		LPUSHX命令执行之后，表的长度。
 */

/**
 * rpushx
 * 将值value插入到列表key的表尾，当且仅当key存在并且是一个列表。
 * 和RPUSH命令相反，当key不存在时，RPUSHX命令什么也不做。
 * 返回值：
 * 		RPUSHX命令执行之后，表的长度。
 */

/**
 * lpop
 * 移除并返回列表key的头元素。
 * 返回值：
 * 		列表的头元素。当key不存在时，返回nil。
 */

/**
 * rpop
 * 移除并返回列表key的尾元素。
 * 返回值：
 * 		列表的尾元素。当key不存在时，返回nil。
 */

echo '<br><br>TTL<br>';

$redis->rpush('key', 'A');
$redis->rpush('key', 'B');
$redis->rpush('key', 'C');
// var_dump($redis->lpop('key'));
// var_dump($redis->rpop('key'));

/**
 * llen
 * 返回列表key的长度。
 * 如果key不存在，则key被解释为一个空列表，返回0.
 * 如果key不是列表类型，返回一个错误。
 * 返回值：
 * 		列表key的长度。
 */
echo $redis->llen('key');	//3

/**
 * 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。
 *
 * 返回值：一个列表，包含指定区间内的元素。
 */
var_dump($redis->lrange('key', 0, -1));

/**
 * lindex	(LINDEX key index)
 * 返回列表key中，下标为index的元素。
 * 下标(index)参数start和stop都以0为底，也就是说，以0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。
 * 你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
 * 如果key不是列表类型，返回一个错误。
 * 返回值：
 * 		列表中下标为index的元素。
 * 		如果index参数的值不在列表的区间范围内(out of range)，返回nil。
 */
var_dump($redis->lindex('key', 1));

/**
 * lset 	(LSET key index value)
 * 将列表key下标为index的元素的值甚至为value。
 * 当index参数超出范围，或对一个空列表(key不存在)进行LSET时，返回一个错误。
 * 返回值：
 * 		操作成功返回ok，否则返回错误信息
 */
var_dump($redis->lset('key', 1, '123'));
var_dump($redis->lrange('key', 0, -1));

/**
 * lrem 	(LREM key count value)
 * 根据参数count的值，移除列表中与参数value相等的元素。
 * count的值可以是以下几种：
 * 		count > 0: 从表头开始向表尾搜索，移除与value相等的元素，数量为count。
 * 		count < 0: 从表尾开始向表头搜索，移除与value相等的元素，数量为count的绝对值。
 * 		count = 0: 移除表中所有与value相等的值。
 * 返回值：
 * 		被移除元素的数量。
 * 		因为不存在的key被视作空表(empty list)，所以当key不存在时，LREM命令总是返回0。
 */
var_dump($redis->lrem("key", -1, "123"));
var_dump($redis->lrange('key', 0, -1));


/**
 * ltrim 	(LTRIM key start stop)
 * 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
 * 举个例子，执行命令LTRIM list 0 2，表示只保留列表list的前三个元素，其余元素全部删除。
 * 下标(index)参数start和stop都以0为底，也就是说，以0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。
 * 你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
 * 当key不是列表类型时，返回一个错误。
 * 返回值:
 * 		命令执行成功时，返回ok。
 */


/**
 * rpoplpush	(RPOPLPUSH source destination)
 * 命令RPOPLPUSH在一个原子时间内，执行以下两个动作:
 * 		1. 将列表source中的最后一个元素(尾元素)弹出，并返回给客户端。
 * 		2. 将source弹出的元素插入到列表destination，作为destination列表的的头元素。
 * 举个例子，你有两个列表source和destination，source列表有元素a, b, c，destination列表有元素x, y, z，执行RPOPLPUSH source destination之后，source列表包含元素a, b，destination列表包含元素c, x, y, z ，并且元素c被返回。
 * 如果source不存在，值nil被返回，并且不执行其他动作。
 * 如果source和destination相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。
 * 返回值：被弹出的元素
 */
/**
设计模式： 一个安全的队列

Redis的列表经常被用作队列(queue)，用于在不同程序之间有序地交换消息(message)。一个程序(称之为生产者，producer)通过LPUSH命令将消息放入队列中，而另一个程序(称之为消费者，consumer)通过RPOP命令取出队列中等待时间最长的消息。

不幸的是，在这个过程中，一个消费者可能在获得一个消息之后崩溃，而未执行完成的消息也因此丢失。

使用RPOPLPUSH命令可以解决这个问题，因为它在返回一个消息之余，还将该消息添加到另一个列表当中，另外的这个列表可以用作消息的备份表：假如一切正常，当消费者完成该消息的处理之后，可以用LREM命令将该消息从备份表删除。

另一方面，助手(helper)程序可以通过监视备份表，将超过一定处理时限的消息重新放入队列中去(负责处理该消息的消费者可能已经崩溃)，这样就不会丢失任何消息了。
 */
$redis->rpush('list1', 'ab0');
$redis->rpush('list1', 'ab1');
$redis->rpush('list2', 'ab2');
$redis->rpush('list2', 'ab3');
$redis->rpoplpush('list1', 'list2');
var_dump($redis->lrange('list1', 0, -1));
var_dump($redis->lrange('list2', 0, -1));

$redis->rpoplpush('list2', 'list2');
var_dump($redis->lrange('list2', 0, -1));	// 适用于同一个队列把最后一个元素移到最前面

/**
 * brpoplpush 	(BRPOPLPUSH source destination timeout)
 * BRPOPLPUSH是RPOPLPUSH的阻塞版本，当给定列表source不为空时，BRPOPLPUSH的表现和RPOPLPUSH一样。
 * 当列表source为空时，BRPOPLPUSH命令将阻塞连接，直到等待超时，或有另一个客户端对source执行LPUSH或RPUSH命令为止。
 * 超时参数timeout接受一个以秒为单位的数字作为值。超时参数设为0表示阻塞时间可以无限期延长(block indefinitely) 。
 * 返回值：
 * 		假如在指定时间内没有任何元素被弹出，则返回一个nil和等待时长。
 * 		反之，返回一个含有两个元素的列表，第一个元素是被弹出元素的值，第二个元素是等待时长。
 */


/**
 * linsert 	(LINSERT key BEFORE|AFTER pivot value)
 * 将值value插入到列表key当中，位于值pivot之前或之后。
 * 当pivot不存在于列表key时，不执行任何操作。
 * 当key不存在时，key被视为空列表，不执行任何操作。
 * 如果key不是列表类型，返回一个错误。
 * 返回值：
 * 		如果命令执行成功，返回插入操作完成之后，列表的长度。
 * 		如果没有找到pivot，返回-1。
 * 		如果key不存在或为空列表，返回0。
 */
$redis->linsert('list2', 'before', 'ab1', '123'); 	//表示在元素'ab1'之前插入'123'
var_dump($redis->lrange('list2', 0, -1));
$redis->linsert('list2', 'after', 'ab1', '456');   //表示在元素'ab1'之后插入'456'
var_dump($redis->lrange('list2', 0, -1));

// blpop/brpop 阻塞并等待一个列队不为空时，再pop出最左或最右的一个元素（这个功能在php以外可以说非常好用）
// brpoplpush 同样是阻塞并等待操作，结果同rpoplpush一样

var_dump($redis->blpop('list3',10)); 		//如果list3为空则一直等待,直到不为空时将第一元素弹出,10秒后超时

 

 

 

 

 

set类型

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */

require_once('conn.php');

/**
 * set表操作
 */

/**
 * sadd 	(SADD key member [member ...])
 * 将一个或多个member元素加入到集合key当中，已经存在于集合的member元素将被忽略。
 * 假如key不存在，则创建一个只包含member元素作成员的集合。
 * 当key不是集合类型时，返回一个错误。
 * 返回值：被添加到集合中的新元素的数量，不包括被忽略的元素。
 * 注解:在Redis2.4版本以前，SADD只接受单个member值。
 */
$redis->sadd('set1', 'ab');		// sadd 增加元素,返回true,重复返回false
$redis->sadd('set1', 'cd');
$redis->sadd('set1', 'ef');

/**
 * srem 	(SREM key member [member ...])
 * 移除集合key中的一个或多个member元素，不存在的member元素会被忽略。
 * 当key不是集合类型，返回一个错误。
 * 返回值：被成功移除的元素的数量，不包括被忽略的元素。
 * 注解:在Redis2.4版本以前，SREM只接受单个member值。
 */
$redis->srem('set1', 'cd');		// 删除’cd’元素
var_dump($redis->smembers('set1'));


/**
 * spop
 * 移除并返回集合中的一个随机元素。
 * 返回值：
 * 		被移除的随机元素。
 * 		当key不存在或key是空集时，返回nil。
 * 也可以参考:如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用SRANDMEMBER命令。
 */
// var_dump($redis->spop('set1'));

$redis->sadd('set2', '123');
$redis->smove('set1', 'set2', 'ab');	// 移动’set1′中的’ab’到’set2′,返回true or false
echo "\ns1: ";
var_dump($redis->smembers('set1'));
echo "\ns2: ";
var_dump($redis->smembers('set2'));


/**
 * scard 	(SCARD key)
 * 返回集合key的基数(集合中元素的数量)。
 * 返回值：
 * 		集合的基数。
 * 		当key不存在时，返回0。
 */
var_dump($redis->scard('set2'));	// scard 返回当前set表元素个数

/**
 * sismember 	(SISMEMBER key member)
 * 判断member元素是否是集合key的成员。
 * 返回值：
 * 		如果member元素是集合的成员，返回1。
 * 		如果member元素不是集合的成员，或key不存在，返回0。
 */
var_dump($redis->sismember('set2', '123'));	// true or false

/**
 * smembers 	(SMEMBERS key)
 * 返回集合key中的所有成员。
 * 返回值：
 * 		集合中的所有成员。
 */
var_dump($redis->smembers('set2'));

//sinter/sunion/sdiff  返回两个表中元素的交集/并集/补集
$redis->sadd('set1', 'ab');
var_dump($redis->sinter('set2', 'set1'));
var_dump($redis->sunion('set2', 'set1'));
var_dump($redis->sdiff('set2', 'set1'));

//sinterstore/sunionstore/sdiffstore 将两个表交集/并集/补集元素copy到第三个表中
echo "============sinterstore/sunionstore/sdiffstore==============>\n";
$redis->set('foo', 0);
$redis->sinterstore('foo', 'set1');	//这边等同于将’set1′的内容copy到’foo’中，并将’foo’转为set表
var_dump($redis->smembers('foo'));
echo "============sinterstore/sunionstore/sdiffstore==============>\n";

var_dump($redis->smembers('set1'));
var_dump($redis->smembers('set2'));
$redis->sinterstore('foo', array('set1', 'set2')); //将’set1′和’set2′中相同的元素copy到’foo’表中,覆盖’foo’原有内容
var_dump($redis->smembers('foo'));

/**
 * srandmember 	(SRANDMEMBER key)
 * 返回集合中的一个随机元素。
 * 该操作和SPOP相似，但SPOP将随机元素从集合中移除并返回，而SRANDMEMBER则仅仅返回随机元素，而不对集合进行任何改动。
 * 返回值：被选中的随机元素。 当key不存在或key是空集时，返回nil。
 */
//srandmember 返回表中一个随机元素
var_dump($redis->srandmember('set1'));


/**
 * 有序set表操作
 */
/**
 * zadd 	(ZADD key score member [[score member] [score member] ...])
 * 将一个或多个member元素及其score值加入到有序集key当中。
 * 如果某个member已经是有序集的成员，那么更新这个member的score值，并通过重新插入这个member元素，来保证该member在正确的位置上。
 * score值可以是整数值或双精度浮点数。
 * 如果key不存在，则创建一个空的有序集并执行ZADD操作。
 * 当key存在但不是有序集类型时，返回一个错误。
 */
// sadd 增加元素,并设置序号,返回true,重复返回false
$redis->flushdb();
$redis->zadd('zset1', 1, 'ab');
$redis->zadd('zset1', 2, 'cd');
$redis->zadd('zset1', 3, 'ef');
print_r($redis->zrange('zset1', 0, -1));

/**
 * 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值可以是整数值或双精度浮点数。
 * 返回值：member成员的新score值，以字符串形式表示。
 */
// zincrby 对指定元素索引值的增减,改变元素排列次序
echo "==========================>\n";
$redis->zincrby('zset1', 10, 'ab');		//返回11
print_r($redis->zrange('zset1', 0, -1));

// zrem 移除指定元素
$redis->zrem('zset1', 100);

//zrange 按位置次序返回表中指定区间的元素
$redis->zrange('zset1', 0, 1);	//返回位置0和1之间(两个)的元素
$redis->zrange('zset1', 0, -1);	//返回位置0和倒数第一个元素之间的元素(相当于所有元素)

//zrevrange 同上,返回表中指定区间的元素,按次序倒排
$redis->zrevrange('zset1', 0, -1); //元素顺序和zrange相反

// zrangebyscore/zrevrangebyscore 按顺序/降序返回表中指定索引区间的元素
$redis->zadd('zset1', 3, 'ef');
$redis->zadd('zset1', 5, 'gh');
print_r($redis->zrangebyscore('zset1', 2, 9)); //返回索引值2-9之间的元素 array(‘ef’,'gh’)

 //返回索引值2-9之间的元素,’withscores’ =>true表示包含索引值; ‘limit’=>array(1, 2),表示最多返回2条,结果为array(array(‘ef’,3),array(‘gh’,5))
 // 返回所引致2-9之间的元素，'withscores'=>true标识包含索引值；
 // 'limit'=array(1, 2)，标识最多返回2条，结果为array( array('ef', 3), array('gh', 5) )
print_r($redis->zrangebyscore('zset1', 2, 9, array(
		'withscores' =>true,
		'limit'=>array(1, 2)
	)
));

// zunionstore/zinterstore 将多个表的并集/交集存入另一个表中
$redis->zunionstore('zset3', array('zset1', 'zset2', 'zset0'));
print_r($redis->zrange('zset3', 0, -1));

// weights参数表示权重，其中表示并集后值大于5的元素排在前，大于0的排在后
$redis->zunionstore('zset3',array('zset1', 'zset2'), array('weights' => array(5, 0)) );
print_r($redis->zrange('zset3', 0, -1));

// 'aggregate' => 'max'或'min'表示并集后相同的元素是取大值或是取小值
$redis->zunionstore('zset3', array('zset1','zset2'),array('aggregate' => 'max') );
print_r($redis->zrange('zset3', 0, -1));

// zcount 统计一个索引区间的元素个数
echo $redis->zcount('zset1', 3, 5);

// zcard 统计元素个数
echo $redis->zcard('zset1');		//4

// zscore 查询元素的索引
echo $redis->zscore('zset1', 'ef');		//3

// zremrangebyscore 删除一个索引区间的元素
// 删除索引在0-2之间的元素('ab', 'cd'),返回删除元素个数2
echo $redis->zremrangebyscore('zset1', 0, 2); 

// zrank/zrevrank 返回元素所在表顺序/降序的位置(不是索引)
// 返回0,因为它是第一个元素;zrevrank则返回1(最后一个)
echo $redis->zrank('zset1', 'ef');

// zremrangebyrank 删除表中指定位置区间的元素
// 删除位置为0-10的元素,返回删除的元素个数2
echo $redis->zremrangebyrank('zset1', 0, 10); 

hash类型

 

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */

require_once('conn.php');

// hset/hget 存取hash表的数据
$redis->hset('hash1', 'key1', 'v1'); 		// 将key为'key1' value为'v1'的元素存入hash1表
$redis->hset('hash1', 'key2', 'v2');
print_r( $redis->hget('hash1', 'key1') );  		//取出表'hash1'中的key 'key1'的值,返回'v1'

// hexists 返回hash表中的指定key是否存在
print_r( $redis->hexists ('hash1', 'key1') );		//true or false

// hdel 删除hash表中指定key的元素
print_r( $redis->hdel('hash1', 'key2') );		//true or false

// hlen 返回hash表元素个数
echo $redis->hlen('hash1'); //1

// hsetnx 增加一个元素,但不能重复
$redis->hsetnx('hash1', 'key1', 'v2');		//false
$redis->hsetnx('hash1', 'key2', 'v2');		//true

print_r( $redis->hmget('hash1', array('key1', 'key2')) );

// hincrby 对指定key进行累加
$redis->hincrby('hash1', 'key5', 3); //返回3
$redis->hincrby('hash1', 'key5', 10); //返回13

print_r( $redis->hmget('hash1', array('key5')) );

//hkeys 返回hash表中的所有key
var_dump($redis->hkeys('hash1')); //返回array('key1','key2','key3','key4','key5')

//hvals 返回hash表中的所有value
var_dump($redis->hvals('hash1')); //返回array('v1', 'v2', '169')

// hgetall 返回整个hash表元素
var_dump($redis->hgetall('hash1')); 	// 返回array('key1'=>'v1', 'key5'=>'195', 'key2'=>'v2')

排序

 

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */

require_once('conn.php');

/**
 * 排序操作
 */
$redis->flushdb();
$redis->rpush('tab', 3);
$redis->rpush('tab', 2);
$redis->rpush('tab', 17);
var_dump( $redis->sort('tab') );

var_dump( $redis->sort('tab', array('sort' => 'desc')) );

// 返回顺序位置中1的元素2个(这里的2是指个数,而不是位置),返回array(3,17)
var_dump( $redis->sort('tab', array('limit' => array(1, 2))) );

$redis->rpush('tab', 'xyz');
$redis->rpush('tab', 'abc');
$redis->rpush('tab', 'hij');
var_dump( $redis->sort('tab', array('limit' => array('alpha' => true))) );	// 按首字符排序

var_dump( $redis->sort('tab', array('limit' => array('store' => 'ordered'))) );	 // 表示永久性排序,返回元素个数

var_dump( $redis->sort('tab', array('limit' => array('get' => 'pre_*'))) ); //使用了通配符'*'过滤元素,表示只返回以'pre_'开头的元素

管理操作

 

 

<?php
set_time_limit(0);

/**
 * MIT License
 * ===========
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @category   [ Category ]
 * @package    [ Package ]
 * @subpackage [ Subpackage ]
 * @license    http://www.opensource.org/licenses/mit-license.php  MIT License
 * @version    [ Version ]
 * @link       http://[ Your website ]
 */

require_once('conn.php');

/**
 * redis管理操作
 */
// select 指定要操作的数据库
$redis->select(5);		//指定为mydb,不存在则创建

// flushdb 清空当前库
$redis->flushdb();

/**
 * move 	(MOVE key db)
 * 将当前数据库(默认为0)的key移动到给定的数据库db当中。
 * 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
 * 因此，也可以利用这一特性，将MOVE当作锁(locking)原语
 * 返回值：移动成功返回1，失败则返回0。
 */
// 情况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)

$redis->select(1);
var_dump($redis->get('song'));

// 情况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);
$redis->set('favorite_fruit', 'banana');

$redis->select(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

echo "\n";
$redis->select(1);
echo $redis->get('favorite_fruit');             // 数据库1的favorite_fruit也是 return apple