Redis封装





<?php

namespace common;

use \Redis as RedisBase;

class Redis
{
    private static $redis = null;
    private static $expire = 3600; //默认存储时间(秒)
    private static $host = '127.0.0.1';
    private static $port = '6379';
    private static $password = '';
    private static $db = 0;
    private static $timeout = 10;
    /**
     * 初始化Redis连接
     * 所有配置参数在实例化Redis类时加入参数即可
     */
    public function __construct($config=[])
    {
        if($config && is_array($config)){
            self::config($config);
        }
        if(self::$redis==null){
            self::$redis = new RedisBase();
        }
        self::$redis->connect(self::$host,self::$port,self::$timeout) or die('Redis 连接失败!');
        if(!empty(self::$password)){
            self::$redis->auth(self::$password); //如果有设置密码,则需要连接密码
        }
        if((int)self::$db){
            self::$redis->select(self::$db); //选择缓存库
        }
    }

    //构造函数可能不起作用,则用这个初始化类 Redis::_initialize($config=[])
    public static function _initialize($config=[])
    {
        if($config && is_array($config)){
            self::config($config);
        }
        if(self::$redis==null){
            self::$redis = new RedisBase();
        }
        self::$redis->connect(self::$host,self::$port,self::$timeout) or die('Redis 连接失败!');
        if(!empty(self::$password)){
            self::$redis->auth(self::$password); //如果有设置密码,则需要连接密码
        }
        if((int)self::$db){
            self::$redis->select(self::$db); //选择缓存库
        }
    }

    /**
     * 加载配置参数
     * @param  array  $config 配置数组
     */
    private static function config(array $config=[])
    {
        self::$host = isset($config['host']) ? $config['host'] : '127.0.0.1';
        self::$port = isset($config['port']) ? $config['port'] : '6379';
        self::$password = isset($config['password']) ? $config['password'] : '';
        self::$db = isset($config['db']) ? $config['db'] : '';
        self::$expire = isset($config['expire']) ? $config['expire'] : 3600;
        self::$timeout = isset($config['timeout']) ? $config['timeout'] : 10;
    }

    /**
     * 切换到指定的数据库, 数据库索引号用数字值指定
     * @param  int $db 存储库
     * @return
     */
    public static function selectdb($db)
    {
        self::$redis->select((int)$db);
    }

    /**
     * 创建当前数据库的备份(该命令将在 redis 安装目录中创建dump.rdb文件)
     * @return bool 成功true否则false (如果需要恢复数据,只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可)
     */
    public static function savedb()
    {
        return self::$redis->save();
    }

    /**
     * 存储一个键值
     * @param  string or int $key 键名
     * @param  mix $value 键值,支持数组、对象
     * @param  int $expire 过期时间(秒)
     * @return bool 返回布尔值
     */
    public static function set($key, $value, $expire='')
    {
        if(is_int($key) || is_string($key)){
            //如果是int类型的数字就不要序列化,否则用自增自减功能会失败,
            //如果不序列化,set()方法只能保存字符串和数字类型,
            //如果不序列化,浮点型数字会有失误,如13.6保存,获取时是13.59999999999
            $value = is_int($value) ? $value : serialize($value);
            $expire = (int)$expire ? $expire : self::$expire;
            if(self::$redis->set($key, $value) && self::$redis->expire($key, $expire)){
                return true;
            }
            return false;
        }
        return false;
    }

    /**
     * 设置过期时间
     * @param  string or int $key 键名
     * @param  int $expire 过期时间(秒)
     * @return bool 返回布尔值  [如果成功返回true,如果键不存在或已过期则返回false]
     */
    public static function expire($key, $expire=0)
    {
        $expire = (int)$expire ? $expire : self::$expire;
        if(self::$redis->expire($key, $expire)){
            return true;
        }
        return false;
    }

