PHP Redis 对象方法手册

redis（Remote Dictionary Server）是一种Nosql技术，它是一个开源的高级kv存储和数据结构存储系统。

redis不仅仅是能够存储key和value这种简单的键值对，还能存储例如集合、hash表、列表、字典等。

redis在整个运行过程中，数据统统都是存储在内存中的，因此它的速度非常快。

redis会周期性的将内存中的数据写入在磁盘中，从而实现数据持久化的访问能力。

redis还支持主从模式以及支持通过lua脚本去编写扩展，并且支持高可用和分布式集群解决方案。

Redis 连接（CONNECT）

/**
 * 创建一个 Redis 客户端
 *
 * Redis::__construct 构造函数
 */
$redis = new Redis();

/**
 * connect 连接redis服务
 *
 * @param   string  $host [服务地址]
 * @param   int     $port [端口号，默认6379]
 * @param   float   $timeout [连接时长，默认0.0表示不限制]
 * @return  bool    [成功返回true，失败返回false]
 */
$redis->connect('127.0.0.1', 6379, 0.0);

/**
 * pconnect 不会主动关闭的连接
 *
 * @param   string  $host [服务地址]
 * @param   int     $port [端口号，默认6379]
 * @param   float   $timeout [连接时长，默认0.0]
 * @return  bool    [成功返回true,失败返回false]
 */
$redis->pconnect('127.0.0.1', 6379, 0.0);

/**
 * auth 使用密码进行连接验证
 *
 * @param   string  $password
 * @return  bool [验证成功返回true，否则返回false]
 */
$redis->auth('password');

/**
 * ping 检查当前连接状态
 *
 * @return  string  [成功返回+PONG，失败抛出RedisException]
 */
$redis->ping();

/**
 * select 切换到指定的数据库(0-15)
 * 新连接总是使用0号数据库
 *
 * @param   int     $dbindex
 * @return  bool [成功返回true，失败返回false]
 */
$redis->select(5);

/**
 * open 连接服务，与connect功能相同
 *
 * @param   string  $host [服务地址]
 * @param   int     $port [端口号，默认6379]
 * @param   float   $timeout [连接时长，默认0.0]
 */
$redis->open('127.0.0.1');

/**
 * close 关闭连接，除非连接正在使用
 */
$redis->close();

redis-connect

Redis 键（KEY）

/**
 * del 移除特定的key
 *
 * @param   int|array   $key1 [需要移除的key]
 * @param   string      $key2 ...
 * @param   string      $key3 ...
 * @return  int [被删除key的数量]
 */
$redis->del('key1', 'key2', 'key3');
$redis->del(array('key1', 'key2', 'key3'));

/**
 * keys 查找符合特定模式的key
 * '*' 匹配数据库中所有key
 *
 * @param   string  $pattern [匹配模式]
 * @return  array [符合条件的key数组]
 */
$redis->keys('key_id_*');

/**
 * randomkey 从数据库中随机返回一个key
 *
 * @return  string [一个随机的key]
 */
$redis->randomKey();

/**
 * ttl 返回给定key的剩余生存时间(单位秒)
 *
 * @param   string  $key
 * @return  int [key剩余有效时间]
 */
$redis->ttl('key');

/**
 * exists 检查给定key是否存在
 *
 * @param   string  $key
 * @return  bool [如果key存在返回true，否则返回false]
 */
$redis->exists('key');

/**
 * move 将当前数据库(默认为0)的key移动到给定的数据库db当中
 *
 * @param   string  $key [待移动的key]
 * @param   int     $dbindex [目标数据库编号]
 * @return  bool [成功返回true，失败返回false]
 */
$redis->select(0); //选择数据库0
$redis->move('key', 1); //将key从db0移动至db1

/**
 * rename 修改key的名称
 *
 * @param   string  $srcKey [修改之前的名称]
 * @param   string  $dstKey [修改之后的名称]
 * @return  bool [成功返回true，失败返回false]
 */
$redis->rename('srcKey', 'dstKey');

/**
 * renameNx 仅当srcKey不存在时，将srcKey改名为dstKey
 *
 * @param   string  $srcKey
 * @param   string  $dstKey
 * @return  bool [成功返回true，失败返回false]
 */
$redis->renameNx('srcKey', 'dstKey');

