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();