redis用法 php

1.什么是redis

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如
下：

• 字符串类型
• 散列类型
• 列表类型
• 集合类型
• 有序集合类型。

2.redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等、登录、网页、数据、实现购物车）。（最多使用）
• 分布式集群架构中的session分离。
• 聊天室的在线好友列表。
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜。
• 网站访问统计。
• 数据过期处理（可以精确到毫秒）
• 搜索

redis缓存的数据格式

大概思路：
根据请求的url来判断：
1.请求的url hash 后在redis中有记录,则直接返回redis中的数据。
2.请求的url hash 后在redis中无记录,则查询数据库(mysql),保存到redis中,并返回。
url格式： 模块,控制器,操作(action)，page

redis缓存的数据格式：
分为两种：
一种是html标签，也就是框架渲染完成的html页面。
另一种是josn数据，这部分是ajax请求所需的数据。

  public function Cache($name, $arguments)

    {

        // 因为我们主要是根据方法名的后缀决定具体操作，

        // 所以如果传入的 $name 长度小于5，可以直接报错

        if (strlen($name) < 5) {

            exit('Method does not exist.');

        }

 

        // 接着，我们截取 $name，获取原方法和要执行的动作，

        // 是cache、clear还是flush，这里我们取了个巧，动作

        // 的名称都是5个字符，这样截取就非常高效。

        $method = substr($name, 0, -5);

        $action = substr($name, -5);

 

        // 当前调用的类名称，包括命名空间的名称

        $class = get_class();

 

        // 生成缓存键名，$arguments稍后再加上

        $key = sprintf('%s:%s:', str_replace('\\', '_', $class), $method);

        // 都用小写好看点

        $key = strtolower($key);

 

        switch ($action) {

            case 'Cache':

                // 缓存键名加上$arguments

                $key = $key . md5(json_encode($arguments));

 

                // 从Redis中读取数据

                $data = Common::redis()->get($key);

 

                // 如果Redis中有数据

                if ($data !== false) {

                    $decodeData = json_decode($data, JSON_UNESCAPED_UNICODE);

                    // 如果不是JSON格式的数据，直接返回，否则返回json解析后的数据

                    return $decodeData === null ? $data : $decodeData;

                }

 

                // 如果Redis中没有数据则继续往下执行

 

                // 如果原方法不存在

                if (method_exists($this, $method) === false) {

                    exit('Method does not exist.');

                }

 

                // 调用原方法获取数据

                $data = call_user_func_array([$this, $method], $arguments);

 

                // 保存数据到Redis中以便下次使用

                Common::redis()->set($key, json_encode($data), 3600);

 

                // 结束执行并返回数据

                return $data;

                break;

 

            case 'Clear':

                // 缓存键名加上$arguments

                $key = $key . md5(json_encode($arguments));

                return Common::redis()->del($key);

                break;

 

            case 'Flush':

                $key = $key . '*';

 

                // 获取所有符合 $class:$method:* 规则的缓存键名

                $keys = Common::redis()->keys($key);

                return Common::redis()->del($keys);

                break;

 

            default:

                exit('Method does not exist.');

        }

    }

任务队列。（秒杀、抢购、12306等等） 使用 列表

 public function LPUSH(){
 
		$redis = new Redis();
		$redis->connect('127.0.0.1',6379);
		try {
		  $redis->LPUSH('click',$user_id);
		}
		catch(Exception $e) {
		  echo $e->getMessage();
		}
}
 public function LPOP(){
	$redis = new Redis();
	$redis->pconnect('127.0.0.1',6379);
	while(1) {
	  try{
	    $value = $redis->LPOP('click');
	    /**
	      利用$value进行逻辑和数据处理
	     */
	  }
	  catch(Exception $e) {
	    echo $e->getMessage();
	  }
	}
}

应用排行榜。 使用 键(key)和有序集合

<?php
namespace Leaderboard;

/**
 * 使用rediszset的的商品排行榜
 * @author yiwang
 *        
 */
class RedisLeaderboard
{

    /**
     *
     * @var object redis client
     */
    private $redis;
    /**
     *
     * @var string 放置排行榜的key
     */
    private $leaderboard;