/**
 * type 返回key所存储的值的类型
 * none(0) string(1) set(2) list(3) zset(4) hash(5)
 *
 * @param   string  $key
 * @return  int [值类型]
 */
$redis->type('key');

/**
 * expire|setTimeout 为给定key设置生存时间(单位秒)
 * 当key过期时，它会被自动删除
 *
 * @param   string  $key [将失效的key]
 * @param   int     $ttl [剩余生存时间]
 * @return  bool [设置成功返回true，失败返回false]
 */
$redis->expire('key', 10);
$redis->setTimeout('key', 10);

/**
 * expireAt 为给定key设置到期时间(时间戳)
 *
 * @param   string  $key [将失效的key]
 * @param   int     $timestamp [UNIX时间戳]
 * @return  bool [设置成功返回true，失败返回false]
 */
$redis->expireAt('key', time() + 60);

/**
 * persist 移除key的过期时间，key将持久保持
 * 如果key不存在或没有设置过期时间，则操作失败
 *
 * @param   string  $key
 * @return  bool [移除成功返回true，失败返回false]
 */
$redis->persist('key');

/**
 * sort 给列表、集合、有序集合排序（默认递增）
 * [BY pattern] [GET patern] [LIMIT offset count]
 * [SORT ASC|DESC] [ALPHA] [STORE destination]
 *
 * @param   string  $key
 * @param   array   $option [可选，操作]
 * @return  array [排序结果]
 */
$redis->sort('key', array(
    'BY' => 'user_id_*',    //使用外部key作为权重比较元素
    'GET' => 'user_name_*', //获取外部关联key值
    'LIMIT' => array(5, 3), //从5开始取3个元素
    'ALPHA' => true,        //以UTF-8规则对字符排序
    'SORT' => 'DESC',       //以递减模式排序
    'STORE' => 'newKey',    //将排序结果保存至newKey中
));

redis-key

Redis 字符串（STRING）

/**
 * set 将字符串value关联到key
 * set 无视类型覆盖原值
 *
 * @param   string  $key
 * @param   string  $value
 * @param   int     $timeout [过期时间，默认为0]
 * @return  bool [命令成功返回true]
 */
$redis->set('key', 'value');

/**
 * setnx 当key不存在时设置key的值。
 *
 * @param   string  $key
 * @param   string  $value
 * @return  bool [成功返回true，失败返回false]
 */
$redis->setnx('key', 'value');

/**
 * setex 将值value关联到key，并设置key的有效时间(单位秒)
 * setex 是一个原子性操作，关联值和设置有效时间会同时完成
 *
 * @param   string  $key
 * @param   int     $ttl
 * @param   string  $value
 * @return  bool [命令成功返回true]
 */
$redis->setex('key', 60, 'value');

/**
 * setRange 用value覆写key中存储的字符串(从偏移量offset开始)
 * 若key中存储的字符串长度小于偏移量，那么偏移量之间的空白将用零比特填充
 *
 * @param   string  $key
 * @param   int     $offset
 * @param   string  $value
 * @return  int [返回覆写后的字符串长度]
 */
$redis->setRange('key', 5, 'value');

/**
 * mset 同时设置多个key-value对(会覆盖旧值)
 * mset 是一个原子性操作，所有key在同一时间被设置
 *
 * @param   array   $array [key-value数组]
 * @return  bool [成功返回true，失败返回false]
 */
$redis->mset(array('key' => 'value'));

/**
 * msetnx 同时设置多个key-value(当且仅当key不存在时)
 * msetnx 是原子性的，所有key要么都被设置，要么都不被设置
 *
 * @param   array $array [key-value数组]
 * @return  int 1 [成功返回1，失败返回0]
 */
$redis->msetnx(array('key' => 'value'));

/**
 * append 将value追加到key原来的值之后
 * 如果key不存在，则简单的将key设为value
 *
 * @param   string  $key
 * @param   string  $value [追加的字符串]
 * @return  int [返回追加后的字符串长度]
 */
$redis->append('key', 'value');

/**
 * get 返回key所关联的字符串值
 *
 * @param   string  $key
 * @return  string|bool [成功返回value值，失败返回false]
 */
$redis->get('key');

/**
 * mget 返回所有给定key的值
 *
 * @param   array $array [key数组]
 * @return  array [返回values数组]
 */
