redis 在 php 中的应用（key篇）

ameimeng

　　本文为我阅读了redis参考手册 之后结合 博友的博客 编写，注意 php_redis 和 redis-cli 的区别（主要是返回值类型和参数用法）
　　目录：

KEY（键）　　DEL            

EXISTS            
EXPIRE      　　EXPIREAT   
　　keys        

MOVE      
PERSIST  
TTL         
RANDOMKEY
RENAME
RENAMENX
TYPE  
SORT
　　KEY（键）
　　1、DEL
　　Redis DEL 命令用于删除已存在的键。不存在的 key 会被忽略。
　　语法：
　　

redis 127.0.0.1:6379> DEL KEY_NAME　　

　　返回值： 被删除 key 的数量。
　　可用版本： >= 1.0.0
　　时间复杂度：O(N)，N为要移除的key的数量。

　　　　　　移除单个字符串类型的key，时间复杂度为O(1)。
　　　　　　移除单个列表、集合、有序集合或哈希表类型的key，时间复杂度为O(M)，M为以上数据结构内的元素数量。　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

// The first case 删除单独的 key　　
$redis->set('w3ckey','redis');
　　

($redis->get('w3ckey'));     // 返回 redis　　
$redis ->del('w3ckey');              // 删除该key，若需要获取返回值，则返回值为 int(1)
　　
($redis->get('w3ckey'));     // 返回 boolean(false)
　　

　　
// The second case 删除一个不存在的 key
　　
if(!$redis->exists('fake_key'))
　　
{
　　($redis->del('fake_key'));   // 返回 int();
　　
}
　　
// The third case 同时删除多个 key
　　
$array_mset = array(
　　'key1' => 'val1',
　　'key2' => 'val2',
　　'key3' => 'val3',
　　
);
　　
$redis->mset($array_mset);           // 使用 mset 同时存储多个值
　　
$array_mget = array('key1', 'key2', 'key3');
　　
($redis->mget($array_mget)); // 返回 array (size=3)0 => string 'val1' (length=4) 1 => string 'val2' (length=4) 2 => string 'val3' (length=4)
　　
$redis -> del($array_mget);          // 同时删除多个值
　　
($redis->mget($array_mget)); // 返回 array (size=3) 0 => boolean false 1 => boolean false 2 => boolean false
　　

　　2、EXISTS
　　Redis EXISTS 命令用于检查给定 key 是否存在。
　　语法：
　　

redis 127.0.0.1:6379> EXISTS KEY_NAME　　

　　返回值： 若 key 存在返回 1 ，否则返回 0 。
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->set('w3ckey','redis');　　

($redis->exists('w3ckey'));   // boolean true　　
$redis ->del('w3ckey');
　　

($redis->exists('w3ckey'));   // boolean(false)　　

　　3、EXPIRE
　　Redis Expire 命令用于设置 key 的过期时间。key 过期后将不再可用。
　　语法：
　　

redis 127.0.0.1:6379> EXPIRE KEY_NAME TIME_IN_SECONDS　　

　　返回值：设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时返回 0. (从2.1.3版本开始，key的生存时间可以被更新，也可以被PERSIST命令移除)
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->set('w3ckey','redis');　　

$redis->expire('w3ckey',20);      // 设置 w3ckey 的剩余生存时间为 20s　　
(2);
　　

($redis->TTL('w3ckey'));  // 查看给定 key 的剩余生存时间，int 18　　
$redis->expire('w3ckey',30);      // 更新 w3ckey 的剩余生存时间为 30s
　　
(3);
　　
($redis->TTL('w3ckey'));  // int 27
　　

　　4、EXPIREAT
　　Redis Expireat 命令用于以 UNIX 时间戳(unix timestamp)格式设置 key 的过期时间。key 过期后将不再可用。EXPIREAT的作用和EXPIRE一样，都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。
　　语法：
　　

redis 127.0.0.1:6379> EXPIREAT KEY_NAME TIME_IN_UNIX_TIMESTAMP　　

　　返回值：设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时返回 0.
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->set('w3ckey','redis');　　

$redis->expireAt('w3ckey',()+10);      // 设置 w3ckey 的剩余生存时间为 10s 后过期　　
(3);
　　

($redis->TTL('w3ckey'));           // 查看给定 key 的剩余生存时间，int 7　　

