Rides 3.0.0 API
construct
语法：__construct()
定义：构造方法
$redis = new Redis();
connect
语法：connect( $host, $port = 6379, $timeout = 0.0, $retry_interval)
定义：连接一个reids实例
参数：
- $host string 一个主机地址或者是UNIX的套间字路径
- $port int redis端口，默认6379
- $timeout float [option] 连接时长，单位为秒。默认值为0.0，表示不限制时间
- $retry_interval int [option] 重试连接的时间间隔，单位为毫秒。默认为0。
返回值：true/false 连接成功/连接失败
$redis->connect('127.0.0.1', 6379);
$redis->connect('127.0.0.1'); // port 6379 by default
$redis->connect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
$redis->connect('/tmp/redis.sock'); // unix domain socket.
psetex
语法：psetex($key, $ttl, $value)
定义：将参数中的字符串设置为key的值，并指定生存周期
参数：
- $key string 键名
- $ttl int 该键的生存周期，单位为毫秒。
- $value string 键值
返回值：true/false 命令成功/失败
$redis->psetex('key', 100, 'value');
scan
语法：scan( &$iterator, $pattern = null, $count = 0 )
定义：扫描所有的key。
参数：
- $iterator int 迭代器，初始值为空。
- $pattern string 模式匹配。
- $count int 每次迭代的键的个数（对redis来说只是个建议）
返回值：array/bool 如果有key返回一个数组，如果没有返回false
$iterator = null;
while($keys = $redis->scan($iterator)) {
foreach($keys as $key) {
echo $key . PHP_EOL;
}
}
client
语法：client($command, $arg = '')
定义：用各种参数发出客户端命令
参数：
- $command string 客户端命令名 list|getname|setname|kill
- $arg string 客户端命令的参数值
返回值：mixed
$redis->client('list');
$redis->client('getname');
$redis->client('setname', 'somename');
$redis->client('kill', <ip:port>);
slowlog
语法：slowlog($command) redis的slowlog记录了那些执行时间超过规定时长的请求。执行时间不包括I/O操作（比如与客户端进行网络通信等），只是命令的实际执行时间（期间线程会被阻塞，无法服务于其它请求）。
定义：读取solwlog日志
参数：
- $command string 读取日志命令名 get|len|reset
- $arg string 读取日志命令的参数值
返回值：mixed
//获取10条日志信息
$redis->slowlog('get', 10);
//获取所有日志信息
$redis->slowlog('get');
//重置日志信息
$redis->slowlog('reset');
//获取日志信息长度
$redis->slowlog('len');
open
语法：open( $host, $port = 6379, $timeout = 0.0, $retry_interval = 0 ) 同 connect
pconnect
语法：pconnect( $host, $port = 6379, $timeout = 0.0 )
定义：连接到一个redis示例或者重用一个已经通过pconnect,popen建立的链接 在关闭或结束请求之前，连接将不会关闭，直到PHP进程结束。
参数：
- $host string 一个主机地址或者是UNIX的套间字路径
- $port int redis端口，默认6379
- $timeout float [option] 连接时长，单位为秒。默认值为0.0，表示不限制时间
返回值：true/false 连接成功/连接失败
$redis->pconnect('127.0.0.1', 6379);
$redis->pconnect('127.0.0.1'); // port 6379 by default
$redis->pconnect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout.
$redis->pconnect('/tmp/redis.sock'); // unix domain socket.
popen
语法：popen( $host, $port = 6379, $timeout = 0.0 ) 同 pconnect
close
语法：close()
定义：关闭redis链接，如果使用pconnect/popen函数无效
setOption
语法：setOption( $name, $value )
定义：设置客户端参数
参数：
- $name string 参数名
- $value string 参数值
返回值：true/false
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // don't serialize data
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP); // use built-in serialize/unserialize
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // use igBinary serialize/unserialize
$redis->setOption(Redis::OPT_PREFIX, 'myAppName:'); // use custom prefix on all keys
getOption
语法：getOption($name)
定义：获取客户端参数
参数：
- $name string 参数名
返回值：int 参数值
$redis->getOption(Redis::OPT_SERIALIZER);
ping
语法：ping()
定义：测试链接状态
返回值：string 如果连接成功，返回+PONG
$redis->ping();
get
语法：get( $key )
定义：获取与指定键相关的值
参数：
- $name string 键名
返回值：string/bool 如果该键有值则返回字符串，如果没有返回false
$redis->get('key');
set
语法：set( $key, $value, $timeout = 0 )
定义：将参数中的字符串设置为键的值并指定生存周期
参数：
- $key string 键名
- $value string 键值
- $timeout int [optional] 该键的生存周期。(如果想设置生存周期，請使用setex函数)
返回值：bool 命令执行成功返回true
$redis->set('key', 'value');
setex
语法：setex( $key, $ttl, $value )
定义：将参数中的字符串设置为键的值并指定生存周期
参数：
- $key string 键名
- $ttl int 该键的生存周期，单位为秒。
- $value string 键值
返回值：bool 命令执行成功返回true
$redis->setex('key', 3600, 'value');
setnx
语法：setnx( $key, $value )
定义：如果该key不存在，则给这个key设置值
参数：
- $key string 键名
- $value string 键值
返回值：bool 如果该key已经存在返回false，如果不存在并且命令执行成功返回true
$redis->setnx('key', 'value'); // return TRUE
$redis->setnx('key', 'value'); // return FALSE
del
语法：del( $key1, $key2 = null, $key3 = null )
定义：删除一个或多个键值
参数：
- $key1 int|array 键名数组或者枚举的key:key1,key2,key3,....keyN
返回值：返回删除了几个key
$redis->set('key1', 'val1');
$redis->set('key2', 'val2');
$redis->set('key3', 'val3');
$redis->set('key4', 'val4');
$redis->delete('key1', 'key2'); // return 2
$redis->delete(array('key3', 'key4')); // return 2
delete
语法：delete( $key1, $key2 = null, $key3 = null ) 同 del
multi
语法：multi( $mode = Redis::MULTI )
定义：进入和退出事物模式
参数：
- $mode int Redis::MULTI|Redis::PIPELINE 默认值为Redis::MULTI
- Redis::MULTI 所有的命令都看成是一个事物
- Redis::PIPELINE 可以更快的与服务器交互，但是不能保证原子性。
返回值：redis实例
$ret = $redis->multi()
->set('key1', 'val1')
->get('key1')
->set('key2', 'val2')
->get('key2')
->exec();
$ret == array (
0 => TRUE,
1 => 'val1',
2 => TRUE,
3 => 'val2'
);
exec
语法：exec()
定义：提交一个事物
discard
语法：discard()
定义：取消一个事物
watch
语法：watch($key)
定义：监听一个连接的key是否被另一个客户端更改。如果发生更改则多事物失败。unwatch取消所有key的监听。
参数：
- $key string|array 被监听的秘钥、秘钥列表
返回值：void
$redis->watch('x');
// long code here during the execution of which other clients could well modify `x`
$ret = $redis->multi()
->incr('x')
->exec();
// $ret = FALSE if x has been modified between the call to WATCH and the call to EXEC.
unwatch
语法：unwatch()
定义：取消所有key的监听
subscribe
语法：subscribe( $channels, $callback )
定义：订阅频道。警告：这个功能将来可能会改变。
参数：
- $channels array 被订阅的频道数组
- $callback functoin|string|array 回调函数接收三个参数：
- redis Redis实例
- $chan 频道名字
- $msg 信息
function f($redis, $chan, $msg) {
switch($chan) {
case 'chan-1':
...
break;
case 'chan-2':
...
break;
case 'chan-2':
...
break;
}
}
// subscribe to 3 chans
$redis->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f');
psubscribe
语法：psubscribe( $patterns, $callback )
定义：按模式订阅频道
function psubscribe($redis, $pattern, $chan, $msg) {
echo "Pattern: $pattern\n";
echo "Channel: $chan\n";
echo "Payload: $msg\n";
}
publish
语法：publish( $channel, $message )
定义：向频道发送消息。这个函数未来会改变
参数：
- $channels array 被订阅的channel
- $message string 消息
返回值：int 接到消息的客户端的个数
$redis->publish('chan-1', 'hello, world!');
pubsub
语法：pubsub( $keyword, $argument )
定义：可以通过pub/sub 系统获得信息的命令
参数：
- $keyword string channels|numsub|numpat
- $argument string|array 如果是"channels",$argument:正则表达式；如果是numsub，$argument:频道数组
返回值：int|array
- channels 返回符合这个正则表达式的频道数组
- numsub 返回订阅这些频道的客户端
- numpat 返回模式订阅的频道的个数
$redis->pubsub('channels'); // All channels
$redis->pubsub('channels', '*pattern*'); // Just channels matching your pattern
$redis->pubsub('numsub', array('chan1', 'chan2')); // Get subscriber counts for 'chan1' and 'chan2'
$redis->pubsub('numpat'); // Get the number of pattern subscribers
exists
语法：exists( $key )
定义：判断是否存在key
参数：
- $key string 键名
返回值：bool 存在返回true，失败返回false
$redis->set('key', 'value');
$redis->exists('key'); // TRUE
$redis->exists('NonExistingKey'); // FALSE
public
语法：public function incr( $key )
定义：将已经存储的key的值加1
参数：
- $key string 键名
返回值：int 加1后的值
$redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
$redis->incr('key1'); // 2
$redis->incr('key1'); // 3
$redis->incr('key1'); // 4
incrByFloat
语法：incrByFloat( $key, $increment )
定义：将已经存储的key的值增加指定步长
参数：
- $key string 键名
- $increment float 指定的步长
返回值：float 增加步长后的值
$redis = new Redis();
$redis->connect('127.0.0.1');
$redis->set('x', 3);
var_dump( $redis->incrByFloat('x', 1.5) ); // float(4.5)
// ! SIC
var_dump( $redis->get('x') ); // string(3) "4.5"
incrBy
语法：incrBy( $key, $value )
定义：将已经存储的key的值增加指定步长
参数：
- $key string 键名
- $value int 指定的步长
返回值：int 增加步长后的值
$redis->incr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value 1
$redis->incr('key1'); // 2
$redis->incr('key1'); // 3
$redis->incr('key1'); // 4
$redis->incrBy('key1', 10); // 14
decr
语法：decr( $key )
定义：将已经存储的key的值递减
参数：
- $key string 键名
返回值：int 递减步长后的值
$redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
$redis->decr('key1'); // -2
$redis->decr('key1'); // -3
decrBy
语法：decrBy( $key, $value )
定义：将已经存储的key的值按照指定步长递减
参数：
- $key string 键名
- $value int 指定的步长
返回值：int 递减步长后的值
$redis->decr('key1'); // key1 didn't exists, set to 0 before the increment and now has the value -1
$redis->decr('key1'); // -2
$redis->decr('key1'); // -3
$redis->decrBy('key1', 10); // -13
getMultiple
语法：getMultiple( array $keys )
定义：获取多个key的值 如果key不存在则返回false
参数：
- $keys array 键名数组
返回值：array 多个key对应的value的数组
$redis->set('key1', 'value1');
$redis->set('key2', 'value2');
$redis->set('key3', 'value3');
$redis->getMultiple(array('key1', 'key2', 'key3')); // array('value1', 'value2', 'value3');
$redis->getMultiple(array('key0', 'key1', 'key5')); // array(`FALSE`, 'value2', `FALSE`);
lPush
语法：lPush( $key, $value1, $value2 = null, $valueN = null )
定义：将一个或多个值插入到指定的列表中(双向链表实现)，如果列表不存在则创建
参数：
- $keys string 列表名
- $value1 string 列表的值
返回值：int/bool 命令执行成功返回列表长度，否则返回false
$redis->lPush('l', 'v1', 'v2', 'v3', 'v4') // int(4)
var_dump( $redis->lRange('l', 0, -1) );
Output:
array(4) {
[0]=> string(2) "v4"
[1]=> string(2) "v3"
[2]=> string(2) "v2"
[3]=> string(2) "v1"
}
rPush
语法：rPush( $key, $value1, $value2 = null, $valueN = null )
定义：将一个或多个值插入到指定的列表中(双向链表实现)，如果列表不存在则创建
参数：
- $keys string 列表名
- $value1 string 列表的值
返回值：int/bool 命令执行成功返回列表长度，否则返回false
$redis->lPush('l', 'v1', 'v2', 'v3', 'v4') // int(4)
var_dump( $redis->lRange('l', 0, -1) );
Output:
array(4) {
[0]=> string(2) "v1"
[1]=> string(2) "v2"
[2]=> string(2) "v3"
[3]=> string(2) "v4"
}
lPushx
语法：lPushx( $key, $value )
定义：如果列表存在，则将value保存到列表的头部
参数：
- $keys string 列表名
- $value string 列表的值
返回值：int/bool 命令执行成功返回列表长度，否则返回false
$redis->delete('key1');
$redis->lPushx('key1', 'A'); // returns 0
$redis->lPush('key1', 'A'); // returns 1
$redis->lPushx('key1', 'B'); // returns 2
$redis->lPushx('key1', 'C'); // returns 3
// key1 now points to the following list: [ 'C', 'B', 'A' ]
rPushx
语法：rPushx( $key, $value )
定义：如果列表存在，则将value保存到列表的尾部
参数：
- $keys string 列表名
- $value string 列表的值
返回值：int/bool 命令执行成功返回列表长度，否则返回false
$redis->delete('key1');
$redis->rPushx('key1', 'A'); // returns 0
$redis->rPushx('key1', 'A'); // returns 1
$redis->rPushx('key1', 'B'); // returns 2
$redis->rPushx('key1', 'C'); // returns 3
// key1 now points to the following list: [ 'A', 'B', 'C' ]
lPop
语法：lPop( $key )
定义：删除列表中的第一个元素
参数：
- $keys string 列表名
返回值：string/bool 成功返回被删除的值，失败返回false
$redis->delete('key1');
$redis->rPushx('key1', 'A'); // returns 0
$redis->rPushx('key1', 'A'); // returns 1
$redis->rPushx('key1', 'B'); // returns 2
$redis->rPushx('key1', 'C'); // returns 3
// key1 now points to the following list: [ 'A', 'B', 'C' ]
$redis->lpop('key1'); //['B','C']
rPop
语法：rPop( $key )
定义：删除列表中的最后一个元素
参数：
- $keys string 列表名
返回值：string/bool 成功返回被删除的值，失败返回false
$redis->delete('key1');
$redis->rPushx('key1', 'A'); // returns 0
$redis->rPushx('key1', 'A'); // returns 1
$redis->rPushx('key1', 'B'); // returns 2
$redis->rPushx('key1', 'C'); // returns 3
// key1 now points to the following list: [ 'A', 'B', 'C' ]
$redis->rpop('key1'); //['A','B']
blPop
语法：blPop( array $keys, $timeout)
定义：如果所有给定的key至少有一个不是空列表，则返回第一个非空列表的第一个值；如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。
参数：
- $keys array|string 列表key数组，也可以是多个key值:$key1,$key2,$key3,...$keyN
- $timeout long 等待超时时间
返回值：array 返回第一个非空列表的key和这个非空列表的第一个值组成的数组
// Non blocking feature
$redis->lPush('key1', 'A');
$redis->delete('key2');
$redis->blPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redis->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
$redis->brPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
// Blocking feature
// process 1
$redis->delete('key1');
$redis->blPop('key1', 10);
// blocking for 10 seconds
// process 2
$redis->lPush('key1', 'A');
// process 1
// array('key1', 'A') is returned
brPop
语法：brPop( array $keys, $timeout)
定义：如果所有给定的key至少有一个不是空列表，则返回第一个非空列表的最后一个值；如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。
参数：
- $keys array|string 列表key数组，也可以是多个key值:$key1,$key2,$key3,...$keyN
- $timeout long 等待超时时间
返回值：array 返回第一个非空列表的key和这个非空列表的最后一个值组成的数组
// Non blocking feature
$redis->lPush('key1', 'A');
$redis->delete('key2');
$redis->blPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redis->blPop(array('key1', 'key2'), 10); // array('key1', 'A')
$redis->brPop('key1', 'key2', 10); // array('key1', 'A')
// OR
$redis->brPop(array('key1', 'key2'), 10); // array('key1', 'A')
// Blocking feature
// process 1
$redis->delete('key1');
$redis->blPop('key1', 10);
// blocking for 10 seconds
// process 2
$redis->lPush('key1', 'A');
// process 1
// array('key1', 'A') is returned
lLen
语法：lLen( $key )
定义：返回列表的长度
参数：
- $keys string 列表键名
返回值：int/bool 如果列表存在返回列表长度，如果列表不存在返回0，如果$key对应的不是列表返回false
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
$redis->lLen('key1'); // 3
$redis->rPop('key1');
$redis->lLen('key1'); // 2
lSize
语法：lSize( $key ) 见lLen
lIndex
语法：lIndex( $key, $index )
定义：获取列表中第几个元素。
参数：
- $keys string 列表键名
- $index int 列表下角标，非负数
返回值：string 列表中对应下角标的元素。如果$key不合法则，或者超过列表长度，返回FALSE；如果key未指向列表，返回FALSE。
$redis->delete('key1');
$redis->lPush('key1','1');
$redis->lPush('key1','2');
$redis->lPush('key1','3');
$redis->lPush('key1','4');
$redis->lIndex('key1',0); //1
$redis->lIndex('key1',5); //false
lGet
语法：lGet( $key, $index ) 见lIndex
lSet
语法：lSet( $key, $index, $value )
定义：设置列表中第index的值
参数：
- $keys string 列表键名
- $index int 列表下角标，非负数
- $value string value
返回值：bool 如果命令执行成功返回TRUE，如果index超出了数组的范围返回FALSE；如果key指向的不是list返回FALSE。
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); // key1 => [ 'A', 'B', 'C' ]
$redis->lGet('key1', 0); // 'A'
$redis->lSet('key1', 0, 'X');
$redis->lGet('key1', 0); // 'X'
lRange
语法：lRange( $key, $start, $end )
定义：获取列表中某一段的值的集合
参数：
- $keys string 列表键名
- $start int 开始位置
- $end int 结束位置
返回值：array 列表中的值组成的数组
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
lGetRange
语法：lGetRange( $key, $start, $end ) 见lRange
lTrim
语法：lTrim( $key, $start, $stop )
定义：按照指定位置截取列表
参数：
- $keys string 列表键名
- $start int 开始位置
- $stop int 结束位置
返回值：bool 如果命令执行成功返回TRUE，如果key指向的不是list返回FALSE。
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1); // array('A', 'B', 'C')
$redis->lTrim('key1', 0, 1);
$redis->lRange('key1', 0, -1); // array('A', 'B')
listTrim
语法：listTrim( $key, $start, $stop ) 见lTrim
lRem
语法：lRem( $key, $value, $count )
定义：根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素，从列表尾部开始。如果COUNT为0则全部删除
参数：
- $keys string 列表键名
- $value int VALUE
- $count int 删除个数
返回值:int/bool 删除元素的个数，如果key指向的不是list返回FALSE。
$redis->lPush('key1', 'A');
$redis->lPush('key1', 'B');
$redis->lPush('key1', 'C');
$redis->lPush('key1', 'A');
$redis->lPush('key1', 'A');
$redis->lRange('key1', 0, -1); // array('A', 'A', 'C', 'B', 'A')
$redis->lRem('key1', 'A', 2); // 2
$redis->lRange('key1', 0, -1); // array('C', 'B', 'A')
lRemove
语法：lRemove( $key, $value, $count ) 见lRem
lInsert
语法：lInsert( $key, $position, $pivot, $value )
定义：想指定位置插入值
参数：
- $keys string 列表键名
- $position int 常量 Redis::BEFORE | Redis::AFTER
- $pivot string 相对位置（列表中的元素）
- $value string 被插入的值
返回值：int 返回插入后列表长度。当列表为空时，pivot不存在返回0，当列表不为空，pivot不存在返回-1。
$redis->delete('key1');
$redis->lInsert('key1', Redis::AFTER, 'A', 'X'); // 0
$redis->lPush('key1', 'A');
$redis->lPush('key1', 'B');
$redis->lPush('key1', 'C');
$redis->lInsert('key1', Redis::BEFORE, 'C', 'X'); // 4
$redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C')
$redis->lInsert('key1', Redis::AFTER, 'C', 'Y'); // 5
$redis->lRange('key1', 0, -1); // array('A', 'B', 'X', 'C', 'Y')
$redis->lInsert('key1', Redis::AFTER, 'W', 'value'); // -1
sAdd
语法：sAdd( $key, $value1, $value2 = null, $valueN = null )
定义：向集合中添加数据
参数：
- $keys string 集合键名
- $value1 string
返回值：int/bool 向里列表中添加元素的个数。如果已经存在返回false
$redis->sAdd('k', 'v1'); // int(1)
$redis->sAdd('k', 'v1', 'v2', 'v3'); // int(2)
sAddArray
语法：sAddArray( $key, array $values)
定义：以数组的形式向集合中添加元素
参数：
- $keys string 集合键名
- $array array 向集合中添加的元素的数组
返回值：int/bool 向里列表中添加元素的个数。如果已经存在返回false
$redis->sAddArray('k', array('v1')); // boolean
$redis->sAddArray('k', array('v1', 'v2', 'v3')); // boolean
sRem
语法：sRem( $key, $member1, $member2 = null, $memberN = null )
定义：移除集合中的值
参数：
- $keys string 合中键名
- $member1 string
返回值:删除元素的个数
var_dump( $redis->sAdd('k', 'v1', 'v2', 'v3') ); // int(3)
var_dump( $redis->sRem('k', 'v2', 'v3') ); // int(2)
var_dump( $redis->sMembers('k') );
Output:
// array(1) {
// [0]=> string(2) "v1"
// }
sRemove
语法：sRemove( $key, $member1, $member2 = null, $memberN = null ) 见sRem
sMove
语法：sMove( $srcKey, $dstKey, $member )
定义：从一个集合向另一个集合中移动元素
参数：
- $srcKey string 源集合
- $dstKey string 目标集合
- $member string 被移动的元素
返回值：bool 成功返回TRUE，如果源集合或者目标集合不存在返回false，如果$member不存在返回false
$redis->sAdd('key1' , 'set11');
$redis->sAdd('key1' , 'set12');
$redis->sAdd('key1' , 'set13'); // 'key1' => {'set11', 'set12', 'set13'}
$redis->sAdd('key2' , 'set21');
$redis->sAdd('key2' , 'set22'); // 'key2' => {'set21', 'set22'}
$redis->sMove('key1', 'key2', 'set13'); // 'key1' => {'set11', 'set12'}
// 'key2' => {'set21', 'set22', 'set13'}
sIsMember
语法：sIsMember( $key, $value )
定义：判断集合中是否存在改元素
参数：
- $key string 集合键值
- $value string 被检查的元素
返回值：bool 存在返回TRUE，失败返回FALSE。
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
$redis->sIsMember('key1', 'set1'); // TRUE
$redis->sIsMember('key1', 'setX'); // FALSE
sContains
语法：sContains( $key, $value ) 见sIsMember
sCard
语法：sCard( $key )
定义：获得集合的长度
参数：
- $key string 集合键值
返回值：int 返回集合长度，如果不存在返回0
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3'); // 'key1' => {'set1', 'set2', 'set3'}
$redis->sCard('key1'); // 3
$redis->sCard('keyX'); // 0
sPop
语法：sPop( $key )
定义：随机删除一个集合中的值并返回
参数：
- $key string 集合键值
返回值：string 被删除的值
$redis->sAdd('key1' , 'set1');
$redis->sAdd('key1' , 'set2');
$redis->sAdd('key1' , 'set3'); // 'key1' => {'set3', 'set1', 'set2'}
$redis->sPop('key1'); // 'set1', 'key1' => {'set3', 'set2'}
$redis->sPop('key1'); // 'set3', 'key1' => {'set2'}
sRandMember
语法：sRandMember( $key, $count = null )
定义：随机返回一个集合中的值
参数：
- $key string 集合键值
返回值：string 被选中的值
$redis->sAdd('key1' , 'one');
$redis->sAdd('key1' , 'two');
$redis->sAdd('key1' , 'three'); // 'key1' => {'one', 'two', 'three'}
var_dump( $redis->sRandMember('key1') ); // 'key1' => {'one', 'two', 'three'}
// string(5) "three"
var_dump( $redis->sRandMember('key1', 2) ); // 'key1' => {'one', 'two', 'three'}
// array(2) {
// [0]=> string(2) "one"
// [1]=> string(2) "three"
// }
sInter
语法：sInter( $key1, $key2, $keyN = null )
定义：取几个集合的交集
参数：
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：array/bool 交集的数组,如果其中一个集合不存在返回false
$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');
var_dump($redis->sInter('key1', 'key2', 'key3'));
//array(2) {
// [0]=>
// string(4) "val4"
// [1]=>
// string(4) "val3"
//}
sInterStore
语法：sInterStore( $dstKey, $key1, $key2, $keyN = null )
定义：取几个集合的交集并存放到另外一个集合中
参数：
- $dstKey string 目标集合的键值
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：int/bool 新集合的元素个数，如果其中有一个集合不存在则返回false
$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');
var_dump($redis->sInterStore('output', 'key1', 'key2', 'key3'));
var_dump($redis->sMembers('output'));
//int(2)
//
//array(2) {
// [0]=>
// string(4) "val4"
// [1]=>
// string(4) "val3"
//}
sUnion
语法：sUnion( $key1, $key2, $keyN = null )
定义：取几个集合的并集
参数：
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：array 合并后的数组
$redis->delete('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s1', '3');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
$redis->sAdd('s2', '4');
var_dump($redis->sUnion('s0', 's1', 's2'));
array(4) {
// [0]=>
// string(1) "3"
// [1]=>
// string(1) "4"
// [2]=>
// string(1) "1"
// [3]=>
// string(1) "2"
//}
sUnionStore
语法：sUnionStore( $dstKey, $key1, $key2, $keyN = null )
定义：取几个集合的并集并存放到另外一个集合中
参数：
- $dstKey string 目标集合的键值
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：int/bool 新集合的元素个数，如果其中有一个集合不存在则返回false
$redis->delete('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s1', '3');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
$redis->sAdd('s2', '4');
var_dump($redis->sUnionStore('dst', 's0', 's1', 's2'));
var_dump($redis->sMembers('dst'));
//int(4)
//array(4) {
// [0]=>
// string(1) "3"
// [1]=>
// string(1) "4"
// [2]=>
// string(1) "1"
// [3]=>
// string(1) "2"
//}
sDiff
语法：sDiff( $key1, $key2, $keyN = null )
定义：取几个集合的差集
参数：
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：array/bool 差集数组,如果其中有一个集合不存在则返回false
$redis->delete('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s0', '3');
$redis->sAdd('s0', '4');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
var_dump($redis->sMembers('dst'));
//int(2)
//array(2) {
// [0]=>
// string(1) "4"
// [1]=>
// string(1) "2"
//}
sDiffStore
语法：sDiffStore( $dstKey, $key1, $key2, $keyN = null )
定义：取几个集合的差集并存放到另外一个集合中
参数：
- $dstKey string 目标集合的键值
- $key1 string 集合键值
- $key2 string 集合键值
- $keyN string 集合键值
返回值：int/bool 新集合的元素个数，如果其中有一个集合不存在则返回false
$redis->delete('s0', 's1', 's2');
$redis->sAdd('s0', '1');
$redis->sAdd('s0', '2');
$redis->sAdd('s0', '3');
$redis->sAdd('s0', '4');
$redis->sAdd('s1', '1');
$redis->sAdd('s2', '3');
var_dump($redis->sDiffStore('dst', 's0', 's1', 's2'));
var_dump($redis->sMembers('dst'));
//int(2)
//array(2) {
// [0]=>
// string(1) "4"
// [1]=>
// string(1) "2"
//}
sMembers
语法：sMembers( $key )
定义：返回集合里的所有元素
参数：
- $key string 集合键值
返回值：array 集合元素数组
$redis->delete('s');
$redis->sAdd('s', 'a');
$redis->sAdd('s', 'b');
$redis->sAdd('s', 'a');
$redis->sAdd('s', 'c');
var_dump($redis->sMembers('s'));
//array(3) {
// [0]=>
// string(1) "c"
// [1]=>
// string(1) "a"
// [2]=>
// string(1) "b"
//}
// The order is random and corresponds to redis' own internal representation of the set structure.
sGetMembers
语法：sGetMembers( $key ) 见sMembers
getSet
语法：getSet( $key, $value )
定义：覆盖$key的值，并返回$key原来的值
参数：
- $key string 键值
- $value string VALUE
返回值：string 原来key的值
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol'); // return '42', replaces x by 'lol'
$newValue = $redis->get('x')' // return 'lol'
randomKey
语法：randomKey()
定义：随机返回字符串键名
返回值：string 键名
$key = $redis->randomKey();
$surprise = $redis->get($key); // who knows what's in there.
select
语法：select( $dbindex )
定义：指定使用某一个数据库
参数：
- $dbindex int 数据库编号
返回值：bool 成功返回TRUE，失败返回false
$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
</pre>
move
语法：move( $key, $dbindex )
定义：将某一个key和其内容移动到指定的数据库中
参数：
- $key string 键值
- $dbindex int 数据库编号
返回值：bool 成功返回TRUE，失败返回false
$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
语法：rename( $srcKey, $dstKey )
定义：重命名键值
参数：
- $key string 原键名
- $dstKey string 新键名
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y'); // → 42
$redis->get('x'); // → `FALSE`
renameKey
语法：renameKey( $srcKey, $dstKey ) 见rename
renameNx
语法：renameNx( $srcKey, $dstKey )
定义：重命名键值,如果新的键名已经存在则不重命名
参数：
- $key string 原键名
- $dstKey string 新键名
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y'); // → 42
$redis->get('x'); // → `FALSE`
expire
语法：expire( $key, $ttl )
定义：为某一个key设置生命周期
参数：
- $key string 键名
- $ttl int 生命周期 单位秒
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$redis->setTimeout('x', 3); // x will disappear in 3 seconds.
sleep(5); // wait 5 seconds
$redis->get('x'); // will return `FALSE`, as 'x' has expired.
pExpire
语法：pExpire( $key, $ttl )
定义：为某一个key设置生命周期
参数：
- $key string 键名
- $ttl int 生命周期 单位毫秒
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$redis->pExpire('x', 11500); // x will disappear in 11500 milliseconds.
$redis->ttl('x'); // 12
$redis->pttl('x'); // 11500
setTimeout
语法：setTimeout( $key, $ttl ) 见expire
expireAt
语法：expireAt( $key, $timestamp )
定义：为某一个key设置生命周期
参数：
- $key string 键名
- $ttl int 生命周期 未来的时间点 秒级时间戳
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$now = time(NULL); // current timestamp
$redis->expireAt('x', $now + 3); // x will disappear in 3 seconds.
sleep(5); // wait 5 seconds
$redis->get('x'); // will return `FALSE`, as 'x' has expired.
pExpireAt
语法：pExpireAt( $key, $timestamp )
定义：为某一个key设置生命周期
参数：
- $key string 键名
- $ttl int 生命周期 未来的时间点 毫秒级时间戳
返回值：bool 成功返回TRUE，失败返回false
$redis->set('x', '42');
$redis->pExpireAt('x', 1555555555005);
echo $redis->ttl('x'); // 218270121
echo $redis->pttl('x'); // 218270120575
keys
语法：keys( $pattern )
定义：返回符合某种模式的键值
参数：
- $pattern string 模式
返回值：array key组成的数组
$allKeys = $redis->keys('*'); // all keys will match this.
$keyWithUserPrefix = $redis->keys('user*');
getKeys
语法：getKeys( $pattern ) 见keys
dbSize
语法：dbSize()
定义：获取当前数据库的key的个数
返回值：int 获取当前数据库的key的个数
$count = $redis->dbSize();
echo "Redis has $count keys\n";
auth
语法：auth($password)
定义：使用密码验证连接。警告：密码以text/plain的形式在网络中传输
返回值：bool 成功返回TRUE，失败返回false
$redis->auth('foobared');
bgrewriteaof
语法：bgrewriteaof( )
定义：执行一个 AOF文件 重写操作
返回值：bool 成功返回TRUE，失败返回false
$redis->bgrewriteaof();
slaveof
语法：slaveof( $host = '127.0.0.1', $port = 6379 )
定义：将当前服务器转变为指定服务器的从属服务器(slave server)。如果当前服务器已经是某个主服务器(master server)的从属服务器，那么执行 SLAVEOF host port 将使当前服务器停止对旧主服务器的同步，丢弃旧数据集，转而开始对新主服务器进行同步。
参数：
- $host string 主机地址
- $port int 端口号
返回值：bool 成功返回TRUE，失败返回false
$redis->slaveof('10.0.1.7', 6379);
// ...
$redis->slaveof();
object
语法：object( $string = '', $key = '' )
定义：从内部察看给定 key 的 Redis 对象。
参数：
- $string string object子命令 refcount|encoding|idletime
- $key string 键名 OBJECT 命令有多个子命令：
- OBJECT refcount <key> 返回给定 key 引用所储存的值的次数。此命令主要用于除错。
- OBJECT encoding <key> 返回给定 key 锁储存的值所使用的内部表示(representation)。
- OBJECT idletime <key> 返回给定 key 自储存以来的空转时间(idle， 没有被读取也没有被写入)，以秒为单位。
返回值：对象可以以多种方式编码
- refcount的情况 返回 int
- idletime的情况 返回 int
- encoding的情况：
- 字符串可以被编码为 raw (一般字符串)或 int (用字符串表示64位数字是为了节约空间)。
- 列表可以被编码为 ziplist 或 linkedlist 。 ziplist 是为节约大小较小的列表空间而作的特殊表示。
- 集合可以被编码为 intset 或者 hashtable 。 intset 是只储存数字的小集合的特殊表示。
- 哈希表可以编码为 zipmap 或者 hashtable 。 zipmap 是小哈希表的特殊表示。
- 有序集合可以被编码为 ziplist 或者 skiplist 格式。 ziplist 用于表示小的有序集合，而 skiplist 则用于表示任何大小的有序集合。
$redis->object("encoding", "l"); // → ziplist
$redis->object("refcount", "l"); // → 1
$redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).
save
语法：save()
定义：将当前 Redis 实例的所有数据快照(snapshot)以 RDB 文件的形式保存到硬盘(同步)
返回值：bool 成功返回TRUE，失败返回false
$redis->save();
bgsave
语法：bgsave() 定义：在后台异步(Asynchronously)保存当前数据库的数据到磁盘。 返回值：bool 成功返回TRUE，失败返回false。如果save已经运行返回false
$redis->bgsave();
lastSave
语法：lastSave()
定义：返回最近一次 Redis 成功将数据保存到磁盘上的时间，以 UNIX 时间戳格式表示。
返回值：int 上一次时间点的时间戳
$redis->lastSave();
wait
语法：wait( $numSlaves, $timeout )
定义：阻塞当前客户端，直到指定的最少数量客户端的所有命令执行成功之后再执行。
参数：
- $numSlaves int 最少客户端的数量
- $timeout int 阻塞时间，毫秒时间戳，0代表永远阻塞
返回值：所有之前的写命令保证接收由WAIT返回的slaves的数量
$redis->wait(2, 1000);
type
语法：type( $key )
定义：返回 key 所储存的值的类型。
参数：
- $key string 键名
返回值：
- none (key不存在)
- string (字符串)
- list (列表)
- set (集合)
- zset (有序集)
- hash (哈希表)
$redis->type('key');
append
语法：append( $key, $value )
定义：如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
参数：
- $key string 键名
- $value string VALUE
返回值：int 追加 value 之后， key 中字符串的长度。
$redis->set('key', 'string value');
$redis->getRange('key', 0, 5); // 'string'
$redis->getRange('key', -5, -1); // 'value'
substr
语法：substr( $key, $start, $end )
定义：截取$key的值
参数：
- $key string 键名
- $start int 开始位置
- $end int 结束位置
返回值：string 被截取的字符串
$redis->set('key', 'Hello world');
$redis->substr('key', 0, 3);
setRange
语法：setRange( $key, $offset, $value )
定义：从指定位置开始更改一个字符串
参数：
- $key string 键名
- $offset int 指定位置
- $value string VALUE
返回值：int 改变后的字符串长度
$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis"); // returns 11
$redis->get('key'); // "Hello redis"
strlen
语法：strlen( $key )
定义：获取key的值的长度
参数：
- $key string 键名
返回值：int key的值的长度
$redis->set('key', 'value');
$redis->strlen('key'); // 5
bitpos
语法：bitpos( $key, $bit, $start = 0, $end = null)
定义：返回第一位设置为1或0的字符串。返回的位置，认为作为一个数组的位从左到右，其中第一个字节的最重要的位是在位置0，第二个字节的最重要的位是在位置8，等等。
参数：
- $key string 键名
- $bit int 1或者0
- $start int 开始位置
- $end int 结束位置
返回值：int 该命令根据请求返回第一位设置为1或0的位置。如果我们寻找设置位（位参数为1），字符串是空的或由零字节，返回1。如果我们寻找清楚的位（位参数是0）和字符串只包含位设置为1，函数返回的第一位不是字符串的一部分正确的.如果字符串是三个字节的值设置为0XFF这命令bitpos关键0返回24，因为高达位23所有位是1。基本上，函数考虑右边的字符串填充与零，如果你寻找明确的位，并指定没有范围或仅开始参数。但是，如果您正在寻找清晰的位和指定开始和结束的范围。如果在指定范围内没有找到清晰的位，则函数返回- 1，当用户指定一个明确的范围，并没有在该范围内的0位。
$redis->set('key', '\xff\xff');
$redis->bitpos('key', 1); // int(0)
$redis->bitpos('key', 1, 1); // int(8)
$redis->bitpos('key', 1, 3); // int(-1)
$redis->bitpos('key', 0); // int(16)
$redis->bitpos('key', 0, 1); // int(16)
$redis->bitpos('key', 0, 1, 5); // int(-1)
getBit
语法：getBit( $key, $offset )
定义：对 key 所储存的字符串值，获取指定偏移量上的位(bit)。
参数：
- $key string 键名
- $offset int 偏移量
返回值：int 字符串值指定偏移量上的位(bit)。当 offset 比字符串值的长度大，或者 key 不存在时，返回 0 。
$redis->set('key', "\x7f"); // this is 0111 1111
$redis->getBit('key', 0); // 0
$redis->getBit('key', 1); // 1
setBit
语法：setBit( $key, $offset, $value )
定义：对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。
位的设置或清除取决于 value 参数，可以是 0 也可以是 1 。
当 key 不存在时，自动生成一个新的字符串值。
字符串会进行伸展(grown)以确保它可以将 value 保存在指定的偏移量上。当字符串值进行伸展时，空白位置以 0 填充。
offset 参数必须大于或等于 0 ，小于 2^32 (bit 映射被限制在 512 MB 之内)。
参数：
- $key string 键名
- $offset int 偏移量
- $value int 0或1
返回值：int 指定偏移量原来储存的位。
$redis->set('key', "*"); // ord("*") = 42 = 0x2f = "0010 1010"
$redis->setBit('key', 5, 1); // returns 0
$redis->setBit('key', 7, 1); // returns 0
$redis->get('key'); // chr(0x2f) = "/" = b("0010 1111")
bitCount
语法：bitCount( $key, $start, $end)
定义：计算给定字符串中，被设置为 1 的比特位的数量。
参数:
- $key string 键名
- $start int 开始位置
- $end int 结束位置
返回值：int 被设置为 1 的位的数量。
$redis->set('bit', '345'); // // 11 0011 0011 0100 0011 0101
var_dump( $redis->bitCount('bit', 0, 0) ); // int(4)
var_dump( $redis->bitCount('bit', 1, 1) ); // int(3)
var_dump( $redis->bitCount('bit', 2, 2) ); // int(4)
var_dump( $redis->bitCount('bit', 0, 2) ); // int(11)
bitOp
语法：bitOp( $operation, $retKey, ...$keys)
定义：对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。
参数:
- $operation string 位元操作 "AND", "OR", "NOT", "XOR"
- BITOP AND destkey key [key ...] ，对一个或多个 key 求逻辑并，并将结果保存到 destkey 。
- BITOP OR destkey key [key ...] ，对一个或多个 key 求逻辑或，并将结果保存到 destkey 。
- BITOP XOR destkey key [key ...] ，对一个或多个 key 求逻辑异或，并将结果保存到 destkey 。
- BITOP NOT destkey key ，对给定 key 求逻辑非，并将结果保存到 destkey 。
- $retKey string 返回的键名
- $keys string 被操作的key
返回值：保存到 destkey 的字符串的长度，和输入 key 中最长的字符串长度相等。
注：BITOP 的复杂度为 O(N) ，当处理大型矩阵(matrix)或者进行大数据量的统计时，最好将任务指派到附属节点(slave)进行，避免阻塞主节点。
$redis->set('bit1', '1'); // 11 0001
$redis->set('bit2', '2'); // 11 0010
$redis->bitOp('AND', 'bit', 'bit1', 'bit2'); // bit = 110000
$redis->bitOp('OR', 'bit', 'bit1', 'bit2'); // bit = 110011
$redis->bitOp('NOT', 'bit', 'bit1', 'bit2'); // bit = 110011
$redis->bitOp('XOR', 'bit', 'bit1', 'bit2'); // bit = 11
flushDB
语法：flushDB( )
定义：清空当前数据库中的所有 key。(此命令从不失败。)
返回值：string 总是返回 OK 。
$redis->flushDB();
flushAll
语法：flushAll( )
定义：清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。(此命令从不失败。)
返回值：string 总是返回 OK 。
$redis->flushAll();
sort
语法：sort( $key, $option = null )
定义：返回或保存给定列表、集合、有序集合 key 中经过排序的元素。
参数:
- $keys string 被操作的key
- $options array 排序方式
- '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'
返回值：array 排序后的集合
$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
详见：http://doc.redisfans.com/key/sort.html
info
语法：info( $option = null )
定义：以一种易于解释（parse）且易于阅读的格式，返回关于 Redis 服务器的各种信息和统计数值。
参数:
- $option string 选项 SERVER | CLIENTS | MEMORY | PERSISTENCE | STATS | REPLICATION | CPU | CLASTER | KEYSPACE | COMANDSTATS
返回值：array 返回字符串和整数的关联数组，包含以下key
- redis_version
- redis_git_sha1
- redis_git_dirty
- arch_bits
- multiplexing_api
- process_id
- uptime_in_seconds
- uptime_in_days
- lru_clock
- used_cpu_sys
- used_cpu_user
- used_cpu_sys_children
- used_cpu_user_children
- connected_clients
- connected_slaves
- client_longest_output_list
- client_biggest_input_buf
- blocked_clients
- used_memory
- used_memory_human
- used_memory_peak
- used_memory_peak_human
- mem_fragmentation_ratio
- mem_allocator
- loading
- aof_enabled
- changes_since_last_save
- bgsave_in_progress
- last_save_time
- total_connections_received
- total_commands_processed
- expired_keys
- evicted_keys
- keyspace_hits
- keyspace_misses
- hash_max_zipmap_entries
- hash_max_zipmap_value
- pubsub_channels
- pubsub_patterns
- latest_fork_usec
- vm_enabled
- role
$redis->info();
//or
$redis->info("COMMANDSTATS"); //Information on the commands that have been run (>=2.6 only)
$redis->info("CPU"); // just CPU information from Redis INFO
详见：http://doc.redisfans.com/server/info.html
resetStat
语法：resetStat( )
定义：重置 INFO 命令中的某些统计数据，包括：
- Keyspace hits (键空间命中次数)
- Keyspace misses (键空间不命中次数)
- Number of commands processed (执行命令的次数)
- Number of connections received (连接服务器的次数)
- Number of expired keys (过期key的数量)
返回值：bool 成功返回TRUE，失败返回FALSE
$redis->resetStat();
ttl
语法：ttl( $key )
定义：以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
参数:
- $key string 键名
返回值：int/bool 剩余的生存时间，如果key不存在返回FALSE
$redis->ttl('key');
pttl
语法：pttl( $key )
定义：以毫秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
参数:
- $key string 键名
返回值：int/bool 剩余的生存时间，如果key不存在返回FALSE
$redis->pttl('key');
persist
语法：persist( $key )
定义：移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
参数:
- $key string 键名
返回值：bool 成功返回TRUE，失败返回FALSE
$redis->persist('key');
##mset 语法：mset( array $array )
定义：同时设置一个或多个 key-value 对。
参数: +$array array key-value 组成的数组
返回值：bool 如果所有的key都设置成功返回TRUE否则返回FALSE。
$redis->mset(array('key0' => 'value0', 'key1' => 'value1'));
var_dump($redis->get('key0'));
var_dump($redis->get('key1'));
// Output:
// string(6) "value0"
// string(6) "value1"
mget
语法：mget( array $array )
定义：获取所有key的值
参数: +$array array key 组成的数组
返回值：array 每个key对应的value组成的数组。如果key对应的value不是字符串或者key不存在则返回false
$redis->delete('x', 'y', 'z', 'h'); // remove x y z
$redis->mset(array('x' => 'a', 'y' => 'b', 'z' => 'c'));
$redis->hset('h', 'field', 'value');
var_dump($redis->mget(array('x', 'y', 'z', 'h')));
// Output:
// array(3) {
// [0]=>
// string(1) "a"
// [1]=>
// string(1) "b"
// [2]=>
// string(1) "c"
// [3]=>
// bool(false)
// }
msetnx
语法：msetnx( array $array ) 见mset
rpoplpush
语法：rpoplpush( $srcKey, $dstKey )
定义：在一个原子时间内，执行以下两个动作：
- 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
- 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
参数:
- $srcKey string 源列表的key
- $dstKey string 目标列表的key
返回值：string 返回被移动的元素
$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));
//Output:
//
//string(3) "abc"
//array(1) {
// [0]=>
// string(3) "def"
//}
//array(3) {
// [0]=>
// string(3) "abc"
// [1]=>
// string(3) "456"
// [2]=>
// string(3) "123"
//}
brpoplpush
语法：brpoplpush( $srcKey, $dstKey, $timeout )
定义：BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。
参数:
- $srcKey string 源列表的key
- $dstKey string 目标列表的key
- $timeout int 超时时间 秒为单位
返回值：string/bool 返回被移动的元素,如果超时返回FALSE
$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->brpoplpush('x', 'y',3));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1));
//Output:
//
//string(3) "abc"
//array(1) {
// [0]=>
// string(3) "def"
//}
//array(3) {
// [0]=>
// string(3) "abc"
// [1]=>
// string(3) "456"
// [2]=>
// string(3) "123"
//}
zAdd
语法：zAdd( $key, $score1, $value1, $score2 = null, $value2 = null, $scoreN = null, $valueN = null )
定义：将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。(二维数组)
参数:
- $key string 有序集键名
- $score1 string 有序集节点key
- $value1 string 有序集节点value
返回值：int 添加了多少个元素
$redis->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
$redis->zRem('z', 'v2', 'v3'); // int(2)
var_dump( $redis->zRange('z', 0, -1) );
Output:
// array(2) {
// [0]=> string(2) "v1"
// [1]=> string(2) "v4"
// }
zRange
语法：zRange( $key, $start, $end, $withscores = null )
定义：返回有序集 key 中，指定区间内的成员。
参数:
- $key string 有序集键名
- $start int 开始位置
- $end int 结束位置
- $withscores bool 是否带有key
返回值：array 包含指定范围内的值的数组
$redis->zAdd('key1', 0, 'val0');
$redis->zAdd('key1', 2, 'val2');
$redis->zAdd('key1', 10, 'val10');
$redis->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')
// with scores
$redis->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)
zRem
语法：zRem( $key, $member1, $member2 = null, $memberN = null )
定义：移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
参数:
- $key string 有序集键名
- $member1 string 节点key
返回值：int 被成功移除的成员的数量，不包括被忽略的成员。
$redis->zAdd('z', 1, 'v2', 2, 'v2', 3, 'v3', 4, 'v4' ); // int(2)
$redis->zRem('z', 'v2', 'v3'); // int(2)
var_dump( $redis->zRange('z', 0, -1) );
Output:
// array(2) {
// [0]=> string(2) "v1"
// [1]=> string(2) "v4"
// }
zDelete
语法：zDelete( $key, $member1, $member2 = null, $memberN = null ) 见#zRem
zRevRange
语法：zRevRange( $key, $start, $end, $withscore = null )
定义：返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递减(从大到小)来排列。具有相同 score 值的成员按字典序的逆序reverse lexicographical order排列。
参数:
- $key string 有序集键名
- $start int 开始位置
- $end int 结束位置
- $withscores bool 是否带有key
返回值：array 指定区间内，带有 score 值(可选)的有序集成员的列表
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRevRange('key', 0, -1); // array('val10', 'val2', 'val0')
// with scores
$redis->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)
zRangeByScore
语法：zRangeByScore( $key, $start, $end, array $options = array() )
定义：返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
参数:
- $key string 有序集键名
- $start int 开始位置
- $end int 结束位置
- $options array
- withscores bool 有序序列中是否显示key
- limit array 分页显示
返回值：array 指定区间内，带有 score 值(可选)的有序集成员的列表。
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRangeByScore('key', 0, 3); // array('val0', 'val2')
$redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE); // array('val0' => 0, 'val2' => 2)
$redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1)); // array('val2' => 2)
$redis->zRangeByScore('key', 0, 3, array('limit' => array(1, 1)); // array('val2')
$redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1)); // array('val2' => 2)
zRevRangeByScore
语法：zRevRangeByScore( $key, $start, $end, array $options = array() ) 见#zRangeByScore
zRangeByLex
语法：zRangeByLex( $key, $min, $max, $offset = null, $limit = null )
定义：返回存储在键的排序集合在指定的范围元素。该元素被认为是从最低到最高的分值进行排序。字典顺序用于以相等的分数的元素。两个开始和结束是从零开始的索引，其中0是第一个元素，1是下一个元素等等。它们也可以是表示偏移量从有序集的结尾，以-1作为排序的集合的最后一个元素，-2倒数第二元素等负数。
参数:
- $key string 有序集键名
- $min int 最小值
- $max int 最大值
- $offset int 偏移量
- $limit int 最多返回几个元素
返回值：array 指定区间内，带有 score 值(可选)的有序集成员的列表。 详见：http://classfoo.com/ccby/article/wZjN7X
foreach (array('a', 'b', 'c', 'd', 'e', 'f', 'g') as $char) {
$redis->zAdd('key', $char);
}
$redis->zRangeByLex('key', '-', '[c'); // array('a', 'b', 'c')
$redis->zRangeByLex('key', '-', '(c'); // array('a', 'b')
$redis->zRangeByLex('key', '-', '[c'); // array('b', 'c')
</pre>
zRevRangeByLex
语法：zRevRangeByLex( $key, $min, $max, $offset = null, $limit = null ) 见#zRangeByLex
zCount
语法：zCount( $key, $min, $max )
定义：返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
参数:
- $key string 有序集键名
- $min int 最小值
- $max int 最大值
返回值：int 介于 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zCount('key', 0, 3); // 2, corresponding to array('val0', 'val2')
zRemRangeByScore
语法：zRemRangeByScore( $key, $start, $end )
定义：移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
参数:
- $key string 有序集键名
- $min int 最小值
- $max int 最大值
返回值：int 被移除成员的数量。
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRemRangeByScore('key', 0, 3); // 2
zDeleteRangeByScore
语法：zDeleteRangeByScore( $key, $start, $end ) 见zRemRangeByScore
zRemRangeByRank
语法：zRemRangeByRank( $key, $start, $end )
定义：int 移除有序集 key 中，指定排名(rank)区间内的所有成员。
参数:
- $key string 有序集键名
- $start int 开始位置
- $end int 结束位置
返回值：int 被移除成员的数量。
$redis->zAdd('key', 1, 'one');
$redis->zAdd('key', 2, 'two');
$redis->zAdd('key', 3, 'three');
$redis->zRemRangeByRank('key', 0, 1); // 2
$redis->zRange('key', 0, -1, array('withscores' => TRUE)); // array('three' => 3)
zDeleteRangeByRank
语法：zDeleteRangeByRank( $key, $start, $end ) 见zRemRangeByRank
zCard
语法：zCard( $key )
定义：返回有序集 key 的基数。
参数:
- $key string 有序集键名
返回值：int 当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0 。
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zCard('key'); // 3
zSize
语法：zSize( $key ) 见zCard
zScore
语法：zScore( $key, $member )
定义：返回有序集 key 中，成员 member 的 score 值。
参数:
- $key string 有序集键名
- $member string 节点key
返回值：member 成员的 score 值，以字符串形式表示。
$redis->zAdd('key', 2.5, 'val2');
$redis->zScore('key', 'val2'); // 2.5
zRank
语法：zRank( $key, $member )
定义：返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
参数:
- $key string 有序集键名
- $member string 节点key
返回值：int 如果 member 是有序集 key 的成员，返回 member 的排名。如果 member 不是有序集 key 的成员，返回 nil 。
$redis->delete('z');
$redis->zAdd('key', 1, 'one');
$redis->zAdd('key', 2, 'two');
$redis->zRank('key', 'one'); // 0
$redis->zRank('key', 'two'); // 1
$redis->zRevRank('key', 'one'); // 1
$redis->zRevRank('key', 'two'); // 0
zRevRank
语法：zRevRank( $key, $member ) 见zRank
zIncrBy
语法：zIncrBy( $key, $value, $member )
定义：为有序集 key 的成员 member 的 score 值加上增量 increment 。
参数:
- $key string 有序集键名
- $value float 增量
- $member string 节点key
返回值：float 增量后的值
$redis->delete('key');
$redis->zIncrBy('key', 2.5, 'member1'); // key or member1 didn't exist, so member1's score is to 0
// before the increment and now has the value 2.5
$redis->zIncrBy('key', 1, 'member1'); // 3.5
zUnion
语法：zUnion($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM')
定义：计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
参数:
- $Output string 转存的结果集
- $ZSetKeys array 有序集组成的key
- $Weights 使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
- $aggregateFunction string "SUM", "MIN", or "MAX" 使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。 默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
返回值：int 返回新的有序集合中元素的个数
$redis->delete('k1');
$redis->delete('k2');
$redis->delete('k3');
$redis->delete('ko1');
$redis->delete('ko2');
$redis->delete('ko3');
$redis->zAdd('k1', 0, 'val0');
$redis->zAdd('k1', 1, 'val1');
$redis->zAdd('k2', 2, 'val2');
$redis->zAdd('k2', 3, 'val3');
$redis->zUnion('ko1', array('k1', 'k2')); // 4, 'ko1' => array('val0', 'val1', 'val2', 'val3')
// Weighted zUnion
$redis->zUnion('ko2', array('k1', 'k2'), array(1, 1)); // 4, 'ko2' => array('val0', 'val1', 'val2', 'val3')
$redis->zUnion('ko3', array('k1', 'k2'), array(5, 1)); // 4, 'ko3' => array('val0', 'val2', 'val3', 'val1')
zInter
语法：zInter($Output, $ZSetKeys, array $Weights = null, $aggregateFunction = 'SUM')
定义：计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.关于 WEIGHTS 和 AGGREGATE 选项的描述，参见 zUnion 命令。
参数:
- $Output string 转存的结果集
- $ZSetKeys array 有序集组成的key
- $Weights 使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。
- $aggregateFunction string "SUM", "MIN", or "MAX" 使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。 默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。
返回值：int 返回新的有序集合中元素的个数
$redis->delete('k1');
$redis->delete('k2');
$redis->delete('k3');
$redis->delete('ko1');
$redis->delete('ko2');
$redis->delete('ko3');
$redis->delete('ko4');
$redis->zAdd('k1', 0, 'val0');
$redis->zAdd('k1', 1, 'val1');
$redis->zAdd('k1', 3, 'val3');
$redis->zAdd('k2', 2, 'val1');
$redis->zAdd('k2', 3, 'val3');
$redis->zInter('ko1', array('k1', 'k2')); // 2, 'ko1' => array('val1', 'val3')
$redis->zInter('ko2', array('k1', 'k2'), array(1, 1)); // 2, 'ko2' => array('val1', 'val3')
// Weighted zInter
$redis->zInter('ko3', array('k1', 'k2'), array(1, 5), 'min'); // 2, 'ko3' => array('val1', 'val3')
$redis->zInter('ko4', array('k1', 'k2'), array(1, 5), 'max'); // 2, 'ko4' => array('val3', 'val1')
hSet
语法：hSet( $key, $hashKey, $value )
定义：将哈希表 key 中的域 hashKey 的值设为 value 。如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。如果域 field 已经存在于哈希表中，旧值将被覆盖。
参数:
- $key string 哈希表的key
- $hashKey string hashKey
- $value string VALUE
返回值：如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1；如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
$redis->delete('h')
$redis->hSet('h', 'key1', 'hello'); // 1, 'key1' => 'hello' in the hash at "h"
$redis->hGet('h', 'key1'); // returns "hello"
$redis->hSet('h', 'key1', 'plop'); // 0, value was replaced.
$redis->hGet('h', 'key1'); // returns "plop"
hSetNx
语法：hSetNx( $key, $hashKey, $value )
定义：将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。若域 field 已经存在，该操作无效。如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。
参数:
- $key string 哈希表的key
- $hashKey string hashKey
- $value string VALUE
返回值：设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。
$redis->delete('h')
$redis->hSetNx('h', 'key1', 'hello'); // TRUE, 'key1' => 'hello' in the hash at "h"
$redis->hSetNx('h', 'key1', 'world'); // FALSE, 'key1' => 'hello' in the hash at "h". No change since the field wasn't replaced.
hGet
语法：hGet($key, $hashKey)
定义：返回哈希表 key 中给定域 $hashKey 的值。
参数:
- $key string 哈希表的key
- $hashKey string hashKey
返回值：给定域的值。当给定域不存在或是给定 key 不存在时，返回 nil 。
$redis->hSet('h', 'key1', 'hello');
$redis->hGet('h', 'key1');
hLen
语法：hLen( $key )
定义：返回哈希表 key 中域的数量。
参数:
- $key string 哈希表的key
返回值：哈希表中域的数量。当 key 不存在时，返回 0 。
$redis->delete('h')
$redis->hSet('h', 'key1', 'hello');
$redis->hSet('h', 'key2', 'plop');
$redis->hLen('h'); // returns 2
hDel
语法：hDel( $key, $hashKey1, $hashKey2 = null, $hashKeyN = null )
定义：删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
参数:
- $key string 哈希表的key
- $hashKey1 string 哈希表的指定域
返回值：被成功移除的域的数量，不包括被忽略的域。
$redis->hMSet('h',
array(
'f1' => 'v1',
'f2' => 'v2',
'f3' => 'v3',
'f4' => 'v4',
));
var_dump( $redis->hDel('h', 'f1') ); // int(1)
var_dump( $redis->hDel('h', 'f2', 'f3') ); // int(2)
var_dump( $redis->hGetAll('h') );
Output:
// array(1) {
// ["f4"]=> string(2) "v4"
// }
hKeys
语法：hKeys( $key )
定义：返回哈希表 key 中的所有域。
参数:
- $key string 哈希表的key
返回值：一个包含哈希表中所有域的表。当 key 不存在时，返回一个空表。
$redis->delete('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hKeys('h'));
// Output:
// array(4) {
// [0]=>
// string(1) "a"
// [1]=>
// string(1) "b"
// [2]=>
// string(1) "c"
// [3]=>
// string(1) "d"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
hVals
语法：hVals( $key )
定义：返回哈希表 key 中所有域的值。
参数:
- $key string 哈希表的key
返回值：一个包含哈希表中所有值的表。当 key 不存在时，返回一个空表。
$redis->delete('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hVals('h'));
// Output
// array(4) {
// [0]=>
// string(1) "x"
// [1]=>
// string(1) "y"
// [2]=>
// string(1) "z"
// [3]=>
// string(1) "t"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
hGetAll
语法：hGetAll( $key )
定义：返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
参数:
- $key string 哈希表的key
返回值：以列表形式返回哈希表的域和域的值。若 key 不存在，返回空列表。
$redis->delete('h');
$redis->hSet('h', 'a', 'x');
$redis->hSet('h', 'b', 'y');
$redis->hSet('h', 'c', 'z');
$redis->hSet('h', 'd', 't');
var_dump($redis->hGetAll('h'));
// Output:
// array(4) {
// ["a"]=>
// string(1) "x"
// ["b"]=>
// string(1) "y"
// ["c"]=>
// string(1) "z"
// ["d"]=>
// string(1) "t"
// }
// The order is random and corresponds to redis' own internal representation of the set structure.
hExists
语法：hExists( $key, $hashKey )
定义：查看哈希表 key 中，给定域 $hashKey 是否存在。
参数:
- $key string 哈希表的key
- $hashKey1 string 哈希表的指定域
返回值：如果哈希表含有给定域，返回 TRUE 。如果哈希表不含有给定域，或 key 不存在，返回 FALSE 。
$redis->hSet('h', 'a', 'x');
$redis->hExists('h', 'a'); // TRUE
$redis->hExists('h', 'NonExistingKey'); // FALSE
hIncrBy
语法：hIncrBy( $key, $hashKey, $value )
定义：为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。本操作的值被限制在 64 位(bit)有符号数字表示之内。
参数:
- $key string 哈希表的key
- $hashKey string hashKey
- $value string VALUE
返回值：执行 HINCRBY 命令之后，哈希表 key 中域 $hashKey 的值。
$redis->delete('h');
$redis->hIncrBy('h', 'x', 2); // returns 2: h[x] = 2 now.
$redis->hIncrBy('h', 'x', 1); // h[x] ← 2 + 1. Returns 3
hIncrByFloat
语法：hIncrByFloat( $key, $field, $increment )
定义：为哈希表 key 中的域 field 加上浮点数增量 increment 。如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。当以下任意一个条件发生时，返回一个错误：
- 域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
- 域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number)
参数:
- $key string 哈希表的key
- $hashKey string hashKey
- $value string VALUE
返回值：执行加法操作之后 field 域的值。
$redis = new Redis();
$redis->connect('127.0.0.1');
$redis->hset('h', 'float', 3);
$redis->hset('h', 'int', 3);
var_dump( $redis->hIncrByFloat('h', 'float', 1.5) ); // float(4.5)
var_dump( $redis->hGetAll('h') );
// Output
array(2) {
["float"]=>
string(3) "4.5"
["int"]=>
string(1) "3"
}
hMset
语法：hMset( $key, $hashKeys )
定义：同时将多个 field-value (域-值)对设置到哈希表 key 中。此命令会覆盖哈希表中已存在的域。如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
参数:
- $key string 哈希表的key
- $hashKeys array 由key-value组成的数组
返回值：如果命令执行成功，返回 OK 。当 key 不是哈希表(hash)类型时，返回一个错误。
$redis->delete('h');
$redis->hSet('h', 'field1', 'value1');
$redis->hSet('h', 'field2', 'value2');
$redis->hmGet('h', array('field1', 'field2')); // returns array('field1' => 'value1', 'field2' => 'value2')
config
语法：config( $operation, $key, $value )
定义：获取或设置redis配置参数
参数:
- $operation string GET|SET
- $key string redis配置项
- $value 配置项的值（只在GET时使用）
返回值：由配置项和配置值组成的数组
$redis->config("GET", "*max-*-entries*");
$redis->config("SET", "dir", "/var/run/redis/dumps/");
evaluate
语法：evaluate( $script, $args = array(), $numKeys = 0 ) 见eval
evalSha
语法：evalSha( $scriptSha, $args = array(), $numKeys = 0 )
定义：根据给定的 sha1 校验码，对缓存在服务器中的脚本进行求值。将脚本缓存到服务器的操作可以通过 SCRIPT LOAD 命令进行。这个命令的其他地方，比如参数的传入方式，都和 EVAL 命令一样。
参数: 见eval
返回值：见eval
$script = 'return 1';
$sha = $redis->script('load', $script);
$redis->evalSha($sha); // Returns 1
evaluateSha
语法：evaluateSha( $scriptSha, $args = array(), $numKeys = 0 ) 见evalSha
script
语法：script( $command, $script )
定义：使用脚本命令执行的脚本系统进行各种操作。
参数:
- $command string 脚本命令 load | flush | kill | exists
- $script string 脚本内容
返回值：mixed
$redis->script('load', $script);
$redis->script('flush');
$redis->script('kill');
$redis->script('exists', $script1, [$script2, $script3, ...]);
getLastError
语法：getLastError()
定义：获取上一次执行的错误
返回值：string 上次错误的内容，如果没有错误返回NULL
$redis->eval('this-is-not-lua');
$err = $redis->getLastError();
clearLastError
语法：clearLastError()
定义：清空上一次错误
返回值：bool 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();
// NULL
_prefix
语法：_prefix( $value )
定义：设置前缀
参数:
- $value string VALUE
返回值：返回加上前缀后的值
$redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
$redis->_prefix('my-value'); // Will return 'my-prefix:my-value'
_unserialize
语法：_unserialize( $value )
定义：反序列化
参数:
- $value string 序列化字符串
返回值：mixed
$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 Array(1,2,3)
_serialize
语法：_serialize( $value )
定义：序列化
参数:
- $value string 被序列化对象
返回值：mixed
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
$redis->_serialize("foo"); // returns "foo"
$redis->_serialize(Array()); // Returns "Array"
$redis->_serialize(new stdClass()); // Returns "Object"
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
$redis->_serialize("foo"); // Returns 's:3:"foo";'
dump
语法：dump( $key )
定义：序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为 Redis 键。
参数:
- $key string 被序列化的键名
返回值：如果 key 不存在，那么返回 nil 。否则，返回序列化之后的值。
$redis->set('foo', 'bar');
$val = $redis->dump('foo'); // $val will be the Redis encoded key value
restore
语法：restore( $key, $ttl, $value )
定义：反序列化给定的序列化值，并将它和给定的 key 关联。参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。
参数:
- $key string 被序列化的键名
- $ttl int 毫秒时间戳
- $value string 由dump序列化得到的二进制值
返回值：如果 key 不存在，那么返回 nil 。否则，返回序列化之后的值。
$redis->set('foo', 'bar');
$val = $redis->dump('foo'); // $val will be the Redis encoded key value
migrate
语法：migrate( $host, $port, $key, $db, $timeout, $copy = false, $replace = false )
定义：见http://doc.redisfans.com/key/migrate.html
参数:
- $host string 主机名
- $port int 端口号
- $key string 键名
- $db int 使用哪个数据库
- $timeout 参数以毫秒为格式，指定当前实例和目标实例进行沟通的最大间隔时间。
- $copy bool 是否发送COPY标识到目标服务器
- $replace bool 是否发送REPLACE标识到目标服务器
返回值：bool 成功返回true/失败返回false
redis->migrate('backup', 6379, 'foo', 0, 3600);
time
语法：time()
定义：返回当前服务器时间。
返回值：array 第一个值是当前时间(以 UNIX 时间戳格式表示)，第二个值是当前这一秒钟已经逝去的微秒数。
var_dump( $redis->time() );
// array(2) {
// [0] => string(10) "1342364352"
// [1] => string(6) "253002"
// }
pfAdd
语法：pfAdd( $key, array $elements )
定义：命令将所有元素的参数保存在指定为第一个参数的键名的HyperLogLog数据结构。
参数:
- $key string 键名
- $elements array 字符串数组
返回值：bool 成功返回true/失败返回false
$redis->pfAdd('key', array('elem1', 'elem2'))
pfCount
语法：pfCount( $key )
定义：获得近似的基数由存储在指定变量的HyperLogLog数据结构进行计算。
参数:
- $key string 键名
返回值：返回整型，近似独特的元素数量。如果键不存在，则返回0。
$redis->pfAdd('key1', array('elem1', 'elem2'));
$redis->pfAdd('key2', array('elem3', 'elem2'));
$redis->pfCount('key1'); // int(2)
$redis->pfCount(array('key1', 'key2')); // int(3)
pfMerge
语法：pfMerge( $destkey, array $sourcekeys )
定义：将多个 HyperLogLog 合并为一个 HyperLogLog 并存入到$destkey中，合并后的 HyperLogLog 的基数估算值是通过对所有 给定 HyperLogLog 进行并集计算得出的。
参数:
- $destkey string 合并后存储的key
- $sourcekeys array 由被合并的key组成的数组
返回值：bool 成功返回true/失败返回false.
$redis->pfAdd('key1', array('elem1', 'elem2'));
$redis->pfAdd('key2', array('elem3', 'elem2'));
$redis->pfMerge('key3', array('key1', 'key2'));
$redis->pfCount('key3'); // int(3)
rawCommand
语法：rawCommand( $command, $arguments )
定义：发送任意东西的redis服务器。
参数:
- $command string 要发送的命令
- $arguments mixed 可选的变量数量的参数发送到服务器
返回值：mixed
$redis->rawCommand('SET', 'key', 'value'); // bool(true)
$redis->rawCommand('GET", 'key'); // string(5) "value"
getMode
语法：getMode()
定义：检测是否存在ATOMIC/MULTI/PIPELINE模式
返回值：int Redis::ATOMIC, Redis::MULTI or Redis::PIPELINE
$redis->getMode();
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