$redis->mget(array('key1', 'key2', 'key3'));

/**
 * getRange 返回key总字符串的子字符串
 * 子字符串的截取范围由start和end两个偏移量决定
 *
 * @param   string  $key
 * @param   int     $start [开始位置]
 * @param   int     $end [结束位置]
 * @return  string [返回截取后的子串]
 */
$redis->getRange('key', 0, -1);

/**
 * getSet 将给定key的值设为value，并返回key的旧值
 *
 * @param   string  $key
 * @param   string  $value
 * @return  string  [返回之前的value]
 */
$redis->getSet('key', 'value');

/**
 * strlen 获取key所存储的字符串长度
 *
 * @param   string  $key
 * @return  int [返回字符串长度]
 */
$redis->strlen('key');

/**
 * incr 将key中储存的数字值增加一
 *
 * @param   string $key
 * @return  int [返回增加后的值]
 */
$redis->incr('key');

/**
 * incrBy 将key所储存的值加上给定的增量值
 *
 * @param   string  $key
 * @param   int     $increment [整形增量]
 * @return  int [返回增加后的值]
 */
$redis->incrBy('key', 10);

/**
 * incrByFloat 将key所储存的值加上给定的浮点增量值
 *
 * @param   string  $key
 * @param   float   $increment [浮点型增量]
 * @return  float [返回增加后的值]
 */
$redis->incrByFloat('key', 3.14);

/**
 * decr 将key中储存的数字值减少一
 *
 * @param   string $key
 * @return  int [返回减少后的值]
 */
$redis->decr('key');

/**
 * decrBy 将key所储存的值减去给定的减量值
 *
 * @param   string  $key
 * @param   int     $decrement [整形减量]
 * @return  int [返回减少后的值]
 */
$redis->decrBy('key', 10);

/**
 * setBit 设置或清除字符串指定偏移量上的位(bit)
 * 位的设置或清除取决于value参数，可以是0或1
 *
 * @param   string  $key
 * @param   int     $offset [偏移量]
 * @param   int     $value [位设置 0或1]
 * @return  int [返回偏移量上原来的比特值 0或1]
 */
$redis->setBit('key', 5, 0);

/**
 * getBit 获取字符串指定偏移量上的位(bit)
 * 当offset大于字符串长度，或key不存在时，返回0
 *
 * @param   string  $key
 * @param   int     $offset [偏移量]
 * @return  int [返回偏移量上的比特值 0或1]
 */
$redis->getBit('key', 5);

redis-string

Redis 哈希表（HASH）

/**
 * hSet 将哈希表key中的域field的值设为value
 * 如果field已经存在于哈希表中，旧值将被覆盖
 *
 * @param   string  $key [key 键]
 * @param   string  $hashKey [field 字段]
 * @param   string  $value [value 值]
 * @return  int [新值返回1，覆盖返回0，错误返回error]
 */
$redis->hSet('key', 'field', 'value');

/**
 * hSetNx 为哈希表中添加一个新值
 * 若域field已存在，则该操作无效
 *
 * @param   string  $key
 * @param   string  $hashKey
 * @param   string  $value
 * @return  bool [设置成功返回true，字段已经存在返回false]
 */
$redis->hSetNx('key', 'field', 'value');

/**
 * hMset 为哈希表同时设置多个field-value
 * 此命令会覆盖哈希表中已存在的域
 *
 * @param   string  $key
 * @param   array   $hashKeys [field-value 数组]
 * @return  bool [成功返回true，失败返回false]
 */
$redis->hMset('key', array('field' => 'value'));

/**
 * hGet 返回哈希表key中给定域field的值
 *
 * @param   string  $key
 * @param   string  $hashKey
 * @return  string|bool [返回字段值，若失败则返回false]
 */
$redis->hGet('key', 'field');

/**
 * hMGet 获取哈希表key中多个域的值
 *
 * @param   string  $key
 * @param   array   $hashKeys
 * @return  array [返回 field-value 数组]
 */
$redis->hMGet('key', array('field1', 'field2', 'field3'));

/**
 * hGetAll 获取哈希表中所有的域和值
 *
 * @param   string $key
 * @return  array [返回 field-value 数组]
 */
$redis->hGetAll('key');

