zoukankan      html  css  js  c++  java
  • 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);
  • 相关阅读:
    Java Web之Tomcat
    Java Web之HTML5
    Java 读取propertoes文件
    SQL Server 触发器
    通过关闭 UseDNS和GSSAPIAuthentication选项加速 SSH登录
    数据库创建索引有什么优点和缺点
    修改查看MYSQL字符集(charset)
    MySQL 数据类型
    远程连接mysql数据库提示:ERROR 1130的解决办法
    怎么快速了解自己的MySQL服务器?
  • 原文地址:https://www.cnblogs.com/woider/p/6502178.html
Copyright © 2011-2022 走看看