　　5、KEYS
　　Redis Keys 命令用于查找所有符合给定模式 pattern 的 key 。
　　（1）KEYS * 命中数据库中所有key。

（2）KEYS h?llo 命中hello， hallo and hxllo等。
（3）KEYS h*llo 命中hllo和heeeeello等。
（4）KEYS h[ae]llo 命中hello和hallo，但不命中hillo。
（5）特殊符号用"\"隔开　　语法：
　　

redis 127.0.0.1:6379> KEYS PATTERN　　

　　返回值：符合给定模式的 key 列表 (Array)。（警告 :KEYS的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合(Set)）
　　可用版本： >= 1.0.0
　　时间复杂度：O(N)，N为数据库中key的数量。
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

$array_mset_keys = array('one' => 1,　　'two' => 2,
　　'three' => 3,
　　'four' => 4,
　　
);
　　
$redis -> mset($array_mset_keys);
　　
// KEYS * 命中数据库中所有key。
　　
($redis -> keys('*'));    // array (size=4) 0 => string 'four' (length=4) 1 => string 'two' (length=3) 2 => string 'three' (length=5) 3 => string 'one' (length=3)
　　
// KEYS *o* 命中所有包含 "o" 的key。
　　
($redis -> keys('*o*'));  // array (size=4) 0 => string 'four' (length=4) 1 => string 'two' (length=3) 2 => string 'one' (length=3)
　　
// KEYS 0?? 命中 "o" 后面有几个问号就命中几位数。
　　
($redis->keys("o??"));    //array (size=1) 0 => string 'one' (length=3)
　　
// KEYS t[wh]* 命中 "t" 后面跟了 "w" , "h" 或者 "wh" 的key。
　　
($redis->keys("t[wh]*")); //array (size=2) 0 => string 'two' (length=3) 1 => string 'three' (length=5)
　　

　　6、MOVE
　　Redis Keys 命令用于将当前数据库(默认为0)的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
　　语法：
　　

redis 127.0.0.1:6379> MOVE KEY_NAME DESTINATION_DATABASE　　

　　返回值：移动成功返回 1 ，失败则返回 0 。
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

// This first case: key 存在于当前数据库　　
$redis -> select(0);                            // redis 默认使用数据库0，这里在显示指定一次
　　
$redis -> set('favorite_fruit','pineapple');    // 确保 key 值存在
　　
if($redis -> move('favorite_fruit',1)){         // 将 favorite_fruit 移动到数据库 1 中， int 1
　　$redis -> select(1);                        // 选择数据库 1
　　($redis -> get('favorite_fruit'));  // string pineapple
　　
}
　　

　　

// This second case: key 不存在　　
$redis -> select(0);
　　
if(! $redis->exists('fake_key')){               // key 不存在
　　$redis -> move('fake_key',1);               // 将 favorite_fruit 移动到数据库 1 中， int 0
　　
}
　　
$redis -> select(1);
　　
($redis->exists('fake_key'));           // boolean (false)
　　

　　
// This third case: 源数据库和目标数据库有相同的 key
　　
$redis -> select(0);
　　
$redis -> set('favorite_singer','Jay Chou');    // db0 和 db1 有相同的 key ： favorite_singer
　　
$redis -> select(1);
　　
$redis -> set('favorite_singer','Xu Wei');
　　
$redis -> select(0);
　　
$redis -> move('favorite_singer',1);            // 将 favorite_fruit 移动到数据库 1 中， int 0
　　
echo $redis -> get('favorite_singer');          // db0 的值没有发生改变，string Jay Chou
　　
$redis -> select(1);
　　
echo $redis -> get('favorite_singer');          // db1 的值没有发生改变，string Xu Wei
　　

　　7、PERSIST
　　Redis PERSIST 命令用于移除给定 key 的过期时间，使得 key 永不过期。
　　语法：
　　

redis 127.0.0.1:6379> PERSIST KEY_NAME　　

　　返回值：当过期时间移除成功时，返回 1 。 如果 key 不存在或 key 没有设置过期时间，返回 0
　　可用版本： >= 2.2.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

// This first case: key 存在且设置了过期时间　　
$redis -> set('favorite_fruit','pineapple');
　　

$redis -> expire('favorite_fruit',20);　　

(2);　　