    /**
     * 构造函数
     * @param object $redis 已连接redis的phpredis的对象
     * @param string $leaderboard 字符串,排行榜的key名
     */
    public function __construct($redis = [], $leaderboard = '')
    {

        if ($redis) {
          $this->redis = $redis;
        } else {
          $this->redis = new \Redis();
          $this->redis->connect('127.0.0.1');
        }

        if ($leaderboard) {
            //这里不会检查当前的key值是否存在,是为了方便重新访问对应的排行榜
            $this->leaderboard = $leaderboard;
        } else {
            $this->leaderboard = 'leaderboard:' . mt(1, 100000);
            while (!empty($this->redis->exists($this->leaderboard))) {
                $this->leaderboard = 'leaderboard:' . mt(1, 100000);
            }
        }

    }
    /**
     * 获取当前的排行榜的key名
     * @return string
     */
    public function getLeaderboard()
    {
        return $this->leaderboard;
    }
    /**
     * 将对应的值填入到排行榜中
     * @param  $node 对应的需要填入的值(比如商品的id)
     * @param number $count 对应的分数,默认值为1
     * @return Long 1 if the element is added. 0 otherwise.
     */
    public function addLeaderboard($node, $count = 1)
    {
        return $this->redis->zAdd($this->leaderboard, $count, $node);
    }
    /**
     * 给出对应的排行榜
     * @param int $number 需要给出排行榜数目
     * @param bool $asc 排序顺序 true为按照高分为第0
     * @param bool $withscores 是否需要分数
     * @param callback $callback 用于处理排行榜的回调函数
     * @return [] 对应排行榜
     */
    public function getLeadboard($number, $asc = true, $withscores = false,$callback = null)
    {
        if ($asc) {
            $nowLeadboard =  $this->redis->zRevRange($this->leaderboard, 0, $number -1, $withscores);//按照高分数顺序排行;
        } else {
            $nowLeadboard =  $this->redis->zRange($this->leaderboard, 0, $number -1, $withscores);//按照低分数顺序排行;
        }


        if ($callback) {
            //使用回调处理
            return $callback($nowLeadboard);
        } else {
            return $nowLeadboard;
        }
    }
    /**
     * 获取给定节点的排名
     * @param string $node 对应的节点的key名
     * @param string $asc 是否按照分数大小正序排名, true的情况下分数越大,排名越高
     * @return 节点排名,根据$asc排序,true的话,第一高分为0,false的话第一低分为0
     */
    public function getNodeRank($node, $asc = true)
    {
        if ($asc) {
            //zRevRank 分数最高的排行为0,所以需要加1位
            return $this->redis->zRevRank($this->leaderboard, $node);
        } else {
            return $this->redis->zRank($this->leaderboard, $node);
        }
    }

}

网站访问统计。 使用 键(key)

    header("Content-Type:text/html;charset=utf-8");
    include 'lib/mysql.class.php';
    $mysql_obj = mysql::getConn(); 
    $redis = new Redis();
    $redis->pconnect('127.0.0.1', 6379);

    if(isset($_SERVER['HTTP_REFERER'])){
        $url_md5 = md5($_SERVER['HTTP_REFERER']);
    }
    $adve_key = 'adve'; 
    $adve_key_exists = 'adve_exists';
    if(!$redis->exists($adve_key_exists)){
        $list = $mysql_obj->fetch_array("select * from user_online_adve");
        if($list){
            foreach ($list as $key => $value) {
                $url_hash = md5($value['adve_url']);
                $adve_hash_key = $adve_key.":".$url_hash;
                $id = $value['id'];
                $redis->set($adve_hash_key,$id);
                $redis->set($adve_key_exists,true);
                //$redis->hmset($adve_hash_key, array('id' =>$id));
                //print_r($redis->get($adve_hash_key));
            }
        }
    }
    $adve_new_key = $adve_key.':'.$url_md5;
    if($redis->exists($adve_new_key)){
            $adve_plus = $adve_new_key.":plus" ;

            if(!$redis->exists($adve_plus)){
                $redis->set($adve_plus,1);  
            }else{
                $redis->incr($adve_plus);
                $num = $redis->get($adve_plus);
                if($num >10){
                    $id = $redis->get($adve_new_key);
                    // insert to sql;
                    $mysql_obj->query("update user_online_adve set adve_num=adve_num+$num where id=$id");
                    $redis->set($adve_plus,1);
                }
            }
    }
    header('HTTP/1.0 301 Moved Permanently');
    header('Location: https://itunes.apple.com/cn/app/san-guo-zhi15-ba-wangno-da-lu/id694974270?mt=8');

 

