phpredis

官方文档

关于redis bit操作的原理bitmap(重要)

关于bitmap的应用

1byte(字节)=8bits (位|比特)     utf8 一个汉字三字节即24bits      UTF-32编码中 世界上任何字符的存储都需要4个字节

①ASCII码中，一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最小值0，最大值255。

②UTF-8编码中，一个英文字符等于一个字节，一个中文（含繁体）等于三个字节。

③Unicode编码中，一个英文等于两个字节，一个中文（含繁体）等于两个字节。

符号：英文标点占一个字节，中文标点占两个字节。举例：英文句号“.”占1个字节的大小，中文句号“。”占2个字节的大小。

④UTF-16编码中，一个英文字母字符或一个汉字字符存储都需要2个字节（Unicode扩展区的一些汉字存储需要4个字节）。

⑤UTF-32编码中，世界上任何字符的存储都需要4个字节。
--------------------- 
作者：自由自在_Yu 
来源：CSDN 
原文：https://blog.csdn.net/yuxiangaaaaa/article/details/78060661 
版权声明：本文为博主原创文章，转载请附上博文链接！

 php字符串与二进制的转换  （附phppack和unpack）

header("Content-type: text/html; charset=utf-8");    
  
/**
* 将字符串转换成二进制
* @param type $str
* @return type
*/
function StrToBin($str){
    //1.列出每个字符
    $arr = preg_split('/(?<!^)(?!$)/u', $str);
    //2.unpack字符
    foreach($arr as &$v){
        $temp = unpack('H*', $v);//从二进制字符串对数据进行解包(H十六进制字符串，高位在前)
        $v = base_convert($temp[1], 16, 2);

        if(strlen($v)<8){
            $v=str_pad(strval($v), 8,0,STR_PAD_LEFT);//向左边填充0补齐8个
        }
        unset($temp);
    }
  
    return join(' ',$arr);
}
  
/**
* 讲二进制转换成字符串
* @param type $str
* @return type
*/
function BinToStr($str){
    $arr = explode(' ', $str);
    foreach($arr as &$v){
        $v = pack("H".strlen(base_convert($v, 2, 16)), base_convert($v, 2, 16));
    }
  
    return join('', $arr);
}

按位操作符：

redis DB 概念:

redis有没有什么方法使不同的应用程序数据彼此分开同时又存储在相同的实例上呢？就相当于mysql数据库，不同的应用程序数据存储在不同的数据库下。

redis下，数据库是由一个整数索引标识，而不是由一个数据库名称。
默认情况下，一个客户端连接到数据库0。
redis配置文件中下面的参数来控制数据库总数：databases 16

可以通过下面的命令来切换到不同的数据库下
select 2

随后，所有的命令将使用数据库3，知道你明确的切换到另一个数据库下。

每个数据库都有属于自己的空间，不必担心之间的key冲突。

不同的数据库下，相同的key取到各自的值。

flushdb命令清除数据，只会清除当前的数据库下的数据，不会影响到其他数据库。

flushall命令会清除这个实例的数据。在执行这个命令前要格外小心。

通用：

rawCommand -对服务器执行任何通用命令

$redis->rawCommand("set", "foo", "bar");//true
$redis->rawCommand("get", "foo");
$redis->rawCommand("rpush", "mylist", "one", 2, 3.5));//3
$redis->rawCommand("lrange", "mylist", 0, -1);// ["one", "2", "3.5000000000000000"]

Connection

$redis = new Redis();
$redis->connect('127.0.0.1',6379,1);//短链接，本地host，端口为6379，超过1秒放弃链接   返回boolean
$redis->open('127.0.0.1',6379,1);//短链接(同上)
$redis->pconnect('127.0.0.1',6379,1);//长链接，本地host，端口为6379，超过1秒放弃链接 返回boolean
$redis->popen('127.0.0.1',6379,1);//长链接(同上)
$redis->auth('password');//登录验证密码，返回boolean【true | false】
$redis->select(0);//选择redis库,0~15 共16个库  返回boolean
$redis->swapdb(0, 1);//切换 DB 0 到 DB 1   v4.0++
$redis->close();//释放资源  要释放长链接版本要大于4.2+   返回boolean
$redis->ping(); //检查是否还再链接,[成功返回+pong,否则抛出一个错误]
setOption:设置客户端选项：
例子：
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);      // 不要序列化数据
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);      // 使用内置的序列化/反序列化
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // 使用igBinary serialize/unserialize
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_MSGPACK);  // 使用msgpack serialize/unserialize
$redis->setOption(Redis::OPT_PREFIX, 'myAppName:');    // 在所有键上使用自定义前缀
/*
命令家族的选项，指示是否从用户抽象空结果。如果设置为SCAN_NORETRY(默认值)，phpredis每次只发出一个扫描命令，
有时返回一个空数组的结果。如果设置为SCAN_RETRY, phpredis将重试scan命令，直到返回键或Redis返回一个0迭代器
*/
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
getOption：获取客户端选项
/*返回 Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP, 
  Redis::SERIALIZER_IGBINARY, or Redis::SERIALIZER_MSGPACK其中一个
*/
$redis->getOption(Redis::OPT_SERIALIZER);
$redis->echo('原样返回');//将字符串发送给ReDIS，用相同的字符串回复

 Server

$redis->bgRewriteAOF();//异步重写append-only文件  返回boolean
$redis->bgsave();//异步把DB所有数据存储到磁盘--dump.rdb文件中   返回boolean   
$redis->save();  //同步把DB所有数据存储到磁盘--dump.rdb文件中 返回boolean
$redis->slaveOf('10.0.1.7', 6379);动态更改从库状态（这里将本redis库设置为10.0.0.7 6379 的从库）重新启动之后，他们之间的复制关系将终止。

    如果希望长期保证这两个服务器之间的Replication关系，可以在该配置文件中做如下修改：slaveof 10.0.0.7 6379 