echo $redis -> ttl('favorite_fruit')."</br>";    // 18　　
$redis -> persist('favorite_fruit');             // 移除过期时间
　　
echo $redis -> ttl('favorite_fruit');            // -1 ,表示成功移除过期时间
　　

　　
// This second case: key 不存在
　　
$redis -> select(0);
　　
if(! $redis->exists('fake_key')){               // key 不存在
　　($redis -> persist('fake_key'));    // boolean false
　　
}
　　

　　
// This third case: key 存在但是没有设置过期时间
　　
$redis -> select(0);
　　
$redis -> set('favorite_singer','Jay Chou');
　　
($redis -> persist('favorite_singer'));  // boolean false
　　

　　8、TTL
　　Redis TTL 命令以秒为单位返回 key 的剩余过期时间。
　　语法：
　　

redis 127.0.0.1:6379> TTL KEY_NAME　　

　　返回值：
　　(1)当 key 不存在时，返回 -2 。
　　(2)当 key 存在但没有设置剩余生存时间时，返回 -1 。
　　(3)否则，以秒为单位，返回 key 的剩余生存时间。
　　注意：在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。
　　可用版本： >= 2.2.0
　　时间复杂度：O(1)
　　具体实例：
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

　　

// This first case: key 存在且设置了过期时间　　
$redis -> set('favorite_fruit','pineapple');
　　

$redis -> expire('favorite_fruit',20);　　

(2);　　

echo $redis -> ttl('favorite_fruit')."</br>";    // 18　　

　　
// This second case: key 不存在
　　
$redis -> select(0);
　　
if(! $redis->exists('fake_key')){               // key 不存在
　　($redis -> ttl('fake_key'));        // int -2
　　
}
　　

　　
// This third case: key 存在但是没有设置过期时间
　　
$redis -> select(0);
　　
$redis -> set('favorite_singer','Jay Chou');
　　
($redis -> ttl('favorite_singer'));     // int -1
　　

　　9、RANDOMKEY
　　Redis RANDOMKEY 命令从当前数据库中随机返回一个 key (不删除) 。
　　语法：
　　

redis 127.0.0.1:6379> RANDOMKEY 　　

　　返回值：当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil 。
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例 :
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

　　

// This first case: 数据库不为空　　
$array_mset_randomkey = array(
'fruit' => 'pineapple',　　'food' => 'beef',
　　'drink' => 'beer'
　　
);
　　
$redis -> mset($array_mset_randomkey);
　　
($redis -> randomKey());        // string 'food' ,随机返回一个 key
　　
($redis -> keys('*'));          // 查看数据库里所有的 key ,验证 randomKey 不删除任何 key
　　

　　
// This second case: 数据库为空
　　
$redis->flushAll();                     // 清空数据库里的数据
　　
($redis -> randomKey());        // boolean false
　　

　　10、RENAME
　　Redis Rename 命令用于修改 key 的名称 。
　　语法：
　　

redis 127.0.0.1:6379> RENAME OLD_KEY_NAME NEW_KEY_NAME　　

　　返回值：
　　（1）改名成功时提示 OK ，失败时候返回一个错误。
　　（2）当 OLD_KEY_NAME 和 NEW_KEY_NAME 相同，或者 OLD_KEY_NAME 不存在时，返回一个错误。
　　（3）当 NEW_KEY_NAME 已经存在时， RENAME 命令将覆盖旧值。
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例 :
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

　　

// This first case: key 存在且 newkey 不存在 ，成功改名　　
$redis -> set('fruit','pineapple');
　　

$redis -> ('fruit','favorite_fruit');     // 重命名　　
($redis -> exists('fruit'));            // boolean false, 原来的 key 已经不存在
　　
($redis -> exists('favorite_fruit'));   // boolean true, key 变成了 newkey
　　

　　
// This second case: key 不存在 ，返回错误
　　
$redis->flushAll();
　　
if(! $redis ->exists('fake_key'))
　　
{
　　($redis -> ('fake_key','never_exists'));  // boolean false
　　
}
　　

　　
// This third case: key 和 newkey 相同 ，返回错误
　　
$redis -> set('favorite_singer','Jay Chou');
　　
($redis -> ('favorite_singer','favorite_singer')); // boolean false
　　

　　
// This fourth case: newkey 已经存在, 覆盖
　　
$redis -> set('PC','SONY');
　　
$redis -> set('personal_computer','lenovo');
　　
($redis -> ('PC','personal_computer'));       // boolean true
　　
($redis -> get('personal_computer'));               // string SONY
　　