分布式集群架构中的session分离。
聊天室的在线好友列表。
数据过期处理（可以精确到毫秒）

redis的所有操作
setex 带生存时间的写入值

$redis->setex('key', 3600, 'value'); 

setnx 判断是否重复的，写入值,如存在了不修改返回0,不存在就添加返回1

$redis->setnx('key', 'value');

返回已经删除key

$redis->delete('key1'); 成功返回1失败返回0
$redis->delete('key1','key2'); 删除两个键成功返回1失败返回0

查询生存时间

$redis->ttl('key1'); 持久化的返回-1，有生存时间的返回时间（单位秒）

同时给多个key赋值,同时设置key0和key1

$redis->mset(array('key0' => 'value0', 'key1' => 'value1'));

key中的值进行自增1，如果填写了第二个参数，者自增第二个参数所填的值

$redis->incr('key1');
$redis->incrBy('key1', 10);

减法跟加法一样

$redis->decr("key1"); 减少1
$redis->decrBy("key1",5) 减少5

list相关操作，连表操作

lPush

$redis->lPush("list", "888");
$id = $redis->lpush('list','HHHHHHH');echo $id;返回链表的元素个数
$redi->lrange('list',0,-1); 返回全部数据，数组形式
$redis->lrange('list',0,2); 返回连表0-2坐标的三个元素

lPushx/rPushx

$redis->lPushx(key, value);

在名称为key的list左边(头)/右边（尾）添加一个值为value的元素,如果value已经存在，则不添加

$redis->lpop('list');输出链表最左边的ksy的值，输出后删除掉这个key
$redis->rpop('list');输出链表最右边的ksy的值，输出后删除掉这个key
$redis->lset('list',7,"update"); 修改坐标为7的值,成功返回1

集合：sadd，sadd是无序的集合,每次插入集合的时候都可能会弄乱里面集合的排序
sadd s1 zhangsan
sadd s1 lisi
sadd s1 wangwu
sadd t1 yangxingyi
sadd t1 lilei
sadd t1 zhangsan
smembers s1 s1的所有集合内容
sdiff s1 t1 s1有的，t1没有的,差集

$redis->sinter('s1','t1');返回s1和t1两个集合都有的,数组形式

scard s1 返回s1集合里面的个数，有多少个就返回多少个,没有从0开始的,坐标才从0开始的
spop抽奖场景，返回集合里面随机的数
spop s1 默认返回1个,返回后就删除这个数，中奖了就不能再中了

$i = $redis->spop('s1');var_dump($i); 返回一个数,返回后删除这个数
$i = $redis->spop('s1',2);var_dump($i);不能返回两个的,提示错误的

随机返回集合里面的一个元素，但不删除，重复中奖

$i = $redis->srandmember('s1');echo $i;

sismember s1 zhangsan 查询张三在不在集合里面,在1，不在false

$i = $redis->sismember('s1','zhangsan2');echo $i;在1，不在false

zadd key 2 value 有序集合
zadd y1 1 zhangsan;
zadd y1 3 lisi;
zadd y1 2 wangwu;
zrange y1 0 -1; 排序就是,根据插入的时候的排序从小到达zhangsan,wangwu,lisi

$i = $redis->zrange('y1',0,-1);var_dump($i);

返回数组，键值不是插入时候给的键，是从0开始的新键
zrevrange y1 0 -1； 反转排序，插入的时候键值越高，排序越优先
zcard y1 ；获取有序集合里面的个数，有多少个就返回多少个,没有从0开始的,坐标才从0开始的
无序就scard,有序就zcard，有z没有s
sInterStore
求交集并将交集保存到output的集合

$redis->sInterStore('output', 'key1', 'key2', 'key3')

Hash操作

hSet 向名称为h的hash中添加元素key1—>hello

$redis->hSet('h', 'key1', 'hello');

hGet 返回名称为h的hash中key1对应的value（hello）

$redis->hGet('h', 'key1');

hLen 返回名称为h的hash中元素个数

$redis->hLen('h');

hDel 删除名称为h的hash中键为key1的域

$redis->hDel('h', 'key1');

hKeys 返回名称为key的hash中所有键

$redis->hKeys('h');

hVals 返回名称为h的hash中所有键对应的value

$redis->hVals('h')

hGetAll 返回名称为h的hash中所有的键（field）及其对应的value

$redis->hGetAll('h');