/* 参数为主库master的host（字符串）和主库master的port（int），或者没有参数停止作为从属库。 */
$redis->slaveOf();
$redis->config("GET", "*max-*-entries*");//获取Redis服务器配置参数      文档  返回key-value关联数组
$redis->config("SET", "dir", "/var/run/redis/dumps/");//设置Redis服务器配置参数 返回boolean
$redis->dbSize();//返回当前库中的key的个数
$redis->flushAll();//清空整个redis[返回总是true]  4.0.0+版本有个可选的参数为boolean值 是否异步执行
$redis->flushDB();//清空当前redis库[返回总是true]  4.0.0+版本有个可选参数为boolean值  是否异步执行


$redis->info();//查询当前redis的状态 [verson:2.4.5....]
/*返回提供有关服务器信息的关联数组。不向INFO传递任何参数将调用标准的REDIS INFO命令，该命令返回如下信息
redis_version、arch_bits、uptime_in_seconds、uptime_in_days、connected_clients、connected_slaves、used_memory、changes_since_last_save、bgsave_in_progress、last_save_time、total_connections_received、total_commands_processed、role*/

//您可以将各种选项传递给INFO（根据Redis文档给定的内容），这将返回的参数指定的内容如：

$redis->info("CPU"); /*只返回指定的cpu信息 */
$redis->lastSave();//上次存储时间key的时间戳[timestamp]

$redis->resetStat();//重置info方法返回的统计信息  返回boolean
$redis->time();//返回当前服务器时间  如果成功，时间将作为关联数组返回，其中元素0是unix时间戳，元素1是微秒
//访问Redis slowLog
$redis->slowLog('操作字符[GET/LEN/RESET]', 操作字符为GET时指定返回的长度即数目);
// 获取十个slowLog条目
$redis->slowLog('get', 10);
//获取默认的slowLog
$redis->slowLog('get');
//重置slowLog
$redis->slowLog('reset');
// 检索slowLog长度
$redis->slowLog('len');

 List

/*List栈的结构,注意表头表尾,创建更新分开操作   l表示头部 r表示尾部  b表示阻塞式*/
$redis->lPush('key','value');//增，只能将一个值value插入到列表key的表头，不存在就创建 [列表的长度 |false]
$redis->rPush('key','value');//增，只能将一个值value插入到列表key的表尾，不存在就创建 [列表的长度 |false]
$redis->lInsert('key', Redis::BEFORE | 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]
$redis->lLen('key');//返回列表key的长度,不存在key返回0， [ len | 0]
$redis->lSize('key');//返回列表key的长度,不存在key返回0， [ len | 0]
  blPop() //删，阻塞式移除并返回列表key的头元素,[被删元素 | false]
  brPop() //删，阻塞式移除并返回列表key的尾元素,[被删元素 | false]
  bRPopLPush(listkey1,listkey2,500) - 阻塞式的从列表中移除最后一个元素，将其推附加到另一个列表头部并返回它 
  rPopLPush - 从列表中移除最后一个元素，将其附加到另一个列表头部并返回它（redis> = 1.1）
  //bRPopLPush和rPopLPush是为了解决lpush与rpop的队列业务时取出消息时客户端崩溃导致数据丢失;
  //bRPopLPush和rPopLPush不仅返回一个消息，同时还将这个消息添加到另一个备份列表当中降低容错率;
  //当一个客户端完成某个消息的处理之后，可以用 LREM key count value 命令将这个消息从备份表删除。
  //最后，还可以添加一个客户端专门用于监视备份表，
  //它自动地将超过一定处理时限的消息重新放入队列中去(负责处理该消息的客户端可能已经崩溃)，这样就不会丢失任何消息了

  $redis->lpush('list_key1','value1');
  $redis->lpush('list_key1','value2');
  $redis->lpush('list_key1','value3');

  $value=$redis->rPopLPush('list_key1', 'list_key2');//将list_key1的最后一个移到list_key2(备份列表)的前面并返回该值
  if($service){
    //如果出里的业务成功则移除备份列表的这个值
    $redis->lRem('list_key2',1,$value);    
  }else{
    //失败将该值继续推送到list_key1的头部
    $redis->lpush('list_key1',$value);
  }
  //另一个监视备份列表的脚本 它自动地将超过一定处理时限的消息重新放入队列中去(一般是崩溃情况)
  $c=$redis->object("idletime", "list_key2"); //→ 400 这个只能查询list_key2的空闲时间 并不能实时的监控某个值的情况,当有其他值变化时会刷新这个时间

Set