/**
 * hDel 删除哈希表中的指定域
 * 不存在的域将被忽略
 *
 * @param   string $key
 * @param   string $hashKey1
 * @param   string $hashKey2
 * @param   string $hashKeyN
 * @return  int [返回被删除字段的数量]
 */
$redis->hDel('key', 'field');

/**
 * hLen 获取哈希表的长度
 * 如果key不存在，或不是hash，则返回false
 *
 * @param   string  $key
 * @return  int [返回字段数量]
 */
$redis->hLen('key');

/**
 * hExists 查看哈希表中给定字段是否存在
 *
 * @param   string  $key
 * @param   string  $hashKey
 * @return  bool [字段存在返回true，否则返回false]
 */
$redis->hExists('key', 'filed');

/**
 * hIncrBy 为哈希表key中的指定字段的整数值加上增量
 *
 * @param   string  $key
 * @param   string  $hashKey
 * @param   int     $increment [整形增量]
 * @return  int [返回增加后的值]
 */
$redis->hIncrBy('key', 'field', 10);

/**
 * hIncrByFloat 为哈希表key中的指定字段的浮点数值加上增量
 *
 * @param   string  $key
 * @param   string  $field
 * @param   float   $increment [浮点型增量]
 * @return  float [返回增加后的值]
 */
$redis->hIncrByFloat('key', 'field', 3.14);

/**
 * hKeys 获取所有哈希表中的字段
 *
 * @param   string  $key
 * @return  array [返回field数组]
 */
$redis->hKeys('key');

/**
 * hVals 获取哈希表中所有值
 *
 * @param   string  $key
 * @return  array [返回value数组]
 */
$redis->hVals('key');

redis-hash

Redis 列表（LIST）

/**
 * lPush 将一个或多个值插入到列表的表头
 * 每个value值将按照从左到右的顺序依次插入到表头
 *
 * @param   string  $key
 * @param   string  $value1  String [插入列表的值]
 * @param   string  $value2  Optional
 * @param   string  $valueN  Optional
 * @return  int|bool [成功返回列表长度，失败返回false]
 */
$redis->lPush('key', 'value1', 'value2', 'value3');

/**
 * lPushx 将一个或多个值插入到已存在的列表头部
 *
 * @param   string  $key
 * @param   string  $value [插入列表的值]
 * @return  int|bool [成功返回列表长度，失败返回false]
 */
$redis->lPushx('key', 'value');

/**
 * rPush 将一个或多个值插入到列表的表尾
 * 每个value值将按照从左到右的顺序依次插入到表尾
 *
 * @param   string  $key
 * @param   string  $value1 String [插入列表的值]
 * @param   string  $value2 Optional
 * @param   string  $valueN Optional
 * @return  int|bool [成功返回列表长度，失败返回false]
 */
$redis->rPush('key', 'value1', 'value2', 'value3');

/**
 * rPushx 将一个或多个值插入到已存在的列表尾部
 *
 * @param   string  $key
 * @param   string  $value String [插入列表的值]
 * @return  int|bool [成功返回列表长度，失败返回false]
 */
$redis->rPushx('key', 'value');

/**
 * lPop 移出并获取列表的第一个元素
 *
 * @param   string $key
 * @return  string [返回移除的元素]
 */
$redis->lPop('key');

/**
 * rPop 移除并获取列表最后一个元素
 *
 * @param   string $key
 * @return  string [返回移除的元素]
 */
$redis->rPop('key');

/**
 * lLen 获取列表的长度
 *
 * @param   string  $key
 * @return  int [key存在时返回列表长度]
 */
$redis->lLen('key');

/**
 * lRange 获取列表指定范围内的元素
 *
 * @param   string  $key
 * @param   int     $start
 * @param   int     $end
 * @return  array [返回特定范围内的元素]
 */
$redis->lRange('key', 0, -1);

/**
 * lRem 根据参数count的值，移除列表中与参数value相等的元素
 * count > 0：从表头开始向表尾搜索，移除与value相等的元素，数量为count
 * count < 0: 从表尾开始向表头搜索，移除与value相等的元素，数量为count的绝对值
 * count = 0: 移除表中所有与value相等的值
 *
 * @param   string  $key
 * @param   string  $value
 * @param   int     $count
 * @return  int     [返回被移除元素的数量]
 */
$redis->lRem('key', 'value', 0);