hExists名称为h的hash中是否存在键名字为a的域

$redis->hExists('h', 'a');

hIncrBy将名称为h的hash中x的value增加2

$redis->hIncrBy('h', 'x', 2);

hMset 向名称为key的hash中批量添加元素

$redis->hMset('user:1', array('name' => 'Joe', 'salary' => 2000));

hMGet 返回名称为h的hash中field1,field2对应的value

$redis->hmGet('h', array('field1', 'field2'));

其他

redis 操作相关
flushDB
清空当前数据库

flushAll
清空所有数据库

randomKey
随机返回key空间的一个key
$key = $redis->randomKey();

select
选择一个数据库
move
转移一个key到另外一个数据库
$redis->select(0); // switch to DB 0
$redis->set('x', '42'); // write 42 to x
$redis->move('x', 1); // move to DB 1
$redis->select(1); // switch to DB 1
$redis->get('x'); // will return 42

rename, renameKey
给key重命名
$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y'); // → 42
$redis->get('x'); // → `FALSE`

renameNx
与remane类似，但是，如果重新命名的名字已经存在，不会替换成功

setTimeout, expire
设定一个key的活动时间（s）
$redis->setTimeout('x', 3);

expireAt
key存活到一个unix时间戳时间
$redis->expireAt('x', time() + 3);

keys, getKeys
返回满足给定pattern的所有key
$keyWithUserPrefix = $redis->keys('user*');

dbSize
查看现在数据库有多少key
$count = $redis->dbSize();

auth
密码认证
$redis->auth('foobared');

bgrewriteaof
使用aof来进行数据库持久化
$redis->bgrewriteaof();

slaveof
选择从服务器
$redis->slaveof('10.0.1.7', 6379);

save
将数据同步保存到磁盘

bgsave
将数据异步保存到磁盘

lastSave
返回上次成功将数据保存到磁盘的Unix时戳

info
返回redis的版本信息等详情

 Redis::__construct构造函数
$redis = new Redis();

connect, open 链接redis服务
参数
host: string，服务地址
port: int,端口号
timeout: float,链接时长 (可选, 默认为 0 ，不限链接时间)
注: 在redis.conf中也有时间，默认为300

pconnect, popen 不会主动关闭的链接
参考上面

setOption 设置redis模式

getOption 查看redis设置的模式

ping 查看连接状态

get 得到某个key的值（string值）
如果该key不存在，return false

set 写入key 和 value（string值）
如果写入成功，return ture

setex 带生存时间的写入值
$redis->setex('key', 3600, 'value'); // sets key → value, with 1h TTL.

setnx 判断是否重复的，写入值
$redis->setnx('key', 'value');
$redis->setnx('key', 'value');

delete  删除指定key的值
返回已经删除key的个数（长整数）
$redis->delete('key1', 'key2');
$redis->delete(array('key3', 'key4', 'key5'));

ttl
得到一个key的生存时间

persist
移除生存时间到期的key
如果key到期 true 如果不到期 false

mset （redis版本1.1以上才可以用）
同时给多个key赋值
$redis->mset(array('key0' => 'value0', 'key1' => 'value1'));