/*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->sGetMembers('key');//查 返回无序集合中的所有成员
$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]
  $redis->sCard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
  $redis->sMove('key1', 'key2', 'member');//移动，将member元素从key1集合移动到key2集合。[1 | 0]

  sDiffStore(destination,key1,key2,keyn) - 保存指定key的差集到destination集合并返回,destination存在则覆盖 destination 可以是 key 本身
  $redis->sAdd('s0', '1');
  $redis->sAdd('s0', '2');
  $redis->sAdd('s0', '3');
  $redis->sAdd('s0', '4');
  $redis->sAdd('s1', '1');
  $redis->sAdd('s2', '3');
  $redis->sDiffStore('dst', 's0', 's1', 's2');
  $redis->sMembers('dst');//[4,2]
  //sInterStore(newkey,key1,key2,keyn) - 执行sInter命令(交集)并将结果存储在新集合newkey中
  $redis->sAdd('key1', 'val1');
  $redis->sAdd('key1', 'val2');
  $redis->sAdd('key1', 'val3');
  $redis->sAdd('key1', 'val4');
  $redis->sAdd('key2', 'val3');
  $redis->sAdd('key2', 'val4');
  $redis->sAdd('key3', 'val3');
  $redis->sAdd('key3', 'val4');
  $redis->sInterStore('output', 'key1', 'key2', 'key3');
  $redis->sMembers('output');//['val3','val4']

  sUnionStore(newkey,key1,key2,keyn) //执行sUnion命令(并集)并将结果存储在新集合newkey中

  //sScan(key,iterator,key's_pattern,count) - 迭代无需集合的key(替代阻塞的keys*)
  $it = NULL;
  $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); // don't return empty results until we're done 
  while($arr_mems = $redis->sScan('set', $it, "*pattern*")) {
    foreach($arr_mems as $str_mem) {
      echo "Member: $str_mem
";
    }
  }

  $it = NULL;
  $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY); // return after each iteration, even if empty
  while(($arr_mems = $redis->sScan('set', $it, "*pattern*"))!==FALSE) {
    if(count($arr_mems) > 0) {
      foreach($arr_mems as $str_mem) {
        echo "Member found: $str_mem
";
      }
    } else {
      echo "No members in this iteration, iterator value: $it
";
    }
  }

Zset

/*Zset，没有重复的member，有排序顺序,创建更新同操作*/
$redis->zAdd('key',$score1,$member1,$scoreN,$memberN);//增，改，将一个或多个member元素及其score值加入到有序集key当中。[num | 0]注意存其他类型的key与key同名时会放弃添加
$redis->zRem('key','member1','membern');//删，移除有序集key中的一个或多个成员，不存在的成员将被忽略。[del_num | 0]
$redis->zScore('key','member');//查,通过值反拿权 [num | null]
$redis->zRange('key',$start,$stop);//查，通过位偏移范围(索引)拿member值，返回有序集key中指定偏移量分为的的成员,score从低到高排列 [array | null]
$redis->zRevRange('key',$start,$stop);//查，通过位偏移范围(索引)拿member值，返回有序集key中指定偏移量分为的的成员,score从高到底排列 [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->zAdd('key1', 100, 'val0');
$redis->zAdd('key1', 101, 'val1');
$redis->zAdd('key1', 102, 'val2');
$redis->zAdd('key1', 103, 'val3');
$redis->zAdd('key1', 104, 'val4');
$redis->zAdd('key1', 105, 'val5');
$redis->zAdd('key1', 106, 'val6');
$redis->zAdd('key1', 107, 'val7');
$redis->zAdd('key1', 108, 'val8');
$redis->zAdd('key1', 109, 'val9');
$redis->zAdd('key1', 110, 'val10');
$redis->zAdd('key1', 111, 'val11');

$res1=$redis->zRange('key1', 0, -1); //['val0','val1',...,'val11']
$res3=$redis->zRange('key1', 0, -1, false); //['val0','val1',...,'val11']
$res2=$redis->zRange('key1', 0, -1, true); //['val0'=>100,'val1'=>101,...,'val11'=>111]

$res4=$redis->zRevRange('key1', 0, -1, true); //['val11'=>111,'val10'=>110,...,'val0'=>100]
$res=$redis->zRevRange('key1', 0, -1); //['val11','val10',...,'val0']

$index=2; 
$count=5;
$res5=$redis->zRangeByScore('key1', 0, 111); //['val0','val1',...,'val11']
$res6=$redis->zRangeByScore('key1', 100, 111, ['withscores' => TRUE,'limit' => [$index, $count]]); //['val2','val1',...,'val6']

$res7=$redis->zRevRangeByScore('key1', 0, 111); //为什么返回的是空数组?
$res8=$redis->zRevRangeByScore('key1', 100, 111, ['withscores' => TRUE,'limit' => [$index, $count]]); //为什么返回的是空数组?

$redis->zRank('key','member');//查，返回有序集中指定成员的排名（索引）。其中有序集成员按分数值递增(从小到大)顺序排列[order | null]
$redis->zrevrank('key','member');//查，返回有序集合中指定成员的排名（索引），有序集成员按分数值递减(从大到小)排序[order | null]