/**
 * lSet 将列表key下标为index的元素的值设置为value
 * 当index超出长度范围，返回false
 *
 * @param string    $key
 * @param int       $index
 * @param string    $value
 * @return BOOL [设置成功返回true，否则返回false]
 */
$redis->lSet('key', 0, 'value');

/**
 * lTrim 让列表只保留指定区间内的元素
 *
 * @param string    $key
 * @param int       $start
 * @param int       $stop
 * @return array    Bool [当key不是列表类型时返回false]
 */
$redis->lTrim('key', 0, -1);

/**
 * lIndex 通过索引设置列表元素的值
 *
 * @param string    $key
 * @param int       $index
 * @return String [返回下标为index的元素]
 */
$redis->lIndex('key', 0);

/**
 * lInsert 将值value插入到列表key当中，位于值pivot之前或之后
 * 如果没有找到pivot，返回-1。如果key为空列表，返回0
 *
 * @param   string  $key
 * @param   int     $position Redis::BEFORE | Redis::AFTER
 * @param   string  $pivot
 * @param   string  $value
 * @return  int [返回插入完成后的列表长度]
 */
$redis->lInsert('key', Redis::BEFORE, 'pivot', 'value');

/**
 * rpoplpush 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
 * rpoplpush 将在一个原子时间内同时执行移除和插入两个操作
 *
 * @param   string  $srcKey
 * @param   string  $dstKey
 * @return  string  [返回移除插入成功的元素]
 */
$redis->rpoplpush('srcKey', 'dstKey');

redis-list

Redis 集合（SET）

/**
 * sAdd 将一个或多个member元素加入到集合key当中
 * 已经存在于集合的member元素将被忽略
 *
 * @param   string  $key [集合key]
 * @param   string  $value1 [待添加值]
 * @param   string  $value2 [可选值]
 * @param   string  $valueN [可选值]
 * @return  int [返回被添加到集合中新成员的数量]
 */
$redis->sAdd('key', 'value1', 'value2', 'value3');

/**
 * sRem 移除集合key中的一个或多个member元素
 * 不存在的member元素会被忽略
 *
 * @param   string  $key
 * @param   string  $member1
 * @param   string  $member2
 * @param   string  $memberN
 * @return  int [被成功移除的元素数量]
 */
$redis->sRem('key', 'member1', 'member2', 'member3');

/**
 * sMembers 返回集合key中的所有成员
 *
 * @param   string  $key
 * @return  array [返回集合中所有成员]
 */
$redis->sMembers('key');

/**
 * sIsMember 判断member元素是否是集合key的成员
 *
 * @param   string  $key
 * @param   string  $value
 * @return  bool [成员存在返回true，否则返回false]
 */
$redis->sIsMember('key', 'value');

/**
 * sCard 获取集合中成员的数量
 *
 * @param   string  $key
 * @return  int [返回集合的大小，key不存在时返回0]
 */
$redis->sCard('key');

/**
 * sMove 将member元素从source集合移动到destination集合
 * 如果source集合不存在或不包含指定的member元素，则不执行任何操作
 *
 * @param   string  $srcKey
 * @param   string  $dstKey
 * @param   string  $member
 * @return  bool [操作成功返回true，成员不存在返回false]
 */
$redis->sMove('srcKey', 'dstKey', 'member');

/**
 * sPop 移除并返回集合中的一个随机元素
 * 如果集合不存在或为空时，返回false
 *
 * @param   string  $key
 * @return  string [返回被弹出的元素]
 */
$redis->sPop('key');

/**
 * sRandMember 获取集合中的任意一个成员
 *
 * @param   string  $key
 * @return  string [返回一个集合中的随机元素]
 */
$redis->sRandMember('key');

/**
 * sInter 获取所有给定集合的交集
 *
 * @param   string  $key1 [进行相交运算的集合]
 * @param   string  $key2  ...
 * @param   string  $keyN  ...
 * @return  array [返回所有交集成员]
 */
$redis->sInter('key1', 'key2', 'key3');

/**
 * sInterStore 将给定集合的交集保存到dstKey集合
 * 如果dstKey集合已存在，则将其覆盖
 *
 * @param   string  $dstKey [存储运算结果的集合]
 * @param   string  $key1 [进行相交运算的集合]
 * @param   string  $key2 ...
 * @param   string  $keyN ...
 * @return  int [返回结果集中成员的数量]
 */