multi, exec, discard
进入或者退出事务模式
参数可选Redis::MULTI或Redis::PIPELINE. 默认是 Redis::MULTI
Redis::MULTI：将多个操作当成一个事务执行
Redis::PIPELINE:让（多条）执行命令简单的，更加快速的发送给服务器，但是没有任何原子性的保证
discard:删除一个事务
返回值
multi()，返回一个redis对象，并进入multi-mode模式，一旦进入multi-mode模式，以后调用的所有方法都会返回相同的对象，只到exec(）方法被调用。

watch, unwatch （代码测试后，不能达到所说的效果）
监测一个key的值是否被其它的程序更改。如果这个key在watch 和 exec （方法）间被修改，这个 MULTI/EXEC 事务的执行将失败（return false）
unwatch  取消被这个程序监测的所有key
参数，一对key的列表
$redis->watch('x');

$ret = $redis->multi() ->incr('x') ->exec();


subscribe *
方法回调。注意，该方法可能在未来里发生改变

publish *
发表内容到某一个通道。注意，该方法可能在未来里发生改变

exists
判断key是否存在。存在 true 不在 false

incr, incrBy
key中的值进行自增1，如果填写了第二个参数，者自增第二个参数所填的值
$redis->incr('key1');
$redis->incrBy('key1', 10);

decr, decrBy
做减法，使用方法同incr

getMultiple
传参
由key组成的数组
返回参数
如果key存在返回value，不存在返回false
$redis->set('key1', 'value1'); $redis->set('key2', 'value2'); $redis->set('key3', 'value3'); $redis->getMultiple(array('key1', 'key2', 'key3'));
$redis->lRem('key1', 'A', 2);
$redis->lRange('key1', 0, -1);

list相关操作
lPush
$redis->lPush(key, value);
在名称为key的list左边（头）添加一个值为value的 元素

rPush
$redis->rPush(key, value);
在名称为key的list右边（尾）添加一个值为value的 元素

lPushx/rPushx
$redis->lPushx(key, value);
在名称为key的list左边(头)/右边（尾）添加一个值为value的元素,如果value已经存在，则不添加

lPop/rPop
$redis->lPop('key');
输出名称为key的list左(头)起/右（尾）起的第一个元素，删除该元素

blPop/brPop
$redis->blPop('key1', 'key2', 10);
lpop命令的block版本。即当timeout为0时，若遇到名称为key i的list不存在或该list为空，则命令结束。如果timeout>0，则遇到上述情况时，等待timeout秒，如果问题没有解决，则对keyi+1开始的list执行pop操作

lSize
$redis->lSize('key');
返回名称为key的list有多少个元素

lIndex, lGet
$redis->lGet('key', 0);
返回名称为key的list中index位置的元素

lSet
$redis->lSet('key', 0, 'X');
给名称为key的list中index位置的元素赋值为value

lRange, lGetRange
$redis->lRange('key1', 0, -1);
返回名称为key的list中start至end之间的元素（end为 -1 ，返回所有）

lTrim, listTrim
$redis->lTrim('key', start, end);
截取名称为key的list，保留start至end之间的元素

lRem, lRemove
$redis->lRem('key', 'A', 2);
删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素

lInsert
在名称为为key的list中，找到值为pivot 的value，并根据参数Redis::BEFORE | Redis::AFTER，来确定，newvalue 是放在 pivot 的前面，或者后面。如果key不存在，不会插入，如果 pivot不存在，return -1
$redis->delete('key1'); $redis->lInsert('key1', Redis::AFTER, 'A', 'X'); $redis->lPush('key1', 'A'); $redis->lPush('key1', 'B'); $redis->lPush('key1', 'C'); $redis->lInsert('key1', Redis::BEFORE, 'C', 'X');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'C', 'Y');
$redis->lRange('key1', 0, -1);
$redis->lInsert('key1', Redis::AFTER, 'W', 'value');

rpoplpush
返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
$redis->delete('x', 'y');
$redis->lPush('x', 'abc'); $redis->lPush('x', 'def'); $redis->lPush('y', '123'); $redis->lPush('y', '456'); // move the last of x to the front of y. var_dump($redis->rpoplpush('x', 'y'));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1)); 

string(3) "abc" 
array(1) { [0]=> string(3) "def" } 
array(3) { [0]=> string(3) "abc" [1]=> string(3) "456" [2]=> string(3) "123" }

SET操作相关
sAdd
向名称为key的set中添加元素value,如果value存在，不写入，return false
$redis->sAdd(key , value);

sRem, sRemove
删除名称为key的set中的元素value
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3');
$redis->sRem('key1', 'set2');

sMove
将value元素从名称为srckey的集合移到名称为dstkey的集合
$redis->sMove(seckey, dstkey, value);

sIsMember, sContains
名称为key的集合中查找是否有value元素，有ture 没有 false
$redis->sIsMember(key, value);

sCard, sSize
返回名称为key的set的元素个数

sPop
随机返回并删除名称为key的set中一个元素

sRandMember
随机返回名称为key的set中一个元素，不删除

sInter
求交集

sInterStore
求交集并将交集保存到output的集合
$redis->sInterStore('output', 'key1', 'key2', 'key3')

sUnion
求并集
$redis->sUnion('s0', 's1', 's2');
s0,s1,s2 同时求并集

sUnionStore
求并集并将并集保存到output的集合
$redis->sUnionStore('output', 'key1', 'key2', 'key3')；

sDiff
求差集

sDiffStore
求差集并将差集保存到output的集合

sMembers, sGetMembers
返回名称为key的set的所有元素