$redis->zCard('key');//返回集合key的基数(集合中元素的数量)。[num | 0]
$redis->zCount('key',0,-1);//返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员数量。[num | 0]
  //zIncrBy(key,score,value) - 按给定的值自增score分 返回double类型的score总值
    $redis->zIncrBy('key', 1, 'member1'); // 1 
    $redis->zIncrBy('key', 2.5, 'member1'); // 3.5

    zInter(newkey,arrayZSetKeys=[k1,k2,kn], arrayWeights=[score1,score2,scoren],aggregateFunction ='SUM|MAX|MIN') //保存 k1~kn有序集合的交集 到newkey中,并返回并集新集合成员的个数
  //zInter('newkey', ['k1', 'k2'], [1, 1],'SUM');//第三个参数arrayWeights的默认值每个都为1,第四个参数aggregateFunction默认为SUM
  //newkey元素的score计算规则
  //当第四个参数为sum时：(arrayZSetKeys[0]_score*arrayWeights[0])+(arrayZSetKeys[1]_score*arrayWeights[1])+(arrayZSetKeys[n]_score*arrayWeights[n])
  //当第四个参数为max时: max(arrayZSetKeys[0]_score,arrayZSetKeys[1]_score,arrayZSetKeys[n]_score)*max(arrayWeights[0],arrayWeights[1],arrayWeights[n])
  //当第四个参数为min时: min(arrayZSetKeys[0]_score,arrayZSetKeys[1]_score,arrayZSetKeys[n]_score)*min(arrayWeights[0],arrayWeights[1],arrayWeights[n])

    $redis->delete('k1');$redis->delete('k2');$redis->delete('k3');

    $redis->delete('ko1');$redis->delete('ko2');$redis->delete('ko3');$redis->delete('ko4');

    //k1=>[[0.0,val0],[1.0,val1],[3.0,val3]] 
    $redis->zAdd('k1', 0, 'val0');
    $redis->zAdd('k1', 1, 'val1');
    $redis->zAdd('k1', 3, 'val3');
    //k2=>[[2.0,val1],[3.0,val3]]
    $redis->zAdd('k2', 2, 'val1');
    $redis->zAdd('k2', 3, 'val3');

    $a=$redis->zInter('ko1', ['k1', 'k2']); //返回 2 此时:'ko1' => [[3.0,val1],[6.0,val3]] 1*1+2*1 3*1+3*1
    $b=$redis->zInter('ko2', ['k1', 'k2'], [1, 1]); // 2, 'ko2' => [[3.0,val1],[6.0,val3]] 1*1+2*1 3*1+3*1

    $b=$redis->zInter('ko5', ['k1', 'k2'], [1, 10]); // 2, 'ko5' => [[21.0,val1],[33.0,val3]] (1*1)+(2*10) (3*1)+(3*10)
    $b=$redis->zInter('ko6', ['k1', 'k2'], [1, 10],'SUM'); // 2, 'ko6' => [[21.0,val1],[33.0,val3]] (1*1)+(2*10) (3*1)+(3*10)
    $b=$redis->zInter('ko7', ['k1', 'k2'], [5, 10],'MIN'); // 2, 'ko7' => [[5.0,val1],[15.0,val3]] mim(1,2)*5 min(3,3)*5

    $c=$redis->zInter('ko3', ['k1', 'k2'], [1, 5], 'min'); // 2, 'ko3' => [[1.0,val1],[3.0,val3]] min(1,2)*1 min(3,3)*1
    $d=$redis->zInter('ko4', ['k1', 'k2'], [1, 5], 'max'); // 2, 'ko4' => [[10.0,val1],[15.0,val3]] max(1,2)*5 max(3,3)*5

    zRangeByLex(key,min="-",max="+" [,index,count]) //返回相同score情况下指定有序集合键key的(介于min和max之间的)成员，按成员字典正序排序, 注意：分数必须相同
  //min和max必须以[或者(开头[:包含(:不包含 或者min可以有-表示最小 max有+表示最大 注意 排序的是ASCII编码字符,utf8等其他字符排序不准确 
  //k1=>[a,b,...,g];
  //zRangeByLex('key1','-','+');获取所有zset集合
  //zRangeByLex('key1','[a or(a','(c');获取key1所有a-c之间的所有值包含a不包含c 
    $redis->zRangeByLex('key','-','[c') // ['a','b','c']; 
    $redis->zRangeByLex('key','-','(c') // ['a','b'] 
    $redis->zRangeByLex('key','-','[c',1,2) // ['b','c'] 偏移从1开始且只返回两个


  //zRemRangeByRank(key,start,end), zDeleteRangeByRank(key,start,end) - 删除所有有在索引（下标）start~end之间的有序集合返回删除的个数
    $redis->zAdd('key', 1, 'one');
    $redis->zAdd('key', 2, 'two');
    $redis->zAdd('key', 3, 'three');
    $redis->zRemRangeByRank('key', 0, 1); //2 
  //zRemRangeByScore(key,score1,score2), zDeleteRangeByScore(key,score1,score2) - 删除所有有在score权重排序分score1,score2之间的有序集合返回删除的个数
    $redis->zAdd('key', 0, 'val0');
    $redis->zAdd('key', 2, 'val2');
    $redis->zAdd('key', 10, 'val10');
    $redis->zRemRangeByScore('key', 0, 3); //2
   zUnion(newkey,arrayZSetKeys=[k1,k2,kn], arrayWeights=[score1,score2,scoren],aggregateFunction ='SUM|MAX|MIN') // 返回并集；用法同zInter
  //zScan(key,iterator,key_pattern,count) - 迭代有序集合
    $it = NULL;
    $redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
    while($arr_matches = $redis->zScan('zset', $it, '*pattern*')) {
      foreach($arr_matches as $str_mem => $f_score) {
        echo "Key: $str_mem, Score: $f_score
";
      }
    }

 Hash

/*Hash，表结构，创建更新同操作*/
$redis->hset('key','field','value');//增，改，将哈希表key中的域field的值设为value,不存在创建,存在就覆盖【1 | 0】
$redis->hget('key','field');//查，取值【value|false】
$arr = array('one'=>1,2,3,'name'=>'tom',4);$arr2 = array('one',0,1,'name',2);
$redis->hMset('key',$arr);//增，改，设置多值$arr为(索引|关联)数组,$arr[key]=field, [ true ]
$redis->hMget('key',$arr2);//查，获取指定下标的field，[$arr | false]    ["one"=>1,0=>2,1=>3,"name"=>"tom",2=>4]
$redis->hGetAll('key');//查，返回哈希表key中的所有域和值。[当key不存在时，返回一个空表]
$redis->hKeys('key');//查，返回哈希表key中的所有域。[当key不存在时，返回一个空表]
$redis->hVals('key');//查，返回哈希表key中的所有值。[当key不存在时，返回一个空表]
$redis->hDel('key',$arr2);//删，删除指定下标的field,不存在的域将被忽略,[num | false]

$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]

  //hIncrByFloat(key field increment) - 为哈希表key中的域field加上浮点数增量increment
  $redis->hIncrByFloat('h','x', 1.5); //1.5
  $redis->hIncrByFloat('h', 'x', 1.5); //3.0

  //hSetNx(hash field value);-当且仅当第二个参数-[域:field]未存在于哈希表的情况下,将它的值设置为value,第一个参数hash不存在时新建 返回boolean
  $redis->hSetNx('h', 'key1', 'hello');

  hScan(key,cursor [,MATCH pattern] [,COUNT count]);// 迭代hash键 用法和作用同scan
  hStrLen(key field);// 返回哈希表key中,与给定域field相关联的值的字符串长度 返回number 0表示key或者field不存在

string

Strings

//append -向指定的key追加值
$redis->set('key', 'hello');
$redis->append('key', 'world');
$redis->get('key'); //'helloworld'

//setBit(key,offset,value) - 更改字符串(二进制)的单个位 (offset:位偏移 value:布尔、0或者1) 返回设置之前的位的值(0或者1)
$redis->set('key', "*");     // ord("*") = 42(ASCII) = 0x2f(16进制) = 00101010(二进制)
$redis->setBit('key', 5, 1); // 0   (00101110)
$redis->setBit('key', 7, 1); // 0   (00101111)
$redis->get('key');          // "/"

$redis->getBit('key', 5); //1  返回指定某个键偏移量的值



$redis->bitCount('key'); //计算key 所储存的字符串值中，被设置为 1 的比特位的数量