    /**
     * 获取键值
     * @param string or int $key 键名
     * @return mix 返回值
     */
    public static function get($key)
    {
        $value = self::$redis->get($key);
        if(is_object($value)){
            return $value;
        }
        return is_numeric($value) ? $value : unserialize($value);
    }

    /**
     * 删除一个键值
     * @param  string or int $key 键名
     * @return int 成功返回1 ,失败或不存在键返回0
     */
    public static function del($key)
    {
        return self::$redis->del($key);
    }

    /**
     * 截取字符串,支持汉字
     * @param  string or int $key 键名
     * @param  int $start 起始位,从0开始
     * @param  int $end   截取长度
     * @return string   返回字符串,如果键不存在或值不是字符串类型则返回false
     */
    public static function substr($key,$start,$end=0)
    {
        $value = self::get($key);
        if($value && is_string($value)){
            if($end){
                return mb_substr($value,$start,$end);
            }
            return mb_substr($value,$start);
        }
        return false;
    }

    /**
     * 设置指定 key 的值,并返回 key 的旧值
     * @param  string or int  $key 键名
     * @param  mix  $value 要指定的健值,支持数组
     * @param  int $expire 过期时间,如果不填则用全局配置
     * @return mix 返回旧值,如果旧值不存在则返回false,并新创建key的键值
     */
    public static function replace($key, $value, $expire=0)
    {
        $value = self::$redis->getSet($key, $value);
        $expire = (int)$expire ? $expire : self::$expire;
        self::$redis->expire($key, $expire);
        return is_numeric($value) ? $value : unserialize($value);
    }

    /**
     * 同时设置一个或多个键值对。(支持数组值)
     * @param  array  $arr [要设置的键值对数组]
     * @return bool 返回布尔值,成功true否则false
     */
    public static function mset($arr)
    {
        if($arr && is_array($arr)){
            foreach ($arr as &$value) {
                $value = is_int($value) ? $value : serialize($value);
            }
            if(self::$redis->mset($arr)){
                return true;
            }
            return false;
        }
        return false;
    }

    /**
     * 返回所有(一个或多个)给定 key 的值
     * 可传入一个或多个键名参数,键名字符串类型,如 $values = $redis::mget('one','two','three', ...);
     * @return 返回包含所有指定键值数组,如果不存在则返回false
     */
    public static function mget()
    {
        $keys = func_get_args();
        if($keys){
            $values = self::$redis->mget($keys);
            if($values){
                foreach ($values as &$value) {
                    $value = is_numeric($value) ? $value : unserialize($value);
                }
                return $values;
            }
        }
        return false;
    }

    /**
     * 查询剩余过期时间(秒)
     * @param  string or int $key  键名
     * @return int 返回剩余的时间,如果已过期则返回负数
     */
    public static function expiretime($key)
    {
        return self::$redis->ttl($key);
    }

    /**
     * 指定的 key 不存在时,为 key 设置指定的值(SET if Not eXists)
     * @param  string or int $key  键名
     * @param  mix  $value 要指定的健值,支持数组
     * @param  int $expire 过期时间,如果不填则用全局配置
     * @return bool  设置成功返回true 否则false
     */
    public static function setnx($key, $value, $expire=0)
    {
        $value = is_int($value) ? $value : serialize($value);
        $res = self::$redis->setnx($key, $value);
        if($res){
            $expire = (int)$expire ? $expire : self::$expire;
            self::$redis->expire($key, $expire);
        }
        return $res;
    }

    /**
     * 返回对应键值的长度
     * @param  string or int $key  键名
     * @return int  返回字符串的长度,如果键值是数组则返回数组元素的个数,如果键值不存在则返回0
     */
    public static function valuelen($key)
    {
        $value = self::get($key);
        $lenth = 0;
        if($value){
            if(is_array($value)){
                $lenth = count($value);
            }else{
                $lenth = strlen($value);
            }
        }
        return $lenth;
    }