sort
排序，分页等
参数
'by' => 'some_pattern_*',
'limit' => array(0, 1),
'get' => 'some_other_pattern_*' or an array of patterns,
'sort' => 'asc' or 'desc',
'alpha' => TRUE,
'store' => 'external-key'
例子
$redis->delete('s'); $redis->sadd('s', 5); $redis->sadd('s', 4); $redis->sadd('s', 2); $redis->sadd('s', 1); $redis->sadd('s', 3);
var_dump($redis->sort('s')); // 1,2,3,4,5
var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5
 
string命令
getSet
返回原来key中的值，并将value写入key
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
$newValue = $redis->get('x')' // return 'lol'

append
string，名称为key的string的值在后面加上value
$redis->set('key', 'value1');
$redis->append('key', 'value2');
$redis->get('key');

getRange （方法不存在）
返回名称为key的string中start至end之间的字符
$redis->set('key', 'string value');
$redis->getRange('key', 0, 5);
$redis->getRange('key', -5, -1);

setRange （方法不存在）
改变key的string中start至end之间的字符为value
$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis");
$redis->get('key');

strlen
得到key的string的长度
$redis->strlen('key');

getBit/setBit
返回2进制信息

zset（sorted set）操作相关
zAdd(key, score, member)：向名称为key的zset中添加元素member，score用于排序。如果该元素已经存在，则根据score更新该元素的顺序。
$redis->zAdd('key', 1, 'val1');
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 5, 'val5');
$redis->zRange('key', 0, -1); // array(val0, val1, val5)

zRange(key, start, end,withscores)：返回名称为key的zset（元素已按score从小到大排序）中的index从start到end的所有元素
$redis->zAdd('key1', 0, 'val0');
$redis->zAdd('key1', 2, 'val2');
$redis->zAdd('key1', 10, 'val10');
$redis->zRange('key1', 0, -1); // with scores $redis->zRange('key1', 0, -1, true);

zDelete, zRem
zRem(key, member) ：删除名称为key的zset中的元素member
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zDelete('key', 'val2');
$redis->zRange('key', 0, -1); 

zRevRange(key, start, end,withscores)：返回名称为key的zset（元素已按score从大到小排序）中的index从start到end的所有元素.withscores: 是否输出socre的值，默认false，不输出
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRevRange('key', 0, -1); // with scores $redis->zRevRange('key', 0, -1, true);

zRangeByScore, zRevRangeByScore
$redis->zRangeByScore(key, star, end, array(withscores， limit ));
返回名称为key的zset中score >= star且score <= end的所有元素

zCount
$redis->zCount(key, star, end);
返回名称为key的zset中score >= star且score <= end的所有元素的个数

zRemRangeByScore, zDeleteRangeByScore
$redis->zRemRangeByScore('key', star, end);
删除名称为key的zset中score >= star且score <= end的所有元素，返回删除个数

zSize, zCard
返回名称为key的zset的所有元素的个数

zScore
$redis->zScore(key, val2);
返回名称为key的zset中元素val2的score

zRank, zRevRank
$redis->zRevRank(key, val);
返回名称为key的zset（元素已按score从小到大排序）中val元素的rank（即index，从0开始），若没有val元素，返回“null”。zRevRank 是从大到小排序

zIncrBy
$redis->zIncrBy('key', increment, 'member');
如果在名称为key的zset中已经存在元素member，则该元素的score增加increment；否则向集合中添加该元素，其score的值为increment

zUnion/zInter
参数
keyOutput
arrayZSetKeys
arrayWeights
aggregateFunction Either "SUM", "MIN", or "MAX": defines the behaviour to use on duplicate entries during the zUnion.
对N个zset求并集和交集，并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score，在进行AGGREGATE运算前，都要乘以对于的WEIGHT参数。如果没有提供WEIGHT，默认为1。默认的AGGREGATE是SUM，即结果集合中元素的score是所有集合对应元素进行SUM运算的值，而MIN和MAX是指，结果集合中元素的score是所有集合对应元素中最小值和最大值