$redis->sInterStore('dstKey', 'key1', 'key2', 'key3');

/**
 * sUnion 获取所有给定集合的并集
 *
 * @param   string  $key1 [进行联合运算的集合]
 * @param   string  $key2 ...
 * @param   string  $keyN ...
 * @return  array [返回所有并集成员]
 */
$redis->sUnion('key1', 'key2', 'key3');

/**
 * sUnionStore 将给定集合的并集保存到dstKey集合
 * 如果dstKey集合已存在，则将其覆盖
 *
 * @param   string  $dstKey [存储运算结果的集合]
 * @param   string  $key1 [进行联合运算的集合]
 * @param   string  $key2    ...
 * @param   string  $keyN    ...
 * @return  int [返回结果集中成员的数量]
 */
$redis->sUnionStore('dstKey', 'key1', 'key2', 'key3');

/**
 * sDiff 获取所有给定集合的差集
 *
 * @param   string  $key1 [进行相减运算的集合]
 * @param   string  $key2 ...
 * @param   string  $keyN ...
 * @return  array [返回所有差集成员]
 */
$redis->sDiff('key1', 'key2', 'key3');

/**
 * sDiffStore 将给定集合的差集保存到dstKey集合
 * 如果dstKey集合已存在，则将其覆盖
 *
 * @param   string  $dstKey [存储运算结果的集合]
 * @param   string  $key1 [进行相减运算的集合]
 * @param   string  $key2      ...
 * @param   string  $keyN      ...
 * @return  int [返回结果集中成员的数量]
 */
$redis->sDiffStore('dstKey', 'key1', 'key2', 'key3');

redis-set

Redis 有序集合（ZSET）

/**
 * zAdd 将一个或多个member元素及其score值加入到有序集key当中
 *
 * @param   string  $key
 * @param   float   $score1 [用于排序的分数]
 * @param   string  $value1 [需要添加的元素]
 * @return  int [返回被成功添加的新成员数量]
 */
$redis->zAdd('key', 1.5, 'value');

/**
 * zRem 移除有序集key中的一个或多个成员
 * 不存在的成员将被忽略
 *
 * @param   string  $key
 * @param   string  $member1
 * @param   string  $member2
 * @param   string  $memberN
 * @return  int [返回被成功移除的成员数量]
 */
$redis->zRem('key', 'member1', 'member2', 'member3');

/**
 * zCard 获取有序集合中的成员数量
 *
 * @param   string  $key
 * @return  int [返回有序集的基数]
 */
$redis->zCard('key');

/**
 * zCount 计算在有序集合中指定区间分数的成员数
 *
 * @param   string  $key
 * @param   string  $start
 * @param   string  $end
 * @return  int [返回特定范围内的成员数量]
 */
$redis->zCount('key', 0, -1);

/**
 * zScore 获取有序集合中指定成员的分数值
 *
 * @param   string  $key
 * @param   string  $member
 * @return  float  [返回member成员的score值]
 */
$redis->zScore('key', 'member');

/**
 * zIncrBy 为成员member的score值加上增量，增量可以为负值
 *
 * @param   string  $key
 * @param   float   $value [浮点型增量]
 * @param   string  $member
 * @return  float  [返回member成员的新score值]
 */
$redis->zIncrBy('key', 1.5, 'member');

/**
 * zRange 通过索引区间（score递增）返回指定区间内的成员
 * 通过withscores选项，可以让member与score一并返回
 *
 * @param   string  $key
 * @param   int     $start
 * @param   int     $end
 * @param   bool    $withscores
 * @return  array [返回指定区间内的成员]
 */
$redis->zRange('key', 0, -1);

/**
 * zRevRange 通过索引区间（score递减）返回指定区间内的成员
 * 通过withscores选项，可以让member与score一并返回
 *
 * @param   string  $key
 * @param   int     $start
 * @param   int     $end
 * @param   bool    $withscore
 * @return  array [返回指定区间内的成员]
 */
$redis->zRevRange('key', 0, -1);

/**
 * zRangeByScore 返回有序集合（score递增）score处于[min,max]区间的成员
 *
 * @param   string  $key
 * @param   float   $min [分数最小值]
 * @param   float   $max [分数最大值]
 * @param   array   $options [可选，限制结果数量与形式]
 * @return  array [返回分数在指定区间内的成员]
 */