　　11、RENAMENX
　　Redis Renamenx 命令用于在新的 key 不存在时修改 key 的名称 。
　　语法：
　　

redis 127.0.0.1:6379> RENAMENX OLD_KEY_NAME NEW_KEY_NAME　　

　　返回值：修改成功时，返回 1 。 如果 NEW_KEY_NAME 已经存在，返回 0 。
　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例 :
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

$redis->flushAll();　　

　　

// This first case: key 存在且 newkey 不存在 ，成功改名　　
$redis -> set('fruit','pineapple');
　　

$redis -> renameNx('fruit','favorite_fruit');     // 重命名　　
($redis -> exists('fruit'));            // boolean false, 原来的 key 已经不存在
　　
($redis -> exists('favorite_fruit'));   // boolean true, key 变成了 newkey
　　

　　
// This second case: newkey已经存在，改名失败
　　
$redis -> set('PC','SONY');
　　
$redis -> set('personal_computer','lenovo');
　　
($redis -> renameNx('PC','personal_computer'));       // boolean false
　　
($redis -> get('PC'));                                // string SONY
　　
($redis -> get('personal_computer'));                 // string lenovo
　　

　　12、TYPE
　　Redis Type 命令用于返回 key 所储存的值的类型。
　　语法：
　　

redis 127.0.0.1:6379> TYPE KEY_NAME 　　

　　返回值： 返回 key 的数据类型，数据类型有：

• none (key不存在)   int(0)
  
• string (字符串)  　  int(1)
  
• set (集合)　　         int(2)
  
• list (列表)              int(3)
  
• zset (有序集)          int(4)
  
• hash (哈希表)         int(5)
  

　　可用版本： >= 1.0.0
　　时间复杂度：O(1)
　　具体实例 :
　　

<?php　　

$redis = new redis();　　

$redis->connect('127.0.0.1',6379);　　

　　

// This first case: key 不存在 ，返回 int(0)　　
$redis->flushAll();
　　

($redis -> type('fake_key'));           // int(0)　　

　　
// This second case: 字符串类型 ,返回 int(1)
　　
$redis -> set('favorite_fruit','banana');
　　
($redis -> type('favorite_fruit'));     // int(1)
　　

　　
// This third case: 集合类型 ， 返回 int(2)
　　
$redis -> sAdd('favorite_singer','Jay Chou');
　　
($redis -> type('favorite_singer'));     // int(2)
　　

　　
// This fourth case: 列表类型 ， 返回 int(3)
　　
$redis -> lPush('program','PHP');
　　
($redis -> type('program'));            // int(3)
　　

　　
// This fifth case: 有序类型 ， 返回 int(4)
　　
$redis -> zAdd('pats','0','dog');
　　
$redis -> zAdd('pats','1','cat');
　　
$redis -> zAdd('pats','1','pig');
　　
$redis -> zAdd('pats','2','fox');
　　
($redis -> zRange('pats',0,-1));        // array (size=4) 0 => string 'dog' (length=3) 1 => string 'cat' (length=3) 2 => string 'pig' (length=3) 3 => string 'fox' (length=3)
　　
($redis -> type('pats'));               // int(4)
　　

　　
// This sixth case: 哈希类型 ， 返回 int(5)
　　
$redis -> hSet('website','baidu','www.baidu.com');
　　
($redis -> hGet('website','baidu'));    // string www.baidu.com
　　
($redis -> type('website'));            // int(5)
　　

　　13、sort
　　Redis Type 命令用于返回 key 所储存的值的类型。
　　语法：
　　

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

　　array(
　　'by' => 'some_pattern_*',
　　'limit' => array(offset, count),
　　'get' => 'some_other_pattern_*' or an array of patterns,
　　'sort' => 'asc' or 'desc',
　　'alpha' => TRUE,
　　'store' => 'external-key'
　　)
　　返回值： 返回或保存给定列表、集合、有序集合key中经过排序的元素。（排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较）。
　　具体实例 :
　　1、sort key  ，若保存的值是数字，返回列表值从小到大的结果
　　

//  sort key ,按从小到大进行排序　　
$redis -> flushAll();
　　

$redis -> lPush('number',1.5);　　

$redis -> lPush('number',18);　　