    /**
     * 将 key 中储存的数字值自增
     * @param  string or int $key  键名
     * @param  int $int 自增量,如果不填则默认是自增量为 1
     * @return int  返回自增后的值,如果键不存在则新创建一个值为0,并在此基础上自增,返回自增后的数值.如果键值不是可转换的整数,则返回false
     */
    public static function inc($key, $int=0)
    {
        if((int)$int){
            return self::$redis->incrby($key,$int);
        }else{
            return self::$redis->incr($key);
        }
    }

    /**
     * 将 key 中储存的数字值自减
     * @param  string or int $key  键名
     * @param  int $int 自减量,如果不填则默认是自减量为 1
     * @return int  返回自减后的值,如果键不存在则新创建一个值为0,并在此基础上自减,返回自减后的数值.如果键值不是可转换的整数,则返回false
     */
    public static function dec($key, $int=0)
    {
        if((int)$int){
            return self::$redis->decrby($key,$int);
        }else{
            return self::$redis->decr($key);
        }
    }

    /**
     * 为指定的 key 追加值
     * @param  string or int $key  键名
     * @param  mix  $value 要指定的健值,支持数组
     * @param  bool $pos 要追加的位置,默认false为追加至末尾,true则追加到开头
     * @param  int $expire 过期时间,如果不填则用全局配置
     * @return bool  设置成功返回true 否则false,支付向字符串或者数组追加内容,向字符串追加时加入的值必须为字符串类型,如果健不存在则创建新的键值对
     */
    public static function append($key, $value, $pos=false, $expire=0)
    {
        $cache = self::get($key);
        if($cache){
            if(is_array($cache)){
                if($pos===true){
                    $value = array_unshift($cache, $value);
                }else{
                    $value = array_push($cache, $value);
                }
            }else{
                if(!is_string($value)){
                    return false;
                }
                if($pos===true){
                    $value .= $cache;
                }else{
                    $value = $cache . $value;
                }
            }
        }
        return self::set($key, $value, $expire);
    }


    // +--------------------------------------------------
    // | 以上方法均为字符串常用方法,并且把数组也兼容了
    // | 以下为哈希表处理方法
    // +--------------------------------------------------


    /**
     * 为哈希表中的字段赋值
     * @param  string  $table  哈希表名
     * @param  string  $column 字段名
     * @param  string|array  $value  字段值
     * @param  int $expire 过期时间, 如果不填则不设置过期时间
     * @return int  如果成功返回 1,否则返回 0.当字段值已存在时覆盖旧值并且返回 0
     */
    public static function hset($table, $column, $value, $expire=0)
    {
        $value = is_array($value) ? json_encode($value) : $value;
        $res = self::$redis->hset($table, $column, $value);
        if((int)$expire){
            self::$redis->expire($table, $expire);
        }
        return $res;
    }

    /**
     * 获取哈希表字段值
     * @param  string $table  表名
     * @param  string $column 字段名
     * @return mix  返回字段值,如果字段值是数组保存的返回json格式字符串,转换成数组json_encode($value),如果字段不存在返回false;
     */
    public static function hget($table, $column)
    {
        return self::$redis->hget($table, $column);
    }

    /**
     * 删除哈希表 key 中的一个或多个指定字段,不存在的字段将被忽略
     * @param  string $table  表名
     * @param  string $column 字段名
     * @return int  返回被成功删除字段的数量,不包括被忽略的字段,(删除哈希表用self::del($table))
     */
    public static function hdel($table, $columns)
    {
        $columns = func_get_args();
        $table = $columns[0];
        $count = count($columns);
        $num = 0;
        for ($i=1; $i < $count; $i++) {
            $num += self::$redis->hdel($table, $columns[$i]);
        }
        return $num;
    }

    /**
     * 查看哈希表的指定字段是否存在
     * @param  string $table  表名
     * @param  string $column 字段名
     * @return bool  存在返回true,否则false
     */
    public static function hexists($table, $column)
    {
        if((int)self::$redis->hexists($table, $column)){
            return true;
        }
        return false;
    }