/*
setBit 与bitCount实现用户上线次数统计等计数  例子：记录用户上线了多少天
首先我们要知道网站的上线时间，没过一天则位增加一个(8个才一个字节)
如今天是网站上线的101天 那么我们以用户名为key 网站上线的天数为offset位偏移 用户一上线就将位偏移设置为1
*/
$redis->setBit(tom, 100, 1); //在网站上线的100天的那天登录过(昨天)
$redis->setBit(tom, 101, 1); //在网站上线的101天的那天登录过(今天)
//然后我们通过 bitCount统计tom的二进制位偏移有多少个1 （有多少个1就上线了几天）
$redis->bitCount('tom'); //tom上线了多少天

//bitOp - 在多个键上按位运算(redis现支持的按位操录作符有: "AND", "OR", "NOT", "XOR") BITOP可能是一个缓慢的命令容易阻塞
$redis->set('k1', 'foobar');
$redis->set('k2', 'abcdef');
$a=$redis->bitOp('and','newkey','k1','k2');//6  `bc`ab
$redis->get('newkey'); //`bc`ab
/*过程：
1100110 1101111 1101111 1100010 1100001 1110010
1100001 1100010 1100011 1100100 1100101 1100110
按位与(and)之后：
1100000 1100010 1100011 1100000 1100001 1100010   (`bc`ab)
*/

//计算网站每日活跃用户(登录了多少用户)
$redis->setBit(active01, userid=1, 1); //每月1号为active01,..每月15号为active15  第二个参数用户的id作为偏移量   只要用户一登录就执行这个设置偏移值为1
$redis->bitCount('active01');//计算昨天(1)号的在线人数
//计算网站每月活跃用户（一个月内登陆的用户去重总数）即可把30天的所有bitmap做or计算，然后再计算bitcount
$redis->bitOp('or','month_active','active01','active02','...','active31');
//计算留存率（次日留存=昨天今天连续登的人数/昨天登录的人数）


//自减：
$redis->decr(键,每次自减的位数默认1);    //命令将 key 中储存的数字值增一，如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作，且将key的有效时间设置为长期有效
$redis->decr('key1', 10); 
$redis->decrBy(键,每次自减的位数默认1);  //命令将 key 中储存的数字加上指定的增量值，如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作(命令用于为哈希表中的字段值加上指定增量值)
$redis->decrBy('key1', 10);

//自增：(同decr、decrBy)
$redis->incr('key1',10); //假设key1 不存在, 自增前自动设置为0现在是0+10=10
$redis->incrBy('key1',10); //10+10=20  

//incrByFloat -使用浮点精度自增自减
$redis->incrByFloat('key1', 1.5); //假设key1不存在 自增前自动赋值为0 现在是0+1.5=1.5
$redis->incrByFloat('key1', 1.5); //1.5+1.5=3
$redis->incrByFloat('key1', -1.5);//3-1.5=1.5

$redis->get('key'); //获取redis某个键的值

//setRange(键,替换的起始位置,替换的字符) - 字符替换
$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis"); //Hello redis
$redis->setRange('key', 6, "my"); //Hello mydis
//getRange(键, 开始位, 结束位); 返回指定范围的字符串
$redis->getRange('key', 0, 5);//'Hello '
$redis->getRange('key', -5, -1); //'mydis'

//getSet - 设置一个值并返回该键的上一个条目
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol');    //返回'42'
$newValue = $redis->get('x');           //返回'lol'

//mGet, getMultiple - 获取所有指定键的值。如果一个或多个键不存在，则数组在键的位置将包含FALSE
$redis->set('key1', 'value1');
$redis->mGet(['key0', 'key1', 'key5']); //[`FALSE`, 'value1', `FALSE`]; 返回与键的值相关的数组

//mSet, mSetNX -批量设置键值  返回boolean
$redis->mSet(['key0' => 'value0', 'key1' => 'value1']);
$redis->mSetNX (['dada' => 'value0', 'xiaoxiao' => 'value1']);//当且仅当所有给定key全都不存在时才批量设置键值  返回boolean  key0和key1都不存在才能设置，否则两个都不会设置成功

//set(键,值,过期时间或者扩展数组) - 设置键的值。如果您使用Redis> = 2.6.12，则可以传递扩展选项
$redis->set('key','value', 10);

//TTL, time to live（生存时间）
//setEx, pSetEx - 将设置为指定key的值，并设置生存时间。 PSETEX使用TTL，以毫秒为单位
$redis->setEx('key', 3600, 'value'); // 设置键值, with 1h TTL.  以秒为单位
$redis->pSetEx('key', 100, 'value'); // 设置键值, with 0.1 sec TTL.  以毫秒为单位
//setNx - 键不存在才赋值 返回boolean
$redis->setNx('key', 'value'); //TRUE 
$redis->setNx('key', 'value'); //FALSE

//strLen(键) -获取键对应字符串值的长度
$redis->set('key', 'value');
$redis->strlen('key'); // 5

 

Keys

Keys
//del, delete, unlink - 删除指定的键   返回删除的键数
//unlink 用法同del一致 非阻塞的，并且将异步执行实际删除  v4.0.0++
$redis->delete('key1', 'key2'); // 2
$redis->delete(['key1', 'key2']); // 2

//dump(键) -序列化给定 key的值,并返回;使用 RESTORE 命令可以将这个值反序列化
//restore(key,ttl,dump序列化的值) - 反序列化给定的dump提供的序列化值,并将它和给定的key关联 
$redis->set('foo', 'bar');
$val = $redis->dump('foo'); //返回序列化后的键值(在浏览器上乱码无关紧要)   bar����(
$res=$redis->restore('foo-bar', 0, $val); // foo-bar键的值与foo键的值相同都为bar
$a=$redis->get('foo');
$b=$redis->get('foo-bar');