$redis -> lPush('number',75);　　

$redis -> lPush('number',38);　　

($redis -> ('number'));　　// array (size=4)
　　//　　0 => string '1.5' (length=3)
　　//　　1 => string '18' (length=2)
　　//　　2 => string '38' (length=2)
　　//　　3 => string '75' (length=2)
　　

　　2、 若保存的是字符串，使用sort(key,array('ALPHA'=>TRUE))进行排序（按字母表顺序）
　　

<?php　　

$redis = new redis();　　

$redis -> connect('127.0.0.1',6379);　　

　　

//  若保存的是字符串，使用sort(key,array('ALPHA'=>TRUE))进行排序（按字母表顺序）　　
$redis -> flushAll();
　　

$redis -> lPush('website','www.baidu.com');　　

$redis -> lPush('website','www.google.com');　　

$redis -> lPush('website','www.tencent.com');　　

$redis -> lPush('website','www.firefox.com');　　

($redis -> ('website', array('ALPHA'=>TRUE)));　　

//  array (size=4)　　
//      0 => string 'www.baidu.com' (length=13)
　　
//      1 => string 'www.firefox.com' (length=15)
　　
//      2 => string 'www.google.com' (length=14)
　　
//      3 => string 'www.tencent.com' (length=15)
　　

　　3、排序之后返回的元素可以通过LIMIT修饰符进行限制，使用sort(key,array('LIMIT'=>array(offset,count)))
　　LIMIT修饰符接受两个参数：offset 和 count。
　　offset指定要跳过的元素数量，count指定跳过offset个指定的元素之后，要返回多少个对象。
　　（1）排序的值为数字：
　　

<?php　　

$redis = new redis();　　

$redis -> connect('127.0.0.1',6379);　　

　　

//  若排序之后返回的元素数量可以通过LIMIT修饰符进行限制，使用sort(key,array('LIMIT'=>array(offset,count)))　　
//  LIMIT修饰符接受两个参数：offset和count。
　　
// offset指定要跳过的元素数量，count指定跳过offset个指定的元素之后，要返回多少个对象。
　　
$redis -> flushAll();
　　

$redis -> lPush('rank',5);  //1　　
$redis -> lPush('rank',55); //7
　　
$redis -> lPush('rank',52); //6
　　
$redis -> lPush('rank',25); //4
　　
$redis -> lPush('rank',24); //3
　　
$redis -> lPush('rank',37); //5
　　
$redis -> lPush('rank',13); //2
　　
$redis -> lPush('rank',87); //8
　　
$redis_sort_option = array('LIMIT' => array(2,5));      // 正序排序，跳过 2 个元素，跳过之后返回 5 个元素
　　
($redis -> ('rank', $redis_sort_option));
　　
//  array (size=5)
　　
//      0 => string '24' (length=2)
　　
//      1 => string '25' (length=2)
　　
//      2 => string '37' (length=2)
　　
//      3 => string '52' (length=2)
　　
//      4 => string '55' (length=2)
　　

　　
$redis_sort_desc = array('LIMIT' => array(2,5),'SORT'=>'desc');      // 逆序排序，跳过 2 个元素，跳过之后返回 5 个元素
　　
($redis -> ('rank', $redis_sort_desc));
　　
//  array (size=5)
　　
//      0 => string '52' (length=2)
　　
//      1 => string '37' (length=2)
　　
//      2 => string '25' (length=2)
　　
//      3 => string '24' (length=2)
　　
//      4 => string '13' (length=2)
　　

　　（2）排序的值为字符串
　　

<?php　　

$redis = new redis();　　

$redis -> connect('127.0.0.1',6379);　　

　　

//  若排序之后返回的元素数量可以通过LIMIT修饰符进行限制，使用sort(key,array('LIMIT'=>array(offset,count)))　　
//  LIMIT修饰符接受两个参数：offset和count。
　　
// offset指定要跳过的元素数量，count指定跳过offset个指定的元素之后，要返回多少个对象。
　　
$redis -> flushAll();
　　