    /**
     * 返回哈希表中,所有的字段和值
     * @param  string $table 表名
     * @return array   返回键值对数组
     */
    public static function hgetall($table)
    {
        return self::$redis->hgetall($table);
    }

    /**
     * 为哈希表中的字段值加上指定增量值(支持整数和浮点数)
     * @param  string $table  表名
     * @param  string $column 字段名
     * @param  int $num  增量值,默认1, 也可以是负数值,相当于对指定字段进行减法操作
     * @return int|float|bool  返回计算后的字段值,如果字段值不是数字值则返回false,如果哈希表不存在或字段不存在返回false
     */
    public static function hinc($table, $column, $num=1)
    {
        $value = self::hget($table, $column);
        if(is_numeric($value)){ //数字类型,包括整数和浮点数
            $value += $num;
            self::hset($table, $column, $value);
            return $value;
        }else{
            return false;
        }
    }

    /**
     * 获取哈希表中的所有字段
     * @param  string $table  表名
     * @return array  返回包含所有字段的数组
     */
    public static function hkeys($table)
    {
        return self::$redis->hkeys($table);
    }

    /**
     * 返回哈希表所有域(field)的值
     * @param  string $table  表名
     * @return array  返回包含所有字段值的数组,数字索引
     */
    public static function hvals($table)
    {
        return self::$redis->hvals($table);
    }

    /**
     * 获取哈希表中字段的数量
     * @param  string $table  表名
     * @return int 如果哈希表不存在则返回0
     */
    public static function hlen($table)
    {
        return self::$redis->hlen($table);
    }

    /**
     * 获取哈希表中,一个或多个给定字段的值
     * @param  string $table  表名
     * @param  string $columns 字段名
     * @return array  返回键值对数组,如果字段不存在则字段值为null, 如果哈希表不存在返回空数组
     */
    public static function hmget($table, $columns)
    {
        $data = self::hgetall($table);
        $result = [];
        if($data){
            $columns = func_get_args();
            unset($columns[0]);
            foreach ($columns as $value) {
                $result[$value] = isset($data[$value]) ? $data[$value] : null;
            }
        }
        return $result;
    }

    /**
     * 同时将多个 field-value (字段-值)对设置到哈希表中
     * @param  string $table  表名
     * @param  array $data  要添加的键值对
     * @param  int $expire  过期时间,不填则不设置过期时间
     * @return bool 成功返回true,否则false
     */
    public static function hmset($table, array $data, $expire=0)
    {
        $result = self::$redis->hmset($table, $data);
        if((int)$expire){
            self::expire($table, $expire);
        }
        return $result;
    }

    /**
     * 为哈希表中不存在的的字段赋值
     * @param  string  $table  哈希表名
     * @param  string  $column 字段名
     * @param  string|array  $value  字段值
     * @param  int $expire 过期时间, 如果不填则不设置过期时间
     * @return bool  如果成功返回true,否则返回 false.
     */
    public static function hsetnx($table, $column, $value, $expire=0)
    {
        if(is_array($value)){
            $value = json_encode($value);
        }
        $result = self::$redis->hsetnx($table, $column, $value);
        if((int)$expire){
            self::expire($table, $expire);
        }
        return $result;
    }



    // +--------------------------------------------------
    // | 以上方法均为哈希表常用方法
    // | 以下为列表处理方法
    // +--------------------------------------------------


    /**
     * 将一个或多个值插入到列表头部(值可重复)或列表尾部。如果列表不存在,则创建新列表并插入值
     * @param  string  $list  列表名
     * @param  string|array  $value  要插入的值,如果是多个值请放入数组传入
     * @param  string $pop 要插入的位置,默认first头部,last表示尾部
     * @param  int $expire 过期时间, 如果不填则不设置过期时间
     * @return int  返回列表的长度
     */
    public static function lpush($list, $value, $pop='first', $expire=0)
    {
        if(is_array($value)){
            foreach ($value as $v) {
                $result = ($pop=='last') ? self::$redis->rpush($list,$v) : self::$redis->lpush($list, $v);
            }
        }else{
            $result = ($pop=='last') ? self::$redis->rpush($list,$value) : self::$redis->lpush($list, $value);
        }
        if((int)$expire){
            self::expire($list, $expire);
        }
        return $result;
    }