//exists(string or array) - 检查给定 key 是否存在  返回存在key的数量  版本<4.0.0则返回boolean
$redis->exists('NonExistingKey'); //0  都不存在返回0
$redis->mset(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
$redis->exists(['foo', 'bar', 'baz']);//3
//
$redis->exists('foo', 'bar', 'baz');//3


//expire, setTimeout, pexpire -设定指定key的生存时间（s）  返回boolean
$redis->set('x', '42');
$redis->setTimeout('x', 3);    // 设置x3秒的存活时间
sleep(5);                // 休眠5秒
$redis->get('x');         // 返回false x已经过期了

//expireAt, pexpireAt - 设定指定key生存时间(只接受10位数的时间戳)
$redis->expireAt('x', time()+3);//3秒的生存时间时间
$redis->expireAt('x', 1577811600);//2020/01/01 00:00:00过期

//keys, getKeys - 返回满足给定pattern的所有key ( 查看键的总数dbSize)  
$redis->keys('user');
$redis->keys('user*');//如user1...
$redis->keys('*');//返回所有键

//scan - 迭代数据库的键 (Redis >= 2.8.0)  实际生产中使用这个避免使用keys阻塞数据库
$it=NULL;
$count=1000;//不填第三个参数是返回所有匹配到的键
$match='active*';//匹配键
$arr_keys =  $redis->scan($it,$match,$count);
//与原生的redis scan有点区别
//仿原生:
$it = null;//游标
$match = 'active*';
$count = 10;
$index = 0;
$redis->setOption(Redis::OPT_SCAN,Redis::SCAN_RETRY);
$iterator = null;
while ($keys = call_user_func_array(array($redis, 'scan'), array(&$it, $match,$count))) {
    echo $it. PHP_EOL.'<br>';        
    foreach ($keys as $key) {
        echo $key . PHP_EOL.'<br>';
    }    
}





//migrate(host,port,key/keys,targetDB(0~15),timeout,不移除源实例上的key(拷贝),替换目标实例上已存在的key) - 将key迁移到其他Redis实例 多个key迁移版本必须>=3.0.6
$redis->migrate('127.0.0.1', 6379, 'foo', 0, 3600);
$redis->migrate('backup', 6379, 'foo', 0, 3600, true, true);  // copy and replace
$redis->migrate('backup', 6379, 'foo', 0, 3600, false, true); // just REPLACE flag

/* 迁移多个keys (version >= 3.0.6)
$redis->migrate('backup', 6379, ['key1', 'key2', 'key3'], 0, 3600);


//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


//object(指定返回内容,key)   返回指定key的Redis对象的内部结构
//REFCOUNT: 返回给定key引用所储存的值的次数。此命令主要用于除错
//ENCODING:返回给定key所储存的值所使用的内部编码方式
    //字符串raw(一般字符串)或int (为了节约内存,Redis 会将字符串表示的 64 位有符号整数编码为整数来进行储存)
    //列表:ziplist(是为节约大小较小的列表空间而作的特殊表示)或linkedlist;
    //集合:intset(是只储存数字的小集合的特殊表示)或者hashtable;
    //哈希:zipmap(是小哈希表的特殊表示)或者hashtable;
    //有序集合:ziplist(用于表示小的有序集合)或者skiplist(用于表示任何大小的有序集合)
//IDLETIME:返回给定 key 自储存以来的空闲时间(idle， 没有被读取也没有被写入)，以秒为单位
//返回值: REFCOUNT 和 IDLETIME 返回数字;ENCODING 返回相应的编码类型;如果密钥不存在则为FALSE。
$b=$redis->object("refcount", "month_active"); // → 1
$a=$redis->object("encoding", "active31"); // → raw   
$c=$redis->object("idletime", "active31"); //→ 400 


//persist(键) - 移除给定key的生存时间(key变成永不过时的key)返回boolean
$redis->persist('key');

//randomKey - 从当前数据库中随机返回(不删除)一个 key
$redis->randomKey();//随机返回当前数据库总的key

//rename(旧键名,新键名), renameKey(旧键名,新键名) - 修改键名   返回boolean
$redis->rename('x', 'y');
renameNx(旧键名,新键名) - 当修改的新键名不存在时才修改键名
//type(键名) - 返回指定key所储存的值的类型
$redis->type('key');
//sort(参数) - 对列表、有序集合和无序集合中的元素进行排序
/*
参数有：
    'by' => 'some_pattern_*',
    'limit' => [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);
$redis->sort('s'); // 1,2,3,4,5
$redis->sort('s', ['sort' => 'desc']); // 5,4,3,2,1
$redis->sort('s', ['sort' => 'desc', 'store' => 'out']); // (int)5


//ttl(键), pttl(键) -返回指定键的剩余生存时间 ttl(返回秒) pttl(返回毫秒)
$redis->ttl('key');

事务

事务
multi, exec, discard - 进入和退出交易模式
$ret = $redis->multi(Redis::MULTI)
    ->set('key1', 'val1')
    ->get('key1')
    ->set('key2', 'val2')
    ->get('key2')
    ->exec();//array (true,'val1',true, 'val2')
 
watch['key1','key2','keyn']    监视其他客户端是否修改制定的key  如果在WATCH和EXEC之间修改key，则MULTI/EXEC事务将失败（返回FALSE）
$redis->watch('x');
$ret = $redis->multi()
    ->incr('x')
    ->exec();
unwatch['key1','key2','keyn']  取消 WATCH 命令对所有 key 的监视  如果在执行WATCH命令之后， EXEC命令或DISCARD命令先被执行了的话，那么就不需要再添加这个代码执行UNWATCH了

发布/订阅  显示在前台页面需要结合websoket

//模糊匹配订阅（创建频道）  cli客户端（订阅者）
pSubscribe(patternArr function($redis, $pattern, $channel, $msg){}) - 订阅一个或多个符合给定模式的频道  re* 以re开头的频道; 回调中的任何非null返回值都将返回给调用者
//订阅（创建频道）   cli客户端（订阅者）
subscribe(channelArr,function($redis, $channel, $msg){},$instance) - 订阅(给定的一个或多个)频道的信息   此功能将来可能会发生变化
    $redis->subscribe(
        ['channel-1', 'channel-2', 'channel-3'],
        function($redis, $channel, $msg){
          echo $msg;//subscribe 是阻塞模式的，一直不会结束,这个脚本执行在浏览器是看不到信息的。除非你在下面加上die。。。,所以只能用cli运行模式
        },
    ); 
上面两个订阅是阻塞式的独占链接，需要在后台挂起
//发布消息  cli客户端（被订阅者 无需独占链接不是堵塞的）
publish(channel, message) - 将信息message发送到指定的频道channel(接收到信息message的订阅者数量) 警告：此功能将来可能会发生变化
    $redis->publish('chan-1', 'hello, world!'); // send message.

pubSub($keyWord [,$argument]) - Introspection into the pub/sub subsystem     查看订阅与发布系统状态  返回一个由活跃频道组成的列表
$argument:对于参数1是channels,您可以传递字符串模式,对于参数1是numsub 那么传递一个通道名称数组
返回值根据keyWord的不同而不同
CHANNELS:返回一个数组，其中成员是匹配的频道
NUMSUB:返回键/值数组，其中键是频道名称，值是它们的计数
NUMPAT:返回匹配的活跃订阅的整数

    $redis->pubSub("channels"); //所有频道
    $redis->pubSub("channels", "*pattern*"); //匹配包含pattern的频道
    $redis->pubSub("numsub", ["chan1", "chan2"]); //获取'chan1' 和 'chan2'的订阅者
    $redis->pubSub("numpat"); //获取匹配的订阅者数

我是如何用redis做实时订阅推送的

流streams 

5.0 全新数据类型 数据流streams 
看起来比pubsub可靠多的消息队列。pubsub不靠谱？ 很不靠谱，网络一断或buffer一大就会主动清理数据。stream的设计参考了kafka的消费组模型
以更抽象的方式建模日志的数据结构。Redis的streams主要是一个append only的数据结构，至少在概念上它是一种在内存中表示的抽象数据类型，只不过它们实现了更强大的操作，以克服日志文件本身的限制
如果你了解MQ，那么可以把streams当做MQ。如果你还了解kafka，那么甚至可以把streams当做kafka
这个功能有点类似于redis以前的Pub/Sub，但是也有基本的不同：
streams支持多个客户端（消费者）等待数据（Linux环境开多个窗口执行XREAD即可模拟），并且每个客户端得到的是完全相同的数据
Pub/Sub是发送忘记的方式，并且不存储任何数据；而streams模式下，所有消息被无限期追加在streams中，除非用于显示执行删除（XDEL）
streams的Consumer Groups也是Pub/Sub无法实现的控制方式
streams数据结构本身非常简单，但是streams依然是Redis到目前为止最复杂的类型，其原因是实现的一些额外的功能：一系列的阻塞操作允许消费者等待生产者加入到streams的新数据。另外还有一个称为Consumer Groups的概念，这个概念最先由kafka提出，Redis有一个类似实现，和kafka的Consumer Groups的目的是一样的：允许一组客户端协调消费相同的信息流
stream适用于允许丢失数据的业务场景，因为redis本身是不支持数据的绝对可靠的，哪怕aof调成always
Redis Stream——作为消息队列的典型应用场景  https://segmentfault.com/a/1190000016777728

xAck($stream, $group, $arr_messages_ids) - 确认一条或多条待处理的消息
    $redis->xAck('mystream_key', 'group1', ['1530063064286-0', '1530063064286-1']);

xAdd($str_key, $str_id(* 代表redis自动生成流序列id), $arr_message) - 向流添加消息  返回添加消息的id
    $obj_redis->xAdd('mystream_key', "*", ['field' => 'value']);//1530063064286-0

xClaim($str_key, $str_group, $str_consumer, $min_idle_time, $arr_messages_ids, [$arr_options]) - 获取待处理信息的所有权  返回消息ID数组以及相应的数据
    $ids = ['1530113681011-0', '1530113681011-1', '1530113681011-2'];
    // 无options 
    $obj_redis->xClaim(
        'mystream', 'group1', 'myconsumer1', 0, $ids
    );

    // 有 options 
    $obj_redis->xClaim(
        'mystream', 'group1', 'myconsumer2', 0, $ids,
        [
            'IDLE' => time() * 1000,
            'RETRYCOUNT' => 5,
            'FORCE',
            'JUSTID'
        ]
    );

xDel(stream_key, $arr_messages_ids) - 从流中删除消息
    $redis->xDel('mystream', ['1530115304877-0', '1530115305731-0']);

Group - 创建,销毁或管理消费者群组
    //创建
    $redis->xGroup('CREATE', $str_key, $str_group, $str_msg_id, [$boo_mkstream]);
    //删除
    $redis->xGroup('DESTROY', $str_key, $str_group);
    //管理
    $obj_redis->xGroup('HELP');
    $obj_redis->xGroup('SETID', $str_key, $str_group, $str_msg_id);
    $obj_redis->xGroup('DELCONSUMER', $str_key, $str_group, $str_consumer_name); //删除消费者

xInfo('CONSUMERS/GROUPS/STREAM/HELP', $str_stream, $str_group) - 获取有关流的信息

xLen(stream_key) - 获取流的总数据个数

xPending($str_stream, $str_group [, $str_start, $str_end, $i_count, $str_consumer]) - 检查流中的待处理消息
    $redis->xPending('mystream', 'mygroup', '-', '+', 1, 'consumer-1');

xRange($str_stream, $str_start, $str_end [, $i_count]) - 查询流中的一系列消息
    $redis->xRange('mystream', '-', '+', 2);

xRead($arr_streams [, $i_count, $i_block) - 从流中读取消息
    $redis->xRead(['stream1' => '1535222584555-0', 'stream2' => '1535222584555-0']);
    //仅接收新消息(($=last id)并无限期等待一个新消息
    $redis->xRead(['stream1' => '$'], 1, 0);
//
xReadGroup($str_group, $str_consumer, $arr_streams [, $i_count, $i_block]) - 使用组和消费者一起读取流消息 类似于xRead,但它支持读取特定消费者组的消息  返回传递给此使用者组的消息（如果有）
    $redis->xReadGroup('mygroup', 'consumer2', ['s1' => 0, 's2' => 0], 1, 1000);
xRevRange($str_stream, $str_end, $str_start [, $i_count]) - 查询从start到end的一条或多条消息
    $redis->xRevRange('mystream', '+', '-');
xTrim($str_stream, $i_max_len [, $boo_approximate])- 流裁剪为指定数量的项目
    $obj_redis->xTrim('mystream', 100, true);

Geocoding  地理位置

Geocoding  地理位置
//geoAdd:将给定的空间元素（纬度、经度、名字）添加到指定的键里面。 这些数据会以有序集合的形式被储存在键里面， 从而使得像 GEORADIUS 和 GEORADIUSBYMEMBER 这样的命令可以在之后通过位置查询取得这些元素
//geoAdd($key, $longitude(经度), $latitude(纬度), $name [, $longitude, $latitude, $member, ...]);
    $redis->del("myplaces");
    $result = $redis->geoAdd(
        "myplaces",
        37.773, -122.431, "San Francisco",
        -157.858, 21.315, "Honolulu"
    );
//geoHash(key,name1,name2,namen)  返回一个或多个位置元素的Geohash字符串     返回一个或多个元素组成的Geohash字符串数组
    $hashes = $redis->geoHash("myplaces", "San Francisco", "Honolulu");//['87z9pyek3y0','8e8y6d5jps0']

//geoPos(key,name1,name2,namen)：从键里面返回所有给定位置元素的位置（经度和纬度） 命令返回一个数组， 数组中的每个项都由两个元素(j经度，纬度)组成
    $positions = $redis->geoPos("myplaces", "San Francisco", "Honolulu")//[[37.773, -122.431],[-157.858, 21.315]]
//GeoDist(key,name1,name2 [, $unit='m']):返回两个给定位置之间的距离 unit包含m、km、mi(英里)、ft(英尺)
    $kilometers  = $redis->geoPos("myplaces", "San Francisco", "Honolulu",'km')//168.2752
//geoRadius($key, $longitudee(经度), $latitude(纬度), $radius(半径), $unit [, Array $options]):以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大半径radius距离的所有位置元素
    $redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi');
    $options['count'] = 1;
    $redis->geoRadius("hawaii", -157.858, 21.306, 300, 'mi', $options);

//geoRadiusByMember($key, $name, $radius, $units [, Array $options]):作用和    geoRadius一样只是原点是name决定而不是像geoRadius输入经度和纬度来决定
    $redis->geoRadiusByMember("myplaces", "Honolulu", 300, 'mi');

lua脚本

eval(script ,args_arr ,num_keys-int) - Evaluate a LUA script serverside 通过内置的Lua解释器,对 Lua 脚本进行求值--评估LUA脚本服务器端
evalSha(script_sha_str,args_arr,num_keys_int) - 根据给定的 sha1 校验码，对缓存在服务器中的脚本进行求值 -- 从脚本的SHA1哈希值而不是脚本本身评估LUA脚本服务器端
script(model,script1,script2,scriptn) - 执行Redis SCRIPT命令以对脚本子系统执行各种操作
model包含:
load: 将脚本script1~n添加到脚本缓存中，但并不立即执行这个脚本(eval会立即执行)  将在成功时返回传递脚本的SHA1哈希值，并在失败时返回FALSE
flush:清除所有 Lua 脚本缓存。 始终返回true
kill:杀死当前正在运行的 Lua 脚本，当且仅当这个脚本没有执行过任何写操作时，这个命令才生效  如果脚本能够被杀死则返回true，否则返回false
exists:给定一个或多个脚本的 SHA1 校验和，表示校验和所指定的脚本是否已经被保存在缓存当中  将为每个传递的脚本返回一个TRUE或FALSE的数组

$redis->script('load', $script);
$redis->script('flush');
$redis->script('kill');
$redis->script('exists', $script1, [$script2, $script3, ...]);
client：使用各种参数发出CLIENT命令  Redis CLIENT命令可以以四种方式使用LIST、GETNAME、SETNAME [name]、KILL [ip:port]
    $redis->client('list'); // 获取客户端列表  返回包含客户端信息的数组数组
    $redis->client('getname'); // 获取当前连接的名称  返回客户端名称，如果没有设置，则返回false
    $redis->client('setname', 'somename'); // 设置当前连接的名称  如果可以设置则为true，否则为false
    $redis->client('kill', <ip:port>); // 通过ip:prot 杀死进程   如果客户端可以被杀死则返回true，否则返回false
getLastError - 最后一条错误消息（如果有的话） 包含上次返回的基于脚本的错误消息的字符串，如果没有错误，则为NULL
$redis->eval('this-is-not-lua');
$err = $redis->getLastError();
clearLastError - 清除最后一条错误消息  返回true 
$redis->set('x', 'a');
$redis->incr('x');
$err = $redis->getLastError();
// "ERR value is not an integer or out of range"
$redis->clearLastError();
$err = $redis->getLastError();
_prefix(prefix) - 一种实用工具方法，用于为phpredis的前缀设置添加前缀
$redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
$redis->_prefix('my-value'); // Will return 'my-prefix:my-value'
_unserialize(serialized_value) - 设置了使用任何序列化程序对数据进行反序列化的实用程序方法
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
$redis->_serialize("foo"); // returns "foo"
$redis->_serialize([]); // Returns "Array"
$redis->_serialize(new stdClass()); // Returns "Object"

$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
$redis->_serialize("foo"); // Returns 's:3:"foo";'
_serialize(unserialized_value) - 设置了使用任何序列化程序序列化数据的实用程序方法
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
$redis->_unserialize('a:3:{i:0;i:1;i:1;i:2;i:2;i:3;}'); // Will return [1,2,3]

Introspection  自我检测

isConnected() ：确定phpredis对象是否认为它已连接到服务器的方法  返回boolean
getHost()：检索我们连接到的主机或unix套接字
getPort():获取我们连接的端口
getDbNum():获取phpredis指向的数据库编号
getTimeout():获取phpredis使用的（写）超时
getReadTimeout():获取指定给phpredis的读取超时或如果我们没有连接则为FALSE
getPersistentID():获取phpredis正在使用的持久ID
getAuth():获取用于验证phpredis连接的密码

 多余：

$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]$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]