$redis->zRangeByScore('key', 1.0, 2.0, array(
    'limit' => array(5, 3), // offset 5,count 3
    'withscores' => true,
));

/**
 * zRevRangeByScore 返回有序集合（score递减）score处于[min,max]区间的成员
 *
 * @param   string  $key
 * @param   float   $min [分数最小值]
 * @param   float   $max [分数最大值]
 * @param   array   $options [可选，限制结果数量与形式]
 * @return  array [返回分数在指定区间内的成员]
 */
$redis->zRevRangeByScore('key', 1.0, 2.0, array(
    'limit' => array(5, 3), // offset 5,count 3
    'withscores' => true,
));

/**
 * zRank 返回有序集合（score递增）中指定成员的排名
 *
 * @param   string  $key
 * @param   string  $member
 * @return  int [返回member在有序集合中的索引]
 */
$redis->zRank('key', 'member');

/**
 * zRevRank 返回有序集合（score递减）中指定成员的排名
 *
 * @param   string  $key
 * @param   string  $member
 * @return  int [返回member在有序集合中的索引]
 */
$redis->zRevRank('key', 'member');

/**
 * zRemRangeByRank 移除有序集合中给定的排名区间的所有成员
 *
 * @param   string  $key
 * @param   int     $start
 * @param   int     $end
 * @return  int [被成功移除的成员数量]
 */
$redis->zRemRangeByRank('key', 0, -1);

/**
 * zRemRangeByScore 移除有序集合中给定的分数区间的所有成员
 *
 * @param   string  $key
 * @param   float   $min [分数最小值]
 * @param   float   $max [分数最大值]
 * @return  int [被成功移除的成员数量]
 */
$redis->zRemRangeByScore('key', 1.0, 2.0);

redis-zset

Redis 服务（SERVER）

/**
 * bgrewriteaof 异步执行AOF文件重写操作
 *
 * @return  bool [操作成功返回true，失败返回false]
 */
$redis->bgrewriteaof();

/**
 * bgsave 在后台异步保存当前数据库的数据到磁盘
 *
 * @return  bool [操作成功返回true，失败返回false]
 */
$redis->bgsave();

/**
 * save 同步保存当前数据库的数据到磁盘
 *
 * @return  bool [操作成功返回true，失败返回false]
 */
$redis->save();

/**
 * lastSave 返回最近一次将数据保存到磁盘上的时间
 *
 * @return  int [返回UNIX时间戳]
 */
$redis->lastSave();

/**
 * dbSize 获取当前数据库的大小
 *
 * @return int [返回当前数据库的key的数量]
 */
$redis->dbSize();

/**
 * slaveof 将当前服务器转变为指定服务器的从属服务器
 *
 * @param   string  $host
 * @param   int $port
 * @return  bool [操作成功返回true，失败返回false]
 */
$redis->slaveof('10.0.1.7', 6379);

/**
 * flushAll 清空整个 Redis 服务器的数据
 *
 * @return  bool [总是返回true]
 */
$redis->flushAll();

/**
 * flushDB 清空当前数据库中的所有数据
 *
 * @return  bool [总是返回true]
 */
$redis->flushDB();

/**
 * info 关于 Redis 服务器的各种信息和统计值
 *
 * @return string
 */
$redis->info();

redis-server

==================Redis使用Demo=======================

/* 连接MySQL */
$mysqli = new mysqli();
$mysqli->connect('127.0.0.1', 'root', '', 'cms');

/* 连接Redis */
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

/* 查询数据 */
$user_data = $mysqli->query('SELECT * FROM user')
    ->fetch_all(MYSQLI_ASSOC);

/* 缓存数据 */
foreach ($user_data as $data) {
    $redis->zAdd('user', $data['id'], $data['username']);
    $redis->hMset('user:' . $data['username'], $data);
}

/* 设置有效时间 */
$redis->expire('user', 60);
foreach ($user_data as $data) {
    $redis->expire('user:' . $data['username'], 60);
}

$user_data = null; //清空从mysql中查询的数据

/* 取出缓存数据 */
$user_set = $redis->zRange('user', 0, -1);
foreach ($user_set as $username) {
    $user_data[] = $redis->hGetAll('user:' . $username);
}

print_r($user_data);