    /**
     * 通过索引获取列表中的元素
     * @param  string  $list  列表名
     * @param  int  $index  索引位置,从0开始计,默认0表示第一个元素,-1表示最后一个元素索引
     * @return string  返回指定索引位置的元素
     */
    public static function lindex($list, $index=0)
    {
        return self::$redis->lindex($list, $index);
    }

    /**
     * 通过索引来设置元素的值
     * @param  string $list  列表名
     * @param  string $value 元素值
     * @param  int $index 索引值
     * @return bool  成功返回true,否则false.当索引参数超出范围,或列表不存在返回false。
     */
    public static function lset($list, $index, $value)
    {
        return self::$redis->lset($list, $index, $value);
    }

    /**
     * 返回列表中指定区间内的元素
     * @param  string  $list  列表名
     * @param  int  $start  起始位置,从0开始计,默认0
     * @param  int  $end 结束位置,-1表示最后一个元素,默认-1
     * @return array  返回列表元素数组
     */
    public static function lrange($list, $start=0, $end=-1)
    {
        return self::$redis->lrange($list, $start, $end);
    }

    /**
     * 返回列表的长度
     * @param  string $list 列表名
     * @return int  列表长度
     */
    public static function llen($list)
    {
        return self::$redis->llen($list);
    }

    /**
     * 移出并获取列表的第一个元素或最后一个元素
     * @param  string $list 列表名
     * @param  string $pop 移出并获取的位置,默认first为第一个元素
     * @return string|bool  列表第一个元素或最后一个元素,如果列表不存在则返回false
     */
    public static function lpop($list, $pop='first')
    {
        if($pop=='last'){
            return self::$redis->rpop($list);
        }
        return self::$redis->lpop($list);
    }

    /**
     * 从列表中弹出最后一个值,将弹出的元素插入到另外一个列表开头并返回这个元素
     * @param  string $list1  要弹出元素的列表名
     * @param  string $list2  要接收元素的列表名
     * @return string|bool  返回被弹出的元素,如果其中有一个列表不存在则返回false
     */
    public static function lpoppush($list1,$list2)
    {
        if(self::lrange($list1) && self::lrange($list2)){
            return self::$redis->brpoplpush($list1, $list2, 500);
        }
        return false;
    }

    /**
     * 用于在指定的列表元素前或者后插入元素。如果元素有重复则选择第一个出现的。当指定元素不存在于列表中时,不执行任何操作
     * @param  string $list   列表名
     * @param  string $element 指定的元素
     * @param  string $value   要插入的元素
     * @param  string $pop     要插入的位置,before前,after后。默认before
     * @return int  返回列表的长度。 如果没有找到指定元素 ,返回 -1 。 如果列表不存在或为空列表,返回 0 。
     */
    public static function linsert($list, $element, $value, $pop='before')
    {
        return self::$redis->linsert($list, $pop, $element, $value);
    }

    /**
     * 移除列表中指定的元素
     * @param  string  $list  列表名
     * @param  string  $element  指定的元素
     * @param  int $count  要删除的个数,0表示删除所有指定元素,负整数表示从表尾搜索, 默认0
     * @return int  被移除元素的数量。 列表不存在时返回 0
     */
    public static function lrem($list, $element, $count=0)
    {
        return self::$redis->lrem($list, $count, $element);
    }