$redis -> lPush('website','www.baidu.com');     //2　　
$redis -> lPush('website','www.tencent.com');   //7
　　
$redis -> lPush('website','www.firefox.com');   //3
　　
$redis -> lPush('website','www.wangyi.com');    //8
　　
$redis -> lPush('website','www.google.com');    //4
　　
$redis -> lPush('website','www.software.com');  //6
　　
$redis -> lPush('website','www.12306.cn');      //1
　　
$redis -> lPush('website','www.hao123.com');    //5
　　
$redis_sort_option = array('LIMIT' => array(0,5),'ALPHA'=>TRUE);      // 正序排序，如果是字符串的话需要加 "ALPHA"=>TRUE ,跳过 0 个元素，跳过之后返回 5 个元素
　　
($redis -> ('website', $redis_sort_option));
　　
//  array (size=5)
　　
//      0 => string 'www.12306.cn' (length=12)
　　
//      1 => string 'www.baidu.com' (length=13)
　　
//      2 => string 'www.firefox.com' (length=15)
　　
//      3 => string 'www.google.com' (length=14)
　　
//      4 => string 'www.hao123.com' (length=14)
　　

　　
$redis_sort_desc = array('LIMIT' => array(0,5),'SORT'=>'desc','ALPHA'=>TRUE);      // 逆序排序，跳过 0 个元素，跳过之后返回 5 个元素
　　
($redis -> ('website', $redis_sort_desc));
　　
//  array (size=5)
　　
//      0 => string 'www.wangyi.com' (length=14)
　　
//      1 => string 'www.tencent.com' (length=15)
　　
//      2 => string 'www.software.com' (length=16)
　　
//      3 => string 'www.hao123.com' (length=14)
　　
//      4 => string 'www.google.com' (length=14)
　　

　　4、使用外部 key 进行排序（有时候会希望使用外部的key作为权重来比较元素，代替默认的对比方法）。
　　假设现在有用户(user)数据如下：

id               
name            
password         
level            
1
Kangkang
Kangkang123
5
4
Michael
Michael123
3
2
Jane
Jane123
2
3
Maria
Maria123
7　　id 保存在 key 名为user_id 的列表中；
　　name 保存在username_{id} 的 key 中；
　　password 保存在userpassword_{id} 的 key 中；
　　level 保存在 userlevel_{id} 的 key 中。
　　（1）首先将数据加入到数据库中
　　

<?php　　

$redis = new redis();　　

$redis -> connect('127.0.0.1',6379);　　

$redis -> flushAll();　　

　　

// kangkang　　
$redis -> lPush('user_id',1);
　　

$redis -> set('username_1','Kangkang');　　

$redis -> set('userpassword_1','Kangkang123');　　

$redis -> set('userlevel_1',5);　　

　　

// Michael　　
$redis -> lPush('user_id',4);
　　
$redis -> set('username_4','Michael');
　　
$redis -> set('userpassword_4','Michael123');
　　
$redis -> set('userlevel_4',3);
　　

　　
// Jane
　　
$redis -> lPush('user_id',2);
　　
$redis -> set('username_2','Jane');
　　
$redis -> set('userpassword_2','Jane123');
　　
$redis -> set('userlevel_2',2);
　　

　　
// Maria
　　
$redis -> lPush('user_id',3);
　　
$redis -> set('username_3','Maria');
　　
$redis -> set('userpassword_3','Maria123');
　　
$redis -> set('userlevel_3',7);
　　

　　（2）如果希望按 level 从大到小的顺序排序，可以这样做：
　　

// 按 level 从大到小排序>
$array_sort_option = array('BY' => 'userlevel_*',　　'SORT' => 'DESC',
　　
);
　　
($redis -> ('user_id',$array_sort_option));
　　
//  array (size=4)
　　
//      0 => string '3' (length=1)
　　
//      1 => string '1' (length=1)
　　
//      2 => string '4' (length=1)
　　
//      3 => string '2' (length=1)
　　

　　
// 有时候只是返回相应的id没有什么用，你可能更希望排序后返回id对应的用户名，GET 可以帮忙实现
　　
$array_sort_option = array(
　　'BY' => 'userlevel_*',
　　'SORT' => 'DESC',
　　'GET' => 'username_*'
　　
);
　　
($redis -> ('user_id',$array_sort_option));
　　
//  array (size=4)
　　
//      0 => string 'Maria' (length=5)
　　
//      1 => string 'Kangkang' (length=8)
　　
//      2 => string 'Michael' (length=7)
　　
//      3 => string 'Jane' (length=4)
　　

　　
// 若不但希望获取用户名，还希望连用户的密码也一并列出，可以使用以下命令,可以多次地、有序地使用 GET 操作来获取更多外部 key
　　
$array_sort_option = array(
　　'BY' => 'userlevel_*',
　　'SORT' => 'DESC',
　　'GET' => array('#','username_*','userpassword_*')   // 注意GET操作是有序的，GET username_* GET userpassword_* 和 GET userpassword_* GET username_*返回的结果位置不同， '#',为当前元素
　　
);
　　
($redis -> ('user_id',$array_sort_option));
　　
//  array (size=12)
　　
//      0 => string '3' (length=1)
　　
//      1 => string 'Maria' (length=5)
　　
//      2 => string 'Maria123' (length=8)
　　
//      3 => string '1' (length=1)
　　
//      4 => string 'Kangkang' (length=8)
　　
//      5 => string 'Kangkang123' (length=11)
　　
//      6 => string '4' (length=1)
　　
//      7 => string 'Michael' (length=7)
　　
//      8 => string 'Michael123' (length=10)
　　
//      9 => string '2' (length=1)
　　
//      10 => string 'Jane' (length=4)
　　
//      11 => string 'Jane123' (length=7)
　　

　　（3）只获取对象而不排序（若希望获取外部对象而又不希望引起排序开销时使用，BY修饰符可以将一个不存在的key当作权重，让SORT跳过排序操作）。
　　

// 此处无论是 ASC 还是 DESC 都无效，是按照先 lpush 的user_id 在走后，后 lpush 的user_id 在最前　　
if(!$redis -> exists('fake_key')){
$array_sort_option1 = array('BY' => 'fake_key',　　'GET' => array('#','username_*','userpassword_*')
　　);
　　($redis -> ('user_id',$array_sort_option1));
　　
}
　　
//  array (size=12)
　　
//      0 => string '3' (length=1)
　　
//      1 => string 'Maria' (length=5)
　　
//      2 => string 'Maria123' (length=8)
　　
//      3 => string '2' (length=1)
　　
//      4 => string 'Jane' (length=4)
　　
//      5 => string 'Jane123' (length=7)
　　
//      6 => string '4' (length=1)
　　
//      7 => string 'Michael' (length=7)
　　
//      8 => string 'Michael123' (length=10)
　　
//      9 => string '1' (length=1)
　　
//      10 => string 'Kangkang' (length=8)
　　
//      11 => string 'Kangkang123' (length=11)
　　

　　（4）保存排序结果
　　默认情况下，SORT操作只是简单地返回排序结果，如果你希望保存排序结果，可以给 STORE 选项指定一个key作为参数，排序结果将以列表的形式被保存到这个key上。(若指定key已存在，则覆盖。)
　　

// 使用 STORE 之后，可以将结果以 list 的形式保存在 STORE 所定义的 key 中。　　
$array_sort_option = array(
'BY' => 'userlevel_*',　　'SORT' => 'DESC',
　　'GET' => array('#','username_*','userpassword_*'),
　　'STORE' => 'userinfo_sort_by_level'
　　
);
　　
($redis -> ('user_id',$array_sort_option));     // int 12
　　
($redis -> lRange('userinfo_sort_by_level',0,-1));
　　
//  array (size=12)
　　
//      0 => string '3' (length=1)
　　
//      1 => string 'Maria' (length=5)
　　
//      2 => string 'Maria123' (length=8)
　　
//      3 => string '1' (length=1)
　　
//      4 => string 'Kangkang' (length=8)
　　
//      5 => string 'Kangkang123' (length=11)
　　
//      6 => string '4' (length=1)
　　
//      7 => string 'Michael' (length=7)
　　
//      8 => string 'Michael123' (length=10)
　　
//      9 => string '2' (length=1)
　　
//      10 => string 'Jane' (length=4)
　　
//      11 => string 'Jane123' (length=7)
　　

　　一个有趣的用法是将SORT结果保存，用EXPIRE为结果集设置生存时间，这样结果集就成了SORT操作的一个缓存。这样就不必频繁地调用SORT操作了，只有当结果集过期时，才需要再调用一次SORT操作。
　　有时候为了正确实现这一用法，你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端，同一时间进行SORT操作，并保存为结果集)，具体参见SETNX命令。
　　如有转载，请注明出处：http://www.cnblogs.com/chrdai/p/6825684.html
　　下一篇：redis 在 php 中的应用（string篇）