/*1.Connection*/
$redis = new Redis();
$redis->connect('127.0.0.1',6379,1);//短链接，本地host，端口为6379，超过1秒放弃链接
$redis->open('127.0.0.1',6379,1);//短链接(同上)
$redis->pconnect('127.0.0.1',6379,1);//长链接，本地host，端口为6379，超过1秒放弃链接
$redis->popen('127.0.0.1',6379,1);//长链接(同上)
$redis->auth('password');//登录验证密码，返回【true | false】
$redis->select(0);//选择redis库,0~15 共16个库
$redis->close();//释放资源
$redis->ping(); //检查是否还再链接,[+pong]
$redis->ttl('key');//查看失效时间[-1 | timestamps]
$redis->persist('key');//移除失效时间[ 1 | 0]
$redis->sort('key',[$array]);//返回或保存给定列表、集合、有序集合key中经过排序的元素，$array为参数limit等！【配合$array很强大】 [array|false]
 
/*2.共性的运算归类*/
$redis->expire('key',10);//设置失效时间[true | false]
$redis->move('key',15);//把当前库中的key移动到15库中[0|1]
//string
$redis->strlen('key');//获取当前key的长度
$redis->append('key','string');//把string追加到key现有的value中[追加后的个数]
$redis->incr('key');//自增1，如不存在key,赋值为1(只对整数有效,存储以10进制64位，redis中为str)[new_num | false]
$redis->incrby('key',$num);//自增$num,不存在为赋值,值需为整数[new_num | false]
$redis->decr('key');//自减1，[new_num | false]
$redis->decrby('key',$num);//自减$num，[ new_num | false]
$redis->setex('key',10,'value');//key=value，有效期为10秒[true]
//list
$redis->llen('key');//返回列表key的长度,不存在key返回0， [ len | 0]
//set
$redis->scard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
$redis->sMove('key1', 'key2', 'member');//移动，将member元素从key1集合移动到key2集合。[1 | 0]
//Zset
$redis->zcard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
$redis->zcount('key',0,-1);//返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。[num | 0]
//hash
$redis->hexists('key','field');//查看hash中是否存在field,[1 | 0]
$redis->hincrby('key','field',$int_num);//为哈希表key中的域field的值加上量(+|-)num,[new_num | false]
$redis->hlen('key');//返回哈希表key中域的数量。[ num | 0]
 
/*3.Server*/
$redis->dbSize();//返回当前库中的key的个数
$redis->flushAll();//清空整个redis[总true]
$redis->flushDB();//清空当前redis库[总true]
$redis->save();//同步??把数据存储到磁盘-dump.rdb[true]
$redis->bgsave();//异步？？把数据存储到磁盘-dump.rdb[true]
$redis->info();//查询当前redis的状态 [verson:2.4.5....]
$redis->lastSave();//上次存储时间key的时间[timestamp]
$redis->watch('key','keyn');//监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断 [true]
$redis->unwatch('key','keyn');//取消监视一个(或多个) key [true]
$redis->multi(Redis::MULTI);//开启事务，事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令在一个原子时间内执行。
$redis->multi(Redis::PIPELINE);//开启管道，事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令在一个原子时间内执行。
$redis->exec();//执行所有事务块内的命令，；【事务块内所有命令的返回值，按命令执行的先后顺序排列，当操作被打断时，返回空值 false】
 
/*4.String，键值对，创建更新同操作*/
$redis->setOption(Redis::OPT_PREFIX,'hf_');//设置表前缀为hf_
$redis->set('key',1);//设置key=aa value=1 [true]
$redis->mset($arr);//设置一个或多个键值[true]
$redis->setnx('key','value');//key=value,key存在返回false[|true]
$redis->get('key');//获取key [value]
$redis->mget($arr);//(string|arr),返回所查询键的值
$redis->del($key_arr);//(string|arr)删除key，支持数组批量删除【返回删除个数】
$redis->delete($key_str,$key2,$key3);//删除keys,[del_num]
$redis->getset('old_key','new_value');//先获得key的值，然后重新赋值,[old_value | false]
 
