文档章节

Rides 3.0.0 中文文档

思不如学
 思不如学
发布于 2017/03/24 21:31
字数 15461
阅读 76
收藏 1

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

© 著作权归作者所有

思不如学
粉丝 0
博文 10
码字总数 16862
作品 0
朝阳
私信 提问
linux下实现百度文库的安装方法

启动openoffice soffice -headless -accept="socket,host=127.0.0.1,port=8100;urp;" -nofirststartwizard & 命令:java -jar /usr/local/jodconverter-core-3.0-beta-4/lib/jodconverter-......

jackjie2010
2012/04/25
0
0
WPS For iOS的2014上半年

说起2014上半年,恍如昨日,原来唰的一下,半年都过去了,面对这半年,WPS For iOS究竟为用户做了什么改变,以及我们的下半年会有什么计划?下面让我来总结一下过去,展望一下未来吧…… WP...

WPS果粉之家
2014/07/02
165
0
Linux Deepin 11.12.1 发布

这次版本主要更新了 Deepin GNOME Shell,深度软件中心 2.1.2,深度截图工具 2.0,桌面指南 1.2。同时,修复了用户反馈和系统测试中出现的问题。 一、主要更新 Deepin GNOME Shell -增加了 ...

火耳
2012/03/01
1K
6
【开源早报】新型 Linux 病毒 | Google 与 Mozilla 开发文件 API | RedisPlus 3.0.0 重构升级

2018.11.25 开源早报 【综合资讯】 1.新型 Linux 病毒,脚本超 1000 行,功能复杂 2.2018 年 77% 的组织遭受 DNS 攻击,你中招了没 3.Google 与 Mozilla 开发 API 让 Web 应用轻松编辑本地文...

h4cd
2018/11/25
170
0
Python用不好?看官方中文文档啦

Python 作为世界上最好用的语言,官方支持的文档一直没有中文。小伙伴们已经习惯了原汁原味的英文文档,但如果有官方中文文档,那么查阅或理解速度都会大大提升。本文将介绍隐藏在 Python 官...

机器之心
03/27
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Java FOR-EACH循环

FOR-EACH循环使得代码更加的简短,也让代码更加易懂,其实他并没有加入什么新的功能。他的功能完全可以用简单的FOR循环代替。 for-each的用法: int a[] = {1,2,3,4,5,6} for(int s:a){ Syst...

无名氏的程序员
25分钟前
3
0
使用HTML5的History API

本文转载于:专业的前端网站➣使用HTML5的History API   HTML5 History API提供了一种功能,能让开发人员在不刷新整个页面的情况下修改站点的URL。这个功能很有用,例如通过一段JavaScript代...

前端老手
28分钟前
4
0
JAVA 编写redisUtils工具类,防止高并发获取缓存出现并发问题

import lombok.extern.slf4j.Slf4j;import org.springframework.data.redis.core.BoundHashOperations;import org.springframework.data.redis.core.BoundValueOperations;import org.......

huangkejie
今天
7
0
JMM内存模型(一)&volatile关键字的可见性

在说这个之前,我想先说一下计算机的内存模型: CPU在执行的时候,肯定要有数据,而数据在内存中放着呢,这里的内存就是计算机的物理内存,刚开始还好,但是随着技术的发展,CPU处理的速度越...

走向人生巅峰的大路
今天
100
0
你对AJAX认知有多少(2)?

接着昨日内容,我们几天继续探讨ajax的相关知识点 提到ajax下面几个问题又是必须要了解的啦~~~ 8、在浏览器端如何得到服务器端响应的XML数据。 通过XMLHttpRequest对象的responseXMl属性 9、 ...

理性思考
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部