    /**
     * 让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除
     * @param  string $list  列表名
     * @param  int $start 起始位置,从0开始
     * @param  int $stop  结束位置,负数表示倒数第n个
     * @return bool  成功返回true否则false
     */
    public static function ltrim($list, $start, $stop)
    {
        return self::$redis->ltrim($list, $start, $stop);
    }



    // +--------------------------------------------------
    // | 以上方法均为列表常用方法
    // | 以下为集合处理方法(集合分为有序和无序集合)
    // +--------------------------------------------------



    /**
     * 将一个或多个元素加入到无序集合中,已经存在于集合的元素将被忽略.如果集合不存在,则创建一个只包含添加的元素作成员的集合。
     * @param  string $set  集合名称
     * @param  string|array $value 元素值(唯一),如果要加入多个元素请传入多个元素的数组
     * @return int  返回被添加元素的数量.如果$set不是集合类型时返回0
     */
    public static function sadd($set, $value)
    {
        $num = 0;
        if(is_array($value)){
            foreach ($value as $key =>$v) {
                $num += self::$redis->sadd($set, $v);
            }
        }else{
            $num += self::$redis->sadd($set, $value);
        }
        return $num;
    }

    /**
     * 返回无序集合中的所有的成员
     * @param  string $set 集合名称
     * @return  array  返回包含所有成员的数组
     */
    public static function smembers($set)
    {
        return self::$redis->smembers($set);
    }

    /**
     * 获取集合中元素的数量。
     * @param  string $set 集合名称
     * @return int  返回集合的成员数量
     */
    public static function scard($set)
    {
        return self::$redis->scard($set);
    }

    /**
     * 移除并返回集合中的一个随机元素
     * @param  string $set 集合名称
     * @return string|bool  返回移除的元素,如果集合为空则返回false
     */
    public static function spop($set)
    {
        return self::$redis->spop($set);
    }

    /**
     * 移除集合中的一个或多个成员元素,不存在的成员元素会被忽略
     * @param  string $set 集合名称
     * @param  string|array $member 要移除的元素,如果要移除多个请传入多个元素的数组
     * @return int  返回被移除元素的个数
     */
    public static function srem($set, $member)
    {
        $num = 0;
        if(is_array($member)){
            foreach ($member as $value) {
                $num += self::$redis->srem($set, $value);
            }
        }else{
            $num += self::$redis->srem($set, $member);
        }
        return $num;
    }

    /**
     * 返回集合中的一个或多个随机元素
     * @param  string $set   集合名称
     * @param  int $count 要返回的元素个数,0表示返回单个元素,大于等于集合基数则返回整个元素数组。默认0
     * @return string|array   返回随机元素,如果是返回多个则为数组返回
     */
    public static function srand($set, $count=0)
    {
        return ((int)$count==0) ? self::$redis->srandmember($set) : self::$redis->srandmember($set, $count);
    }

    /**
     * 返回给定集合之间的差集(集合1对于集合2的差集)。不存在的集合将视为空集
     * @param  string $set1 集合1名称
     * @param  string $set2 集合2名称
     * @return array  返回差集(即筛选存在集合1中但不存在于集合2中的元素)
     */
    public static function sdiff($set1, $set2)
    {
        return self::$redis->sdiff($set1, $set2);
    }

    /**
     * 将给定集合set1和set2之间的差集存储在指定的set集合中。如果指定的集合已存在,则会被覆盖。
     * @param  string $set  指定存储的集合
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return int  返回指定存储集合元素的数量
     */
    public static function sdiffstore($set, $set1, $set2)
    {
        return self::$redis->sdiffstore($set, $set1, $set2);
    }

    /**
     * 返回set1集合和set2集合的交集(即筛选同时存在集合1和集合2中的元素)
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return array  返回包含交集元素的数组
     */
    public static function sinter($set1, $set2)
    {
        return self::$redis->sinter($set1, $set2);
    }

    /**
     * 将给定集合set1和set2之间的交集存储在指定的set集合中。如果指定的集合已存在,则会被覆盖。
     * @param  string $set  指定存储的集合
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return int  返回指定存储集合元素的数量
     */
    public static function sinterstore($set, $set1, $set2)
    {
        return self::$redis->sinterstore($set, $set1, $set2);
    }

    /**
     * 判断成员元素是否是集合的成员
     * @param  string $set   集合名称
     * @param  string $member 要判断的元素
     * @return bool 如果成员元素是集合的成员返回true,否则false
     */
    public static function sismember($set, $member)
    {
        return self::$redis->sismember($set, $member);
    }

    /**
     * 将元素从集合1中移动到集合2中
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @param  string $member 要移动的元素成员
     * @return bool  成功返回true,否则false
     */
    public static function smove($set1, $set2, $member)
    {
        return self::$redis->smove($set1, $set2, $member);
    }

    /**
     * 返回集合1和集合2的并集(即两个集合合并后去重的结果)。不存在的集合被视为空集。
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return array  返回并集数组
     */
    public static function sunion($set1, $set2)
    {
        return self::$redis->sunion($set1, $set2);
    }

    /**
     * 将给定集合set1和set2之间的并集存储在指定的set集合中。如果指定的集合已存在,则会被覆盖。
     * @param  string $set  指定存储的集合
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return int  返回指定存储集合元素的数量
     */
    public static function sunionstore($set, $set1, $set2)
    {
        return self::$redis->sunionstore($set, $set1, $set2);
    }


    /* ----------------------以下有序集合----------------------- */

    /**
     * 将一个或多个成员元素及其分数值加入到有序集当中,如果成员已存在则更新它的分数值,如果集合不存在则创建
     * @param  string $set    集合名称
     * @param  array $arr  元素(唯一)与其分数值(分数值可以是整数值或双精度浮点数)组成的数组
     * @return int  返回添加成功的成员数量
     */
    public static function zadd($set, $arr)
    {
        $num = 0;
        if($arr && is_array($arr)){
            foreach ($arr as $key => $value) {
                if(is_numeric($value)){
                    $num += self::$redis->zadd($set, $value, $key);
                }
            }
        }
        return $num;
    }

    /**
     * 返回有序集中,指定区间内的成员。默认返回所有成员(默认升序排列)
     * @param  string  $set   集合名称
     * @param  int  $start 起始位置,从0开始计,默认0
     * @param  int $stop  结束位置,-1表示最后一位,默认-1
     * @param  bool $desc 排序,false默认升序,true为倒序
     * @return array  返回有序集合中指定区间内的成员数组(默认返回所有)
     */
    public static function zrange($set, $start=0, $stop=-1, $desc=false)
    {
        if($desc===true){
            return self::$redis->ZREVRANGE($set, $start, $stop, 'WITHSCORES');
        }
        return self::$redis->zrange($set, $start, $stop, 'WITHSCORES');
    }

    /**
     * 返回有序集合中成员数量
     * @param  string $set 集合名称
     * @return int  返回成员的数量
     */
    public static function zcard($set)
    {
        return self::$redis->zcard($set);
    }

    /**
     * 计算有序集合中指定分数区间的成员数量
     * @param  string $set 集合名称
     * @param  int|float $min 最小分数值
     * @param  int|float $max 最大分数值
     * @return int  返回指定区间的成员数量
     */
    public static function zcount($set, $min, $max)
    {
        return self::$redis->zcount($set, $min, $max);
    }

    /**
     * 对有序集合中指定成员的分数加上增量
     * @param  string $set 集合名称
     * @param  string  $member 指定元素
     * @param  int $num   增量值,负数表示进行减法运算,默认1
     * @return float  返回运算后的分数值(浮点型)
     */
    public static function zinc($set, $member, $num=1)
    {
        return self::$redis->zincrby($set, $num, $member);
    }

    /**
     * 计算set1和set2有序集的交集,并将该交集(结果集)储存到新集合set中。
     * @param  string $set  指定存储的集合名称
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return int  返回保存到目标结果集的的成员数量
     */
    public static function zinterstore($set, $set1, $set2)
    {
        return self::$redis->zinterstore($set, 2, $set1, $set2);
    }


    /**
     * 计算set1和set2有序集的并集,并将该并集(结果集)储存到新集合set中。
     * @param  string $set  指定存储的集合名称
     * @param  string $set1 集合1
     * @param  string $set2 集合2
     * @return int  返回保存到目标结果集的的成员数量
     */
    public static function zunionstore($set, $set1, $set2)
    {
        return self::$redis->zunionstore($set, 2, $set1, $set2);
    }

    /**
     * 返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)次序排列
     * @param  string $set   集合名称
     * @param  string $min  最小分数值字符串表示,'1'表示>=1,(1'表示>1
     * @param  string $max  最大分数值字符串表示,'100'表示<=1,(100'表示<100
     * @param  bool $withscores  返回的数组是否包含分数值,默认true, false不包含
     * @return array   返回指定区间的成员,默认是元素=>分数值的键值对数组。如果只要返回包含元素的数组请设置$withscores=false
     */
    public static function zrangebyscore($set, $min, $max, $withscores=true)
    {
        if($withscores===true){
            return self::$redis->zrangebyscore($set, $min, $max, ['withscores'=>'-inf']);
        }
        return self::$redis->zrangebyscore($set, $min, $max);
    }

    /**
     * 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。
     * @param  string $set    集合名称
     * @param  string $member 成员名称(元素)
     * @return int|bool   返回 member 的排名, 如果member不存在返回false
     */
    public static function zrank($set, $member)
    {
        return self::$redis->zrank($set, $member);
    }

    /**
     * 移除有序集中的一个或多个成员,不存在的成员将被忽略。
     * @param  string $set     有序集合名称
     * @param  string|array $members 要移除的成员,如果要移除多个请传入多个成员的数组
     * @return int   返回被移除的成员数量,不存在的成员将被忽略
     */
    public static function zrem($set, $members)
    {
        $num = 0;
        if(is_array($members)){
            foreach ($members as $value) {
                $num += self::$redis->zrem($set, $value);
            }
        }else{
            $num += self::$redis->zrem($set, $members);
        }
        return $num;
    }

    /**
     * 移除有序集中,指定分数(score)区间内的所有成员。
     * @param  string $set   集合名称
     * @param  int $min 最小分数值
     * @param  int $max 最大分数值
     * @return int  返回被移除的成员数量
     */
    public static function zrembyscore($set, $min, $max)
    {
        return self::$redis->zremrangebyscore($set, $min, $max);
    }

    /**
     * 移除有序集中,指定排名(rank)区间内的所有成员(这个排名数字越大排名越高,最低排名0开始)
     * @param  string $set   集合名称
     * @param  int $min 最小排名,从0开始计
     * @param  int $max 最大排名
     * @return int  返回被移除的成员数量,如移除排名为倒数5名的成员:$redis::zremrank($set,0,4);
     */
    public static function zrembyrank($set, $min, $max)
    {
        return self::$redis->zremrangebyrank($set, $min, $max);
    }

    /**
     * 返回有序集中,成员的分数值。
     * @param  string $set    集合名称
     * @param  string $member 成员
     * @return float|bool   返回分数值(浮点型),如果成员不存在返回false
     */
    public static function zscore($set, $member)
    {
        return self::$redis->zscore($set, $member);
    }

    /**
     * 开启事务
     */
    public static function transation()
    {
        self::$redis->multi();
    }

    /**
     * 提交事务
     */
    public static function commit()
    {
        self::$redis->exec();
    }

    /**
     * 取消事务
     */
    public static function discard()
    {
        self::$redis->discard();
    }


    public static function myself()
    {
        return self::$redis;
    }
}


白俊遥博客

白俊遥博客
请先登录后发表评论
  • 最新评论
  • 总共0条评论