/*5.List栈的结构,注意表头表尾,创建更新分开操作*/
$redis->lpush('key','value');//增，只能将一个值value插入到列表key的表头，不存在就创建 [列表的长度 |false]
$redis->rpush('key','value');//增，只能将一个值value插入到列表key的表尾 [列表的长度 |false]
$redis->lInsert('key', Redis::AFTER, 'value', 'new_value');//增，将值value插入到列表key当中，位于值value之前或之后。[new_len | false]
$redis->lpushx('key','value');//增，只能将一个值value插入到列表key的表头，不存在不创建 [列表的长度 |false]
$redis->rpushx('key','value');//增，只能将一个值value插入到列表key的表尾，不存在不创建 [列表的长度 |false]
$redis->lpop('key');//删，移除并返回列表key的头元素,[被删元素 | false]
$redis->rpop('key');//删，移除并返回列表key的尾元素,[被删元素 | false]
$redis->lrem('key','value',0);//删，根据参数count的值，移除列表中与参数value相等的元素count=(0|-n表头向尾|+n表尾向头移除n个value) [被移除的数量 | 0]
$redis->ltrim('key',start,end);//删，列表修剪，保留(start,end)之间的值 [true|false]
$redis->lset('key',index,'new_v');//改，从表头数，将列表key下标为第index的元素的值为new_v, [true | false]
$redis->lindex('key',index);//查，返回列表key中，下标为index的元素[value|false]
$redis->lrange('key',0,-1);//查，(start,stop|0,-1)返回列表key中指定区间内的元素，区间以偏移量start和stop指定。[array|false]
/*6.Set，没有重复的member，创建更新同操作*/
$redis->sadd('key','value1','value2','valuen');//增，改，将一个或多个member元素加入到集合key当中，已经存在于集合的member元素将被忽略。[insert_num]
$redis->srem('key','value1','value2','valuen');//删，移除集合key中的一个或多个member元素，不存在的member元素会被忽略 [del_num | false]
$redis->smembers('key');//查，返回集合key中的所有成员 [array | '']
$redis->sismember('key','member');//判断member元素是否是集合key的成员 [1 | 0]
$redis->spop('key');//删，移除并返回集合中的一个随机元素 [member | false]
$redis->srandmember('key');//查，返回集合中的一个随机元素 [member | false]
$redis->sinter('key1','key2','keyn');//查，返回所有给定集合的交集 [array | false]
$redis->sunion('key1','key2','keyn');//查，返回所有给定集合的并集 [array | false]
$redis->sdiff('key1','key2','keyn');//查，返回所有给定集合的差集 [array | false]
 
/*7.Zset，没有重复的member，有排序顺序,创建更新同操作*/
$redis->zAdd('key',$score1,$member1,$scoreN,$memberN);//增，改，将一个或多个member元素及其score值加入到有序集key当中。[num | 0]
$redis->zrem('key','member1','membern');//删，移除有序集key中的一个或多个成员，不存在的成员将被忽略。[del_num | 0]
$redis->zscore('key','member');//查,通过值反拿权 [num | null]
$redis->zrange('key',$start,$stop);//查，通过(score从小到大)【排序名次范围】拿member值，返回有序集key中，【指定区间内】的成员 [array | null]
$redis->zrevrange('key',$start,$stop);//查，通过(score从大到小)【排序名次范围】拿member值，返回有序集key中，【指定区间内】的成员 [array | null]
$redis->zrangebyscore('key',$min,$max[,$config]);//查，通过scroe权范围拿member值，返回有序集key中，指定区间内的(从小到大排)成员[array | null]
$redis->zrevrangebyscore('key',$max,$min[,$config]);//查，通过scroe权范围拿member值，返回有序集key中，指定区间内的(从大到小排)成员[array | null]
$redis->zrank('key','member');//查，通过member值查(score从小到大)排名结果中的【member排序名次】[order | null]
$redis->zrevrank('key','member');//查，通过member值查(score从大到小)排名结果中的【member排序名次】[order | null]
$redis->ZINTERSTORE();//交集
$redis->ZUNIONSTORE();//差集
/*8.Hash，表结构，创建更新同操作*/
$redis->hset('key','field','value');//增，改，将哈希表key中的域field的值设为value,不存在创建,存在就覆盖【1 | 0】
$redis->hget('key','field');//查，取值【value|false】
$arr = array('one'=>1,2,3);$arr2 = array('one',0,1);
$redis->hmset('key',$arr);//增，改，设置多值$arr为(索引|关联)数组,$arr[key]=field, [ true ]
$redis->hmget('key',$arr2);//查，获取指定下标的field，[$arr | false]
$redis->hgetall('key');//查，返回哈希表key中的所有域和值。[当key不存在时，返回一个空表]
$redis->hkeys('key');//查，返回哈希表key中的所有域。[当key不存在时，返回一个空表]
$redis->hvals('key');//查，返回哈希表key中的所有值。[当key不存在时，返回一个空表]
$redis->hdel('key',$arr2);//删，删除指定下标的field,不存在的域将被忽略,[num | false]