php redis 操作大全

类和方法

用法

  1. Redis类
  2. 类RedisException
  3. 预定义的常量

Redis类

说明：创建一个Redis客户端

例
$redis = new Redis();

类RedisException

 如果无法到达Redis服务器，则phpredis会抛出一个  RedisException对象。如果出现连接问题，Redis服务关闭或Redis主机过载，则可能会发生这种情况。在任何其他有问题的情况下，不涉及无法访问的服务器（例如不存在的密钥，无效的命令等），phpredis将返回  FALSE。

预定义的常量

说明：可用的Redis常量

Redis数据类型，按类型返回 

Redis::REDIS_STRING - String
Redis::REDIS_SET - Set
Redis::REDIS_LIST - List
Redis::REDIS_ZSET - Sorted set
Redis::REDIS_HASH - Hash
Redis::REDIS_NOT_FOUND - Not found / other

@TODO：OPT_SERIALIZER，之后，之前...

连接

  1. 连接，打开  - 连接到服务器
  2. pconnect，popen  - 连接到服务器（持久）
  3. auth  - 对服务器进行身份验证
  4. 选择  - 更改当前连接的选定数据库
  5. 关闭  - 关闭连接
  6. setOption  - 设置客户端选项
  7. getOption  - 获取客户端选项
  8. ping  - Ping服务器
  9. 回声  - 回声给定的字符串

连接，打开

说明：连接到Redis实例。

参数

主机：字符串。可以是主机，也可以是unix域套接字端口的路径  ：int，可选  timeout：float，以秒为单位的值（可选，默认值为0意味着不受限制）  reserved：如果指定retry_interval，则为NULL  retry_interval：int，以毫秒为单位的值（可选的）

返回值

BOOL：  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.
$redis->connect('127.0.0.1', 6379, 1, NULL, 100); // 1 sec timeout, 100ms delay between reconnection attempts.

连接，打开

说明：连接到Redis实例或重新使用与pconnect/ 建立的连接  popen。

close 直到php进程结束，连接才会被请求关闭  或结束。因此，当连接到一台Redis服务器的许多服务器上使用持久连接时，请耐心等待许多开放的FD（特别是在Redis服务器端）。

也可以通过host + port + timeout或host + persistent_id或unix套接字+超时识别多个持久连接。

此功能在线程版本中不可用。 pconnect 而  popen 随后的工作就像他们的非持久的等价物。

参数

主机：字符串。可以是主机，也可以是unix域套接字端口的路径  ：int，可选  timeout：float，以秒为单位的值（可选，默认为0意味着无限制）  persistent_id：string。请求的持久连接的身份  retry_interval：int，以毫秒为单位的值（可选）

返回值

BOOL：  TRUE 成功时，  FALSE 出错。

例
$redis->pconnect('127.0.0.1', 6379);
$redis->pconnect('127.0.0.1'); // port 6379 by default - same connection like before.
$redis->pconnect('127.0.0.1', 6379, 2.5); // 2.5 sec timeout and would be another connection than the two before.
$redis->pconnect('127.0.0.1', 6379, 2.5, 'x'); // x is sent as persistent_id and would be another connection than the three before.
$redis->pconnect('/tmp/redis.sock'); // unix domain socket - would be another connection than the four before.

AUTH

说明：使用密码验证连接。 警告：密码通过网络以纯文本形式发送。

参数

STRING：密码

返回值

BOOL：  TRUE 如果连接被认证，  FALSE 否则。

例
$redis->auth('foobared');

选择

说明：更改当前连接的选定数据库。

参数

INTEGER：dbindex，切换到的数据库编号。

返回值

TRUE 在成功FALSE 的情况下，  在失败的情况下。

例

请参阅方法举例：  移动

关

说明：从Redis实例断开连接，除了  pconnect 使用时。

的SetOption

说明：设置客户端选项。

参数

参数名称 参数值

返回值

BOOL：  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

/* Options for the SCAN family of commands, indicating whether to abstract
   empty results from the user.  If set to SCAN_NORETRY (the default), phpredis
   will just issue one SCAN command at a time, sometimes returning an empty
   array of results.  If set to SCAN_RETRY, phpredis will retry the scan command
   until keys come back OR Redis returns an iterator of zero
*/
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);

getOption

说明：获取客户选项。

参数

参数名称

返回值

参数值。

例
$redis->getOption(Redis::OPT_SERIALIZER);   // return Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP, or Redis::SERIALIZER_IGBINARY.

ping

说明：检查当前的连接状态

参数

（没有）

返回值

STRING：  +PONG 成功。 如上所述，抛出一个连接错误的  RedisException对象。

回声

说明：向Redis发送一个字符串，该字符串以相同的字符串回复

参数

STRING：要发送的消息。

返回值

STRING：相同的信息。

服务器

  1. bgRewriteAOF  - 异步重写仅附加文件
  2. bgSave  - 将数据集异步保存到磁盘（在后台）
  3. config  - 获取或设置Redis服务器配置参数
  4. dbSize  - 返回选定数据库中的键数
  5. flushAll  - 删除所有数据库中的所有密钥
  6. flushDb  - 从当前数据库中删除所有密钥
  7. info  - 获取有关服务器的信息和统计信息
  8. lastSave  - 获取最后一次磁盘保存的时间戳
  9. resetStat  - 重置info  方法返回的统计  信息。
  10. 保存  - 同步将数据集保存到磁盘（等待完成）
  11. slaveOf  - 使服务器成为另一个实例的从属服务器，或将其提升为主服务器
  12. 时间  - 返回当前服务器时间
  13. slowLog  - 访问Redis slowLog条目

bgRewriteAOF

说明：启动AOF的后台重写（仅附加文件）

参数

没有。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。

例
$redis->bgRewriteAOF();

bgSave

说明：将数据集异步保存到磁盘（在后台）

参数

没有。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。如果保存已经运行，该命令将失败并返回  FALSE。

例
$redis->bgSave();

配置

说明：获取或设置Redis服务器配置参数。

参数

操作  （字符串）任一  GET 或  SET 键  字符串  SET为，水珠图案  GET。有关 示例，请参阅  http://redis.io/commands/config-get。 值  可选字符串（仅用于  SET）

返回值

关联数组  为  GET，键- >值  布尔  对 SET

例子
$redis->config("GET", "*max-*-entries*");
$redis->config("SET", "dir", "/var/run/redis/dumps/");

dbSize

说明：返回所选数据库中的键数。

参数

没有。

返回值

INTEGER：数据库大小，按键数量。

例
$count = $redis->dbSize();
echo "Redis has $count keys\n";

flushAll

说明：从所有数据库中删除所有密钥。

参数

没有。

返回值

布尔：总是  TRUE。

例
$redis->flushAll();

flushDb

说明：从当前数据库中删除所有密钥。

参数

没有。

返回值

布尔：总是  TRUE。

例
$redis->flushDb();

信息

说明：获取有关服务器的信息和统计信息

返回提供有关服务器信息的关联数组。不向INFO传递参数将调用标准的REDIS INFO命令，该命令返回如下信息：

  • redis_version
  • arch_bits
  • uptime_in_seconds
  • uptime_in_days
  • connected_clients
  • connected_slaves
  • used_memory
  • changes_since_last_save
  • bgsave_in_progress
  • last_save_time
  • total_connections_received
  • total_commands_processed
  • 角色

您可以将各种选项传递给INFO（根据Redis文档），这将修改返回的内容。

参数

选项：提供redis选项（例如“COMMANDSTATS”，“CPU”）

例
$redis->info(); /* standard redis INFO command */
$redis->info("COMMANDSTATS"); /* Information on the commands that have been run (>=2.6 only)
$redis->info("CPU"); /* just CPU information from Redis INFO */

LASTSAVE

说明：返回上次磁盘保存的时间戳。

参数

没有。

返回值

INT：时间戳。

例
$redis->lastSave();

resetStat

说明：重置info  方法返回的统计  信息。

这些是重置的计数器：

  • Keyspace点击
  • Keyspace想念
  • 处理的命令数
  • 收到的连接数
  • 已过期的密钥数量
参数

没有。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。

例
$redis->resetStat();

保存

说明：将数据集同步保存到磁盘（等待完成）

参数

没有。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。如果保存已经运行，该命令将失败并返回  FALSE。

例
$redis->save();

slaveOf

说明：更改从站状态

参数

无论是主机（字符串）和端口（INT），或没有参数，以停止成为奴隶。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。

例
$redis->slaveOf('10.0.1.7', 6379);
/* ... */
$redis->slaveOf();

时间

说明：返回当前的服务器时间。

参数

（没有）

返回值

如果成功，时间将作为一个关联数组返回，其中元素零为unix时间戳，元素一为微秒。

例子
$redis->time();

slowLog

说明：访问Redis slowLog

参数

操作  （字符串）：这可以是  GET，  LEN或  RESET 长度  （整数），可选的：如果执行一个  SLOWLOG GET 指令，就可以通过一个可选的长度。

返回值

SLOWLOG的返回值取决于执行的操作。SLOWLOG GET：由Redis提供的slowLog条目数组SLOGLOG LEN：整数，slowLog SLOWLOG RESET：Boolean的长度，取决于成功

例子
// Get ten slowLog entries
$redis->slowLog('get', 10);
// Get the default number of slowLog entries

$redis->slowLog('get');
// Reset our slowLog
$redis->slowLog('reset');

// Retrieve slowLog length
$redis->slowLog('len');

键和字符串

字符串

  • append  - 向键添加一个值
  • bitCount  - 计算字符串中的设置位数
  • bitOp  - 在字符串之间执行按位操作
  • decr，decrBy  - 减少密钥的值
  • 获取  - 获取密钥的值
  • getBit  - 返回键中存储的字符串值的偏移位值
  • getRange  - 获取存储在键上的字符串的子字符串
  • getSet  - 设置一个键的字符串值并返回其旧值
  • incr，incrBy  - 增加一个键的值
  • incrByFloat  - 按给定的数量增加一个键的浮点值
  • mGet，getMultiple  - 获取所有给定键的值
  • mSet，mSetNX  - 将多个键设置为多个值
  • set  - 设置一个键的字符串值
  • setBit  - 设置或清除键中存储的字符串值的偏移量位
  • setEx，pSetEx  - 设置密钥的值和过期
  • setNx  - 仅当密钥不存在时才设置密钥的值
  • setRange  - 覆盖从指定偏移量开始的键字符串的一部分
  • strLen  - 获取存储在键中的值的长度

按键

  • 删除，删除  - 删除一个密钥
  • dump  - 返回存储在指定键上的值的序列化版本。
  • 存在  - 确定是否存在密钥
  • 过期，setTimeout，pexpire  - 设置密钥的时间以秒为单位
  • expireAt，pexpireAt  - 将密钥的到期时间设置为UNIX时间戳
  • 键，getKeys  - 查找与给定模式匹配的所有键
  • 扫描  - 扫描密钥空间中的密钥（Redis> = 2.8.0）
  • 迁移  - 将Redis实例中的密钥以原子方式转移到另一个实例
  • 移动  - 将密钥移至另一个数据库
  • 对象  - 检查Redis对象的内部
  • 坚持  - 从密钥中删除到期
  • randomKey  - 从密钥空间返回一个随机密钥
  • 重命名，  重命名键 - 重命名密钥
  • renameNx  - 仅当新密钥不存在时重命名密钥
  • 类型  - 确定存储在键上的类型
  • 排序  - 对列表中的元素进行排序，设置或排序集
  • ttl，pttl  - 让时间为一把钥匙而活
  • 恢复  - 使用提供的序列化值创建一个密钥，以前通过  转储获取。

得到

说明：获取与指定键相关的值

参数

键

返回值

字符串  或  布尔值：如果密钥不存在，  FALSE 则返回。否则，返回与该键有关的值。

例子
$redis->get('key');

组

说明：将参数中的字符串值设置为键的值。如果您使用的是Redis> = 2.6.12，则可以按照下面的说明传递扩展选项

参数

关键 值 超时或选项数组  （可选）。如果你传递一个整数，phpredis将重定向到SETEX，并且如果你传递了一个有效值的数组，它将尝试使用Redis> = 2.6.12扩展选项

返回值

布尔 TRUE  如果命令成功。

例子
// Simple key -> value set
$redis->set('key', 'value');

// Will redirect, and actually make an SETEX call
$redis->set('key','value', 10);

// Will set the key, if it doesn't exist, with a ttl of 10 seconds
$redis->set('key', 'value', Array('nx', 'ex'=>10));

// Will set a key, if it does exist, with a ttl of 1000 miliseconds
$redis->set('key', 'value', Array('xx', 'px'=>1000));

setEx，pSetEx

说明：将参数中的字符串值设置为键的值，并设置生存时间。PSETEX以毫秒为单位使用TTL。

参数

关键 TTL  值

返回值

布尔 TRUE  如果命令成功。

例子
$redis->setEx('key', 3600, 'value'); // sets key → value, with 1h TTL.
$redis->pSetEx('key', 100, 'value'); // sets key → value, with 0.1 sec TTL.

SETNX

说明：如果键不存在于数据库中，请将参数中的字符串值设置为键的值。

参数

关键 值

返回值

布尔 TRUE  如果成功，  FALSE 在失败的情况下。

例子
$redis->setNx('key', 'value'); /* return TRUE */
$redis->setNx('key', 'value'); /* return FALSE */

删除，删除

说明：删除指定的键。

参数

一组键，或者一个未定义数量的参数，每一个键：  key1  key2  key3  ...  keyN

返回值

长  键被删除。

例子
$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 */

存在

说明：验证指定的密钥是否存在。

参数

键

返回值

BOOL：如果键存在，则返回  TRUE，否则返回  FALSE。

例子
$redis->set('key', 'value');
$redis->exists('key'); /*  TRUE */
$redis->exists('NonExistingKey'); /* FALSE */

incr，incrBy

说明：将存储在密钥中的数字加1。如果第二个参数被填充，它将被用作增量的整数值。

参数

关键 值：值将被添加到键（仅适用于incrBy）

返回值

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

incrByFloat

说明：使用浮点精度递增键。

参数

密钥 值：（浮点）值，该值将被添加到关键

返回值

FLOAT  新的价值

例子
$redis->incrByFloat('key1', 1.5); /* key1 didn't exist, so it will now be 1.5 */


$redis->incrByFloat('key1', 1.5); /* 3 */
$redis->incrByFloat('key1', -1.5); /* 1.5 */
$redis->incrByFloat('key1', 2.5); /* 4 */

鹿，decrBy

说明：将存储在密钥中的数字减1。如果第二个参数被填充，它将被用作递减的整数值。

参数

键值 ：将被减去键的值（仅用于decrBy）

返回值

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

mGet，getMultiple

说明：获取所有指定键的值。如果一个或多个键不存在，则数组将包含  FALSE 在键的位置。

参数

Array：包含键列表的数组

返回值

Array：包含参数中与键有关的值的数组

例子
$redis->set('key1', 'value1');
$redis->set('key2', 'value2');
$redis->set('key3', 'value3');
$redis->mGet(array('key1', 'key2', 'key3')); /* array('value1', 'value2', 'value3');
$redis->mGet(array('key0', 'key1', 'key5')); /* array(`FALSE`, 'value1', `FALSE`);

GETSET

说明：设置一个值并返回该键上的前一个条目。

参数

钥匙：钥匙

STRING：价值

返回值

一个字符串，前一个值位于此键处。

例
$redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol');  // return '42', replaces x by 'lol'
$newValue = $redis->get('x')'       // return 'lol'

随机key

说明：返回一个随机密钥。

参数

没有。

返回值

STRING：Redis中的现有密钥。

例
$key = $redis->randomKey();
$surprise = $redis->get($key);  // who knows what's in there.

移动

说明：将密钥移至其他数据库。

参数

钥匙：钥匙，移动的钥匙。

INTEGER：dbindex，将密钥移至的数据库编号。

返回值

布尔：  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

重命名，重命名键

说明：重命名密钥。

参数

STRING：srckey，重命名的关键。

STRING：dstkey，密钥的新名称。

返回值

布尔：  TRUE 如果成功，  FALSE 在失败的情况下。

例
$redis->set('x', '42');
$redis->rename('x', 'y');
$redis->get('y');   // → 42
$redis->get('x');   // → `FALSE`

renameNx

说明：与重命名相同，但如果目标已存在，则不会替换密钥。这与setNx的行为相同。

到期，setTimeout，pexpire

说明：设置项目的到期日期（超时）。pexpire需要以毫秒为单位的TTL。

参数

钥匙：钥匙。将消失的关键。

整数：ttl。密钥剩余的生存时间，以秒为单位。

返回值

布尔：  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.

expireAt，pexpireAt

说明：设置项目的到期日期（时间戳）。pexpireAt需要以毫秒为单位的时间戳。

参数

钥匙：钥匙。将消失的关键。

整数：Unix时间戳。钥匙的死亡日期，距离大纪元时间仅几秒钟。

返回值

布尔：  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.

键，getKeys

说明：返回与特定模式匹配的键。

参数

STRING：模式，使用'*'作为通配符。

返回值

STRING数组：匹配特定模式的键。

例
$allKeys = $redis->keys('*');   // all keys will match this.
$keyWithUserPrefix = $redis->keys('user*');

扫描

说明：扫描密钥的密钥空间

参数

LONG（引用）：Iterator，初始化为NULL  STRING，可选：与LONG匹配的模式  ，可选：每次迭代计算键值（仅向Redis提供建议）

返回值

数组，布尔值：如果没有更多的键，则此函数将返回一组键或FALSE

例
$it = NULL; /* Initialize our iterator to NULL */
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); /* retry when we get no keys back */
while($arr_keys = $redis->scan($it)) {
    foreach($arr_keys as $str_key) {
        echo "Here is a key: $str_key\n";
    }
    echo "No more keys to scan!\n";
}

目的

说明：描述一个键指向的对象。

参数

要检索的信息（字符串）和密钥（字符串）。信息可以是以下之一：

  • “编码”
  • “引用计数”
  • “空闲时间”
返回值

STRING  为“编码”，  LONG  为“refcount”和“空闲时间”，  FALSE 如果密钥不存在。

例
$redis->object("encoding", "l"); // → ziplist
$redis->object("refcount", "l"); // → 1
$redis->object("idletime", "l"); // → 400 (in seconds, with a precision of 10 seconds).

类型

说明：返回给定键指向的数据类型。

参数

钥匙：钥匙

返回值

根据键所指向的数据类型，此方法将返回以下值：string：Redis :: REDIS_STRING set：Redis :: REDIS_SET list：Redis :: REDIS_LIST zset：Redis :: REDIS_ZSET hash：Redis :: REDIS_HASH其他：Redis :: REDIS_NOT_FOUND

例
$redis->type('key');

附加

说明：将指定的字符串追加到存储在指定键中的字符串中。

参数

主要 价值

返回值

INTEGER：追加后的值的大小

例
$redis->set('key', 'value1');
$redis->append('key', 'value2'); /* 12 */
$redis->get('key'); /* 'value1value2' */

getRange

说明：返回一个较大字符串的子字符串

注意：substr也支持，但在redis中不推荐使用。

参数

关键 开始 结束

返回值

STRING：子字符串

例
$redis->set('key', 'string value');
$redis->getRange('key', 0, 5); /* 'string' */
$redis->getRange('key', -5, -1); /* 'value' */

SetRange

说明：更改较大字符串的子字符串。

参数

键 偏移 值

返回值

STRING：修改后的字符串长度。

例
$redis->set('key', 'Hello world');
$redis->setRange('key', 6, "redis"); /* returns 11 */
$redis->get('key'); /* "Hello redis" */

STRLEN

说明：获取字符串值的长度。

参数

键

返回值

整数

例
$redis->set('key', 'value');
$redis->strlen('key'); /* 5 */

GETBIT

说明：从较大的字符串中返回一位

参数

关键 抵消

返回值

LONG：位值（0或1）

例
$redis->set('key', "\x7f"); // this is 0111 1111
$redis->getBit('key', 0); /* 0 */
$redis->getBit('key', 1); /* 1 */

setBit

说明：更改一个字符串的单个位。

参数

键 偏移 值：bool或int（1或0）

返回值

LONG：0或1，它被设置之前的位的值。

例
$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") */

bitOp

说明：在多个按键上按位操作。

参数

操作：“AND”，“OR”，“NOT”，“XOR”  ret_key：返回键  key1  key2 ...

返回值

LONG：目标键中存储的字符串的大小。

位计数

说明：计算字符串中的位。

参数

键

返回值

LONG：输入键后面的值中设置为1的位数。

分类

说明：对列表中的元素进行排序，设置或排序集。

参数

键：键  选项：数组（键=>值，...） - 可选，使用以下键和值：

    'by' => 'some_pattern_*',
    'limit' => array(0, 1),
    'get' => 'some_other_pattern_*' or an array of patterns,
    'sort' => 'asc' or 'desc',
    'alpha' => TRUE,
    'store' => 'external-key'
返回值

一组数值，或者一个数字，对应于存储的元素数量（如果使用的话）。

例
$redis->delete('s');
$redis->sAdd('s', 5);
$redis->sAdd('s', 4);
$redis->sAdd('s', 2);
$redis->sAdd('s', 1);
$redis->sAdd('s', 3);

var_dump($redis->sort('s')); // 1,2,3,4,5
var_dump($redis->sort('s', array('sort' => 'desc'))); // 5,4,3,2,1
var_dump($redis->sort('s', array('sort' => 'desc', 'store' => 'out'))); // (int)5

ttl，pttl

说明：以秒（ttl）或毫秒（pttl）为单位返回给定键的剩余时间。

参数

钥匙：钥匙

返回值

LONG：以秒为单位的时间。如果密钥没有ttl，  -1 将被返回，并且  -2 密钥不存在。

例
$redis->ttl('key');

坚持

说明：从密钥中删除到期计时器。

参数

钥匙：钥匙

返回值

布尔：  TRUE 如果超时被删除，  FALSE 如果密钥不存在或没有到期计时器。

例
$redis->persist('key');

mSet，mSetNx

说明：在一个原子命令中设置多个键值对。如果所有密钥均已设置，则MSETNX仅返回TRUE（请参阅SETNX）。

参数

对：数组（键=>值，...）

返回值

布尔 TRUE  如果成功，  FALSE 在失败的情况下。

例

$redis->mSet(array('key0' => 'value0', 'key1' => 'value1'));
var_dump($redis->get('key0'));
var_dump($redis->get('key1'));

输出：

string(6) "value0"
string(6) "value1"

倾倒

说明：从Redis数据库中转出密钥，其值可以稍后通过RESTORE命令传递给redis。DUMP出来的数据是Redis存储密钥的二进制表示形式。

参数

键  字符串

返回值

Redis编码密钥的值，如果密钥不存在，则为FALSE

例子
$redis->set('foo', 'bar');
$val = $redis->dump('foo'); // $val will be the Redis encoded key value

恢复

说明：从DUMP操作的结果中恢复一个密钥。

参数

键  字符串。密钥名称  ttl  整数。密钥应存活多长时间（如果为零，则不会在密钥上设置过期  值）  字符串（二进制）。Redis编码密钥值（来自DUMP）

例子
$redis->set('foo', 'bar');
$val = $redis->dump('foo');
$redis->restore('bar', 0, $val); // The key 'bar', will now be equal to the key 'foo'

迁移

说明：将密钥迁移到其他Redis实例。

参数

主机  字符串。目标主机  端口的  整数。要连接的TCP端口。 键  字符串。迁移的关键。 destination-db整数。目标数据库。 超时  整数。此次转帐的最长时间。 复制  布尔值，可选。我们是否应该将COPY标志发送到redis  替换  布尔值，可选。我们是否应该将REPLACE标志发送给redis

例子
$redis->migrate('backup', 6379, 'foo', 0, 3600);
$redis->migrate('backup', 6379, 'foo', 0, 3600, true, true); /* copy and replace */
$redis->migrate('backup', 6379, 'foo', 0, 3600, false, true); /* just REPLACE flag */

哈希

  • hDel  - 删除一个或多个散列字段
  • hExists  - 确定是否存在散列字段
  • hGet  - 获取散列字段的值
  • hGetAll  - 获取散列中的所有字段和值
  • hIncrBy  - 将散列字段的整数值增加给定数字
  • hIncrByFloat  - 将哈希字段的float值增加给定量
  • hKeys  - 获取散列中的所有字段
  • hLen  - 获取散列中的字段数
  • hMGet  - 获取所有给定散列字段的值
  • hMSet  - 将多个散列字段设置为多个值
  • hSet  - 设置散列字段的字符串值
  • hSetNx  - 仅当字段不存在时才设置散列字段的值
  • hVals  - 获取散列中的所有值
  • hScan  - 扫描会员的散列键

置盘

说明：为存储在键上的散列值添加一个值。

参数

key  hashKey  值

返回值

 1 如果值不存在并且已成功添加，0 则该值为LONG，  如果该值已经存在并被替换，  FALSE 则出现错误。

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

说明：只有当该字段不在散列中时，才会将值添加到存储在密钥中的散列。

返回值

BOOL TRUE  是否设置了字段，  FALSE 如果它已经存在。

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

说明：从密钥中存储的散列获取值。如果散列表不存在，或者该键不存在，  FALSE 则返回。

参数

key  hashKey

返回值

STRING  值，如果命令成功执行，则  BOOL FALSE  在失败的情况下

为hLen

说明：以项目数量的形式返回散列的长度

参数

键

返回值

LONG  中的散列项目的数量，  FALSE 如果该键不存在或不是一个哈希值。

例
$redis->delete('h')
$redis->hSet('h', 'key1', 'hello');
$redis->hSet('h', 'key2', 'plop');
$redis->hLen('h'); /* returns 2 */

HDEL

说明：从密钥中存储的散列中删除一个值。如果散列表不存在，或者该键不存在，  FALSE 则返回。

参数

key  hashKey1  hashKey2  ...

返回值

LONG  删除的键的数量，如果该键不存在，FALSE 则为0，  如果该键不是散列。

hKeys

说明：将散列中的键作为字符串数组返回。

参数

钥匙：钥匙

返回值

一组元素，散列的键。这工作像PHP的array_keys（）。

例
$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'));

输出：

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [2]=>
  string(1) "c"
  [3]=>
  string(1) "d"
}

顺序是随机的，并对应于redis自己的集合结构的内部表示。

鲸鱼

说明：以散列值的形式返回字符串数组。

参数

钥匙：钥匙

返回值

一组元素，哈希的值。这可以像PHP的array_values（）一样工作。

例
$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'));

输出：

array(4) {
  [0]=>
  string(1) "x"
  [1]=>
  string(1) "y"
  [2]=>
  string(1) "z"
  [3]=>
  string(1) "t"
}

顺序是随机的，并对应于redis自己的集合结构的内部表示。

hGetAll

说明：返回整个散列，作为由字符串索引的字符串数组。

参数

钥匙：钥匙

返回值

一组元素，散列的内容。

例
$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'));

输出：

array(4) {
  ["a"]=>
  string(1) "x"
  ["b"]=>
  string(1) "y"
  ["c"]=>
  string(1) "z"
  ["d"]=>
  string(1) "t"
}

顺序是随机的，并对应于redis自己的集合结构的内部表示。

hExists

说明：验证指定的成员是否存在于某个键中。

参数

key  memberKey

返回值

BOOL：如果该成员存在于散列表中，则返回  TRUE，否则返回  FALSE。

例子
$redis->hSet('h', 'a', 'x');
$redis->hExists('h', 'a'); /*  TRUE */
$redis->hExists('h', 'NonExistingKey'); /* FALSE */

hIncrBy

说明：按给定数量从散列中增加成员的值。

参数

关键 成员 值：（整数）值将被添加到成员的值

返回值

长  新价值

例子
$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

说明：通过提供的浮点值增加散列成员的值

参数

关键 成员 值：（float）值将被添加到成员的值

返回值

FLOAT  新的价值

例子
$redis->delete('h');
$redis->hIncrByFloat('h','x', 1.5); /* returns 1.5: h[x] = 1.5 now */
$redis->hIncrByFloat('h', 'x', 1.5); /* returns 3.0: h[x] = 3.0 now */
$redis->hIncrByFloat('h', 'x', -3.0); /* returns 0.0: h[x] = 0.0 now */

hMSet

说明：填充整个散列。使用标准转换将非字符串值转换为字符串  (string) 。NULL值存储为空字符串。

参数

关键 成员：键→值数组

返回值

BOOL

例子
$redis->delete('user:1');
$redis->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
$redis->hIncrBy('user:1', 'salary', 100); // Joe earns 100 more now.

hMGet

说明：检索与散列中指定字段关联的值。

参数

key  memberKeys  Array

返回值

Array  一个元素数组，散列中指定字段的值，散列键作为数组键。

例子
$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') */

HSCAN

说明：使用可选模式和计数扫描成员的HASH值

参数

key：字符串  迭代器：Long（引用）  模式：与count匹配的可选模式  ：一次返回多少个键（仅对Redis进行消解）

返回值

数组  与我们的模式相匹配的成员数组

例子
$it = NULL;
/* Don't ever return an empty array until we're done iterating */
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
while($arr_keys = $redis->hScan('hash', $it)) {
    foreach($arr_keys as $str_field => $str_value) {
        echo "$str_field => $str_value\n"; /* Print the hash member and value */
    }
}

清单

  • blPop，brPop  - 删除并获取列表中的第一个/最后一个元素
  • bRPopLPush  - 从列表中弹出一个值，将其推送到另一个列表并返回
  • lIndex，lGet  - 通过索引从列表中获取元素
  • lInsert  - 在列表中的另一个元素之前或之后插入一个元素
  • lLen，lSize  - 获取列表的长度/大小
  • lPop  - 删除并获取列表中的第一个元素
  • l推送  - 将一个或多个值添加到列表中
  • lPushx  - 只有当列表存在时，才会将值列入列表
  • lRange，lGetRange  - 从列表中获取一系列元素
  • lRem，lRemove  - 从列表中删除元素
  • lSet  - 通过索引设置列表中元素的值
  • lTrim，listTrim  - 将列表修剪到指定的范围
  • rPop  - 删除并获取列表中的最后一个元素
  • rPopLPush  - 删除列表中的最后一个元素，将其附加到另一个列表并返回它（redis> = 1.1）
  • rPush  - 将一个或多个值附加到列表中
  • rPushX  - 仅当列表存在时，才会将值附加到列表中

blPop，brPop

说明：是一个阻塞lPop（rPop）原语。如果至少有一个列表包含至少一个元素，则该元素将从列表头部弹出并返回给调用者。如果所有通过参数传递的键标识的列表都是空的，blPop将在指定的超时期间阻塞，直到元素被推送到其中一个列表。这个元素将被弹出。

参数

ARRAY  包含列表键的数组  INTEGER  Timeout或  STRING  Key1  STRING  Key2  STRING  Key3 ...  STRING  Keyn INTEGER  Timeout

返回值

ARRAY  数组（'listName'，'element'）

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

bRPopLPush

说明：阻塞版本  rPopLPush，在第三个参数中具有整数超时。

参数

密钥：srckey  密钥：dstkey  长：超时

返回值

STRING  成功时移动的元素，  FALSE 以防超时。

lIndex，lGet

说明：返回存储在指定键上的列表的指定元素。

0第一个元素，1第二个... -1最后一个元素，-2倒数第二个...

FALSE 在索引不正确的情况下返回  或者不指向列表的键。

参数

关键 指标

返回值

 如果键标识非字符串数据类型，或者没有值与列表中的此索引对应，则将此索引中的   元素  字符串布尔化 。FALSEKey

例
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lGet('key1', 0); /* 'A' */
$redis->lGet('key1', -1); /* 'C' */
$redis->lGet('key1', 10); /* `FALSE` */

/

lInsert

说明：在枢轴值之前或之后在列表中插入值。

参数选项指定插入的位置（之前或之后）。如果列表不存在，或者数据透视表不存在，则不插入该值。

参数

关键 位置  Redis :: BEFORE | Redis :: AFTER  枢轴 值

返回值

列表中元素的数量，如果数据透视表不存在则为-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 */

LPOP

说明：返回并删除列表的第一个元素。

参数

键

返回值

STRING  命令执行成功  BOOL FALSE  出现故障（空列表）

例
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lPop('key1'); /* key1 => [ 'B', 'C' ] */

LPUSH

说明：将字符串值添加到列表的头部（左侧）。如果密钥不存在，则创建列表。如果密钥存在并且不是列表，  FALSE 则返回。

参数

键值   字符串，键入的值

返回值

LONG  成功时列表的新长度，  FALSE 以防失败。

例子
$redis->delete('key1');
$redis->lPush('key1', 'C'); // returns 1
$redis->lPush('key1', 'B'); // returns 2
$redis->lPush('key1', 'A'); // returns 3
/* key1 now points to the following list: [ 'A', 'B', 'C' ] */

lPushx

说明：如果列表存在，则将字符串值添加到列表头（左侧）。

参数

键值   字符串，键入的值

返回值

LONG  成功时列表的新长度，  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: [ 'A', 'B', 'C' ] */

lRange，lGetRange

说明：返回存储在范围[start，end]中指定键处的列表的指定元素。开始和结束被解释为索引：0第一个元素，1第二个... -1最后一个元素，-2倒数第二个...

参数

关键 开始 结束

返回值

 包含指定范围内的值的数组。

例
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C');
$redis->lRange('key1', 0, -1); /* array('A', 'B', 'C') */

lRem，lRemove

说明：count 从列表中删除值元素的第一次出现  。如果count为零，则删除所有匹配的元素。如果计数是负数，元素将从尾部移到头部。

注意：参数顺序与Redis文档中的不同。出于兼容性原因保留了这种差异。

参数

关键 值 计数

返回值

龙  元素的数量删除  BOOL 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') */

LSET

说明：使用新值在索引处设置列表。

参数

关键 指标 值

返回值

BOOL TRUE  是否设置了新值。 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' */

lTrim，listTrim

说明：修剪现有列表，使其仅包含指定范围的元素。

参数

按键 启动 停止

返回值

  如果密钥标识非列表值，则 返回  Array BoolFALSE。

例
$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') */

RPOP

说明：返回并删除列表的最后一个元素。

参数

键

返回值

STRING  命令执行成功  BOOL FALSE  出现故障（空列表）

例
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->rPop('key1'); /* key1 => [ 'A', 'B' ] */

rPopLPush

说明：从列表的尾部弹出一个值，并将其推到另一个列表的前面。同样返回这个值。（redis> = 1.1）

参数

密钥：srckey  密钥：dstkey

返回值

STRING  成功时移动的元素，  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->rPopLPush('x', 'y'));
var_dump($redis->lRange('x', 0, -1));
var_dump($redis->lRange('y', 0, -1));

输出：

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

RPUSH

说明：将字符串值添加到列表的尾部（右侧）。如果密钥不存在，则创建列表。如果密钥存在并且不是列表，  FALSE 则返回。

参数

键值   字符串，键入的值

返回值

LONG  成功时列表的新长度，  FALSE 以防失败。

例子
$redis->delete('key1');
$redis->rPush('key1', 'A'); // returns 1
$redis->rPush('key1', 'B'); // returns 2
$redis->rPush('key1', 'C'); // returns 3
/* key1 now points to the following list: [ 'A', 'B', 'C' ] */

rPushX

说明：如果ist存在，则将字符串值添加到列表的尾部（右侧）。 FALSE 在失败的情况下。

参数

键值   字符串，键入的值

返回值

LONG  成功时列表的新长度，  FALSE 以防失败。

例子
$redis->delete('key1');
$redis->rPushX('key1', 'A'); // returns 0
$redis->rPush('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' ] */

lLen，lSize

说明：返回由Key标识的列表大小。

如果列表不存在或为空，则该命令返回0.如果由Key标识的数据类型不是列表，则该命令返回FALSE。

参数

键

返回值

LONG  由Key标识的列表大小存在。 BOOL FALSE  如果由Key标识的数据类型不是列表

例
$redis->rPush('key1', 'A');
$redis->rPush('key1', 'B');
$redis->rPush('key1', 'C'); /* key1 => [ 'A', 'B', 'C' ] */
$redis->lSize('key1');/* 3 */
$redis->rPop('key1');
$redis->lSize('key1');/* 2 */

集

  • sAdd  - 将一个或多个成员添加到一个集合
  • sCard，sSize  - 获取集合中成员的数量
  • sDiff  - 减去多个集合
  • sDiffStore  - 减去多个集合并将结果集存储在一个键中
  • sInter  - 相交多组
  • sInterStore  - 交集多个集合并将结果集存储在一个密钥中
  • sIsMember，sContains  - 确定给定值是否为集合的成员
  • sMembers，sGetMembers  - 获取集合中的所有成员
  • sMove  - 将成员从一组移动到另一组
  • sPop  - 从集合中移除并返回一个随机成员
  • sRandMember  - 从一个集合中获取一个或多个随机成员
  • sRem，sRemove  - 从一个集合中删除一个或多个成员
  • sUnion  - 添加多个集合
  • sUnionStore  - 添加多个集合并将结果集存储在一个密钥中
  • sScan  - 扫描一组成员

萨德

说明：为存储在键上的设定值添加一个值。如果此值已在集合中，  FALSE 则返回。

参数

关键 值

返回值

LONG  添加到集合中的元素的数量。

例
$redis->sAdd('key1' , 'member1'); /* 1, 'key1' => {'member1'} */
$redis->sAdd('key1' , 'member2', 'member3'); /* 2, 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sAdd('key1' , 'member2'); /* 0, 'key1' => {'member1', 'member2', 'member3'}*/

sCard，sSize

说明：返回由键标识的集合的基数。

参数

键

返回值

LONG  由key标识的集合的基数，如果集合不存在，则为0。

例
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sCard('key1'); /* 3 */
$redis->sCard('keyX'); /* 0 */

那么sdiff

说明：执行N组之间的差异并返回它。

参数

密钥：密钥1，密钥2，...，密钥N：与redis中的组相对应的任意数量的密钥。

返回值

字符串数组：第一组的差别将是所有其他组的差异。

例
$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->sDiff('s0', 's1', 's2'));

返回值：s1中既不在s1也不在s2中的所有元素。

array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}

sDiffStore

说明：执行与sDiff相同的操作，但将结果存储在第一个键中

参数

键：dstkey，存储diff的键。

密钥：密钥1，密钥2，...，密钥N：与redis中的组相对应的任意数量的密钥

返回值

INTEGER：结果集的基数，或者  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'));

返回值：s1中既不在s1也不在s2中的元素数。

int(2)
array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}

泉华

说明：返回由指定键保存的所有集合的交集所产生的集合的成员。

如果只指定了一个键，则该命令将生成该组的成员。如果其中一个键丢失，  FALSE 则返回。

参数

key1，key2，keyN：标识我们将应用交集的不同集合的键。

返回值

数组，包含这些键之间的交集结果。如果不同集合的交集为空，则返回值将为空数组。

例子
$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

说明：执行sInter命令并将结果存储在新的集合中。

参数

键：dstkey，存储diff的键。

密钥：密钥1，密钥2 ...密钥N。key1..keyN与sInter相交。

返回值

INTEGER：结果集的基数，或者  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"
}

sIsMember，sContains

说明：检查是否  value 存储在密钥中的组的成员  key。

参数

关键 值

返回值

BOOL TRUE  如果  value 是密钥集中的成员  key，  FALSE 否则。

例
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/

$redis->sIsMember('key1', 'member1'); /* TRUE */
$redis->sIsMember('key1', 'memberX'); /* FALSE */

sMembers，sGetMembers

说明：返回一个集合的内容。

参数

钥匙：钥匙

返回值

一组元素，集合的内容。

例
$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"
}

顺序是随机的，并对应于redis自己的集合结构的内部表示。

SMOVE

说明：将指定成员从srcKey中的集合移至dstKey处的集合。

参数

srcKey  dstKey  成员

返回值

BOOL  如果操作成功，则返回  TRUE。如果srcKey和/或dstKey不存在，并且/或者该成员在srcKey中不存在，  FALSE 则返回。

例
$redis->sAdd('key1' , 'member11');
$redis->sAdd('key1' , 'member12');
$redis->sAdd('key1' , 'member13'); /* 'key1' => {'member11', 'member12', 'member13'}*/
$redis->sAdd('key2' , 'member21');
$redis->sAdd('key2' , 'member22'); /* 'key2' => {'member21', 'member22'}*/
$redis->sMove('key1', 'key2', 'member13'); /* 'key1' =>  {'member11', 'member12'} */
                    /* 'key2' =>  {'member21', 'member22', 'member13'} */

SPOP

说明：从Key中的设置值中移除并返回一个随机元素。

参数

键

返回值

字符串  “弹出”值   如果由键标识的设置为空或不存在，则为Bool FALSE。

例
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member3', 'member1', 'member2'}*/
$redis->sPop('key1'); /* 'member1', 'key1' => {'member3', 'member2'} */
$redis->sPop('key1'); /* 'member3', 'key1' => {'member2'} */

sRandMember

说明：从Key中的设置值返回一个随机元素，而不删除它。

参数

键 数  （整数，可选）

返回值

如果未提供计数， 则将返回该集合中的随机  字符串值。如果提供计数，则将返回该组中的值数组。阅读关于在这里使用计数的不同方法：  SRANDMEMBER   如果由键标识的集合为空或不存在，则为Bool FALSE。

例
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member3', 'member1', 'member2'}*/

// No count
$redis->sRandMember('key1'); /* 'member1', 'key1' => {'member3', 'member1', 'member2'} */
$redis->sRandMember('key1'); /* 'member3', 'key1' => {'member3', 'member1', 'member2'} */

// With a count
$redis->sRandMember('key1', 3); // Will return an array with all members from the set
$redis->sRandMember('key1', 2); // Will an array with 2 members of the set
$redis->sRandMember('key1', -100); // Will return an array of 100 elements, picked from our set (with dups)
$redis->sRandMember('empty-set', 100); // Will return an empty array
$redis->sRandMember('not-a-set', 100); // Will return FALSE

sRem，sRemove

说明：从存储在键上的设定值中删除指定的成员。

参数

关键 成员

返回值

LONG  从集合中删除的元素的数量。

例
$redis->sAdd('key1' , 'member1');
$redis->sAdd('key1' , 'member2');
$redis->sAdd('key1' , 'member3'); /* 'key1' => {'member1', 'member2', 'member3'}*/
$redis->sRem('key1', 'member2', 'member3'); /*return 2. 'key1' => {'member1'} */

sUnion

说明：执行N组之间的联合并返回它。

参数

密钥：密钥1，密钥2，...，密钥N：与redis中的组相对应的任意数量的密钥。

返回值

字符串数组：所有这些集合的联合。

例
$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'));

返回值：在s0或s1或s2中的所有元素。

array(4) {
  [0]=>
  string(1) "3"
  [1]=>
  string(1) "4"
  [2]=>
  string(1) "1"
  [3]=>
  string(1) "2"
}

sUnionStore

说明：执行与sUnion相同的操作，但将结果存储在第一个键中

参数

键：dstkey，存储diff的键。

密钥：密钥1，密钥2，...，密钥N：与redis中的组相对应的任意数量的密钥。

返回值

INTEGER：结果集的基数，或者  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'));

返回值：在s0或s1或s2中的元素数量。

int(4)
array(4) {
  [0]=>
  string(1) "3"
  [1]=>
  string(1) "4"
  [2]=>
  string(1) "1"
  [3]=>
  string(1) "2"
}

SSCAN

说明：扫描成员的集合

参数

Key：搜索迭代器的集合  ：当我们去时，对迭代器的LONG（引用）  pattern：String，与count匹配的可选模式：一次返回多少个成员（Redis可能返回不同的数量）

返回值

数组，布尔：当迭代完成后， PHPRedis将返回一个键数组或者FALSE

例
$it = NULL;
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); /* don't return empty results until we're done */
while($arr_mems = $redis->sScan('set', $it, "*pattern*")) {
    foreach($arr_mems as $str_mem) {
        echo "Member: $str_mem\n";
    }
}

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

排序集

  • zAdd  - 将一个或多个成员添加到已排序的集合，或者如果它已经存在，则更新其分数
  • zCard，zSize  - 获取排序集中成员的数量
  • zCount  - 计算排序集中的成员，其中得分在给定值内
  • zIncrBy  - 增加排序集中成员的分数
  • zInter  - 交集多个有序集合并将结果的有序集合存储在新密钥中
  • zRange  - 按索引返回有序集合中的一系列成员
  • zRangeByScore，zRevRangeByScore  - 按分数返回排序集中的一系列成员
  • zRangeByLex  - 从共享相同分数的成员中返回一个文档范围
  • zRank，zRevRank  - 确定排序集中成员的索引
  • zRem，zDelete  - 从有序集合中删除一个或多个成员
  • zRemRangeByRank，zDeleteRangeByRank  - 删除给定索引内有序集合中的所有成员
  • zRemRangeByScore，zDeleteRangeByScore  - 删除给定分数中排序集中的所有成员
  • zRevRange  - 按索引返回已排序集合中的一系列成员，分数从高到低排序
  • zScore  - 获得与已排序集中给定成员关联的分数
  • zUnion  - 添加多个有序集合并将结果排序后的集合存储在新密钥中
  • zScan  - 为成员扫描一个有序集合

zAdd

说明：将一个或多个成员添加到已排序的集合或更新其分数（如果它已存在）

参数

关键 分数  ：双重  值：字符串

返回值

长  1，如果添加元素。否则为0。

例
$redis->zAdd('key', 1, 'val1');
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 5, 'val5');
$redis->zRange('key', 0, -1); // array(val0, val1, val5)

zCard，zSize

说明：返回有序集合的基数。

参数

键

返回值

长，集合的基数

例
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zSize('key'); /* 3 */

zCount

说明：返回 存储在指定键处的已排序集合中元素的  数量，其中的分数在[start，end]范围内。 在范围之前添加括号  start 或  end将其从范围中排除。+ inf和-inf也是有效的限制。

参数

键 开始：字符串  结束：字符串

返回值

长  对应的zRangeByScore的大小。

例
$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') */

zIncrBy

说明：按给定量增加排序集中成员的分数。

参数

密钥 值：（双）值，该值将被添加到所述成员的得分  构件

返回值

双重  新的价值

例子
$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 */

zInter

说明：创建第二个参数中给出的有序集合的交集。联合的结果将存储在由第一个参数定义的有序集合中。

第三个选项参数定义  weights 为应用于输入中的排序集。在这种情况下，weights 在应用聚合之前，  将乘以排序集合中每个元素的得分。第四个参数定义了  AGGREGATE指定工会结果如何汇总的选项。

参数

keyOutput  arrayZSetKeys  数组权重 aggregateFunction  “SUM”，“MIN”或“MAX”：定义在zInter期间在重复条目上使用的行为。

返回值

LONG  新排序集中值的数量。

例
$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') */

zRange

说明：返回存储在指定键上的有序集合中的一系列元素，其值在[start，end]范围内。

开始和停止被解释为从零开始的索引：0第一个元素，1第二个... -1最后一个元素，-2倒数第二个...

参数

键 开始：长  结束：长  withscores：布尔=假

返回值

 包含指定范围内的值的数组。

例
$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) */

zRangeByScore，zRevRangeByScore

说明：返回存储在指定键处的已排序集合的元素，其分数在[start，end]范围内。 在范围之前添加括号  start 或  end将其从范围中排除。+ inf和-inf也是有效的限制。当 参数start 和  end参数交换时，zRevRangeByScore以相反的顺序返回相同的项目  。

参数

键 开始：字符串  结束：字符串  选项：数组

有两个选项可用：  withscores => TRUE，和 limit => array($offset, $count)

返回值

 包含指定范围内的值的数组。

例
$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') */
$redis->zRangeByScore('key', 0, 3, array('withscores' => TRUE, 'limit' => array(1, 1)); /* array('val2' => 2) */

zRangeByLex

说明：假定成员具有相同的分数，则返回已排序集合中成员的文字范围。最小值和最大值需要以'（'（独占）'，'''（包括）或者正好是' - '（负值inf）或者'+'（正值inf）开始。与三个  或  五个参数或将返回FALSE。

参数

键：您希望运行的ZSET  分钟：您希望获得的最小字母数字值  max：您希望偏移的最大字母数字值  ：可选参数，如果您希望从第一个元素以外的地方开始。limit：可选参数，如果你想限制返回元素的数量。

返回值

 包含指定范围中的值的数组。

例
foreach(Array('a','b','c','d','e','f','g') as $c)
    $redis->zAdd('key',0,$c);

$redis->zRangeByLex('key','-','[c') /* Array('a','b','c'); */
$redis->zRangeByLex('key','-','(c') /* Array('a','b') */
$redis->zRangeByLex('key','-','[c',1,2) /* Array('b','c') */

zRank，zRevRank

说明：返回指定排序集中给定成员的排名，对于分数最低的项目，从0开始。zRevRank从0开始的与该项目  最大的  比分。

参数

关键 成员

返回值

很长，项目的分数。

例
$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 */

zRem，zDelete

说明：从有序集合中删除指定的成员。

参数

关键 成员

返回值

LONG  1成功，0失败。

例
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zDelete('key', 'val2');
$redis->zRange('key', 0, -1); /* array('val0', 'val10') */

zRemRangeByRank，zDeleteRangeByRank

说明：删除在[start，end]范围内具有等级的指定键中存储的有序集合的元素。

参数

按键 开始：LONG  结束：LONG

返回值

LONG  从排序集中删除的值的数量

例
$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) */

zRemRangeByScore，zDeleteRangeByScore

说明：删除在[start，end]范围内得分存储在指定键上的有序集合的元素。

参数

key  start：double或“+ inf”或“-inf”字符串  结尾：double或“+ inf”或“-inf”字符串

返回值

LONG  从排序集中删除的值的数量

例
$redis->zAdd('key', 0, 'val0');
$redis->zAdd('key', 2, 'val2');
$redis->zAdd('key', 10, 'val10');
$redis->zRemRangeByScore('key', 0, 3); /* 2 */

zRevRange

说明：以相反顺序返回存储在指定键范围[start，end]中的有序集合的元素。开始和停止被解释为从零开始的索引：0第一个元素，1第二个... -1最后一个元素，-2倒数第二个...

参数

键 开始：长  结束：长  withscores：布尔=假

返回值

 包含指定范围内的值的数组。

例
$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) */

zScore

说明：返回指定排序集中给定成员的分数。

参数

关键 成员

返回值

双

例
$redis->zAdd('key', 2.5, 'val2');
$redis->zScore('key', 'val2'); /* 2.5 */

zUnion

说明：创建第二个参数中给出的有序集合的联合。联合的结果将存储在由第一个参数定义的有序集合中。

第三个选项参数定义  weights 为应用于输入中的排序集。在这种情况下，weights 在应用聚合之前，  将乘以排序集合中每个元素的得分。第四个参数定义了  AGGREGATE指定工会结果如何汇总的选项。

参数

keyOutput  arrayZSetKeys  arrayWeights  aggregateFunction  “SUM”，“MIN”或“MAX”：定义zUnion期间在重复条目上使用的行为。

返回值

LONG  新排序集中值的数量。

例
$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') */

zScan

说明：使用可选的图案和数量扫描成员的有序集合

参数

key：String，设置为扫描  迭代器：Long（引用），初始化为NULL  pattern：String（可选），要匹配的模式  count：每次迭代返回多少个键（Redis可能返回不同的数字）

返回值

数组，boolean  当迭代完成时， PHPRedis将返回来自Redis的匹配键，或返回FALSE

例
$it = NULL;
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
while($arr_matches = $redis->zScan('zset', $it, '*pattern*')) {
    foreach($arr_matches as $str_mem => $f_score) {
        echo "Key: $str_mem, Score: $f_score\n";
    }
}

酒吧/分

pSubscribe

说明：按模式订阅频道

参数

模式：匹配回调的模式数组  ：一个字符串或一个包含对象和方法的数组。该回调将获得四个参数（$ redis，$ pattern，$ channel，$ message）  返回值：混合。回调中的任何非空返回值将返回给调用者。

例
function pSubscribe($redis, $pattern, $chan, $msg) {
    echo "Pattern: $pattern\n";
    echo "Channel: $chan\n";
    echo "Payload: $msg\n";
}

发布

说明：将消息发布到频道。警告：这个功能将来可能会改变。

参数

频道：发布到messsage的一个频道  ：字符串

例
$redis->publish('chan-1', 'hello, world!'); // send message.

订阅

说明：订阅频道。警告：这个功能将来可能会改变。

参数

通道：订阅回调的通道数组  ：字符串或数组（$ instance，'method_name'）。回调函数接收3个参数：redis实例，通道名称和消息。 返回值：混合。回调中的任何非空返回值将返回给调用者。

例
function f($redis, $chan, $msg) {
    switch($chan) {
        case 'chan-1':
            ...
            break;

        case 'chan-2':
            ...
            break;

        case 'chan-2':
            ...
            break;
    }
}

$redis->subscribe(array('chan-1', 'chan-2', 'chan-3'), 'f'); // subscribe to 3 chans

发布订阅

说明：允许您获取Redis pub / sub系统信息的命令。

参数

关键字：字符串，可以是：“channels”，“numsub”或“numpat”  参数：可选，变体。对于“频道”子命令，您可以传递字符串模式。用于“numsub”通道名称的数组。

返回值

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'*/
$redsi->pubSub("numpat"); /* Get the number of pattern subscribers */

交易

  1. multi，exec，discard  - 进入并退出交易模式
  2. 观看，观看  - 观看另一个客户端的修改密钥。

多，执行，丢弃。

说明：进入并退出交易模式。

参数

（可选）  Redis::MULTI 或  Redis::PIPELINE。默认为  Redis::MULTI。一个  Redis::MULTI 命令块作为单个事务运行; 一个  Redis::PIPELINE 块只是简单地传输给服务器，但是没有任何原子性的保证。discard 取消交易。

返回值

multi() 返回Redis实例并进入多模式。一旦进入多模式，所有后续的方法调用将返回相同的对象直到  exec() 被调用。

例
$ret = $redis->multi()
    ->set('key1', 'val1')
    ->get('key1')
    ->set('key2', 'val2')
    ->get('key2')
    ->exec();

/*
$ret == array(
    0 => TRUE,
    1 => 'val1',
    2 => TRUE,
    3 => 'val2');
*/

看，不看

说明：监视其他客户端修改的密钥。

如果密钥在WATCH 和  之间被修改  EXEC，则MULTI / EXEC事务将失败（返回  FALSE）。 unwatch 取消该客户端对所有密钥的观看。

参数

keys：一个键或一个键列表的字符串

例
$redis->watch('x'); // or for a list of keys: $redis->watch(array('x','another key'));
/* 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.
*/

脚本

  • eval  - 评估LUA脚本serverside
  • evalSha  - 从脚本的SHA1哈希值而不是脚本本身评估LUA脚本serverside
  • 脚本  - 执行Redis SCRIPT命令在脚本子系统上执行各种操作
  • getLastError  - 最后一个错误消息（如果有的话）
  • clearLastError  - 清除最后一条错误消息
  • _prefix  - 一种实用程序方法，将值前缀设置为phpredis的前缀
  • _unserialize  - 使用任何序列化程序设置的反序列化数据的实用程序方法
  • _serialize  - 用于设置任何序列化程序来序列化数据的实用程序方法

EVAL

说明：评估LUA脚本serverside

参数

脚本  字符串。 参数  数组，可选。 num_keys  int，可选。

返回值

混合。返回的内容取决于LUA脚本本身返回的内容，可能是标量值（int / string）或数组。返回的数组也可以包含其他数组，如果这是在您的LUA脚本中设置的。如果执行LUA脚本时出错，getLastError（）函数可以告诉你从Redis返回的消息（例如编译错误）。

例子
$redis->eval("return 1"); // Returns an integer: 1
$redis->eval("return {1,2,3}"); // Returns Array(1,2,3)
$redis->del('mylist');
$redis->rpush('mylist','a');
$redis->rpush('mylist','b');
$redis->rpush('mylist','c');
// Nested response:  Array(1,2,3,Array('a','b','c'));
$redis->eval("return {1,2,3,redis.call('lrange','mylist',0,-1)}");

Avlksh

说明：从脚本的SHA1散列而不是脚本本身评估LUA脚本serverside。

为了运行此命令，Redis必须已经加载脚本，可以通过运行脚本或通过SCRIPT LOAD命令来加载脚本。

参数

script_sha  字符串。您要运行的脚本的sha1编码散列。 参数  数组，可选。传递给LUA脚本的参数。 num_keys  int，可选。应该进入KEYS数组的参数的数量，与Redis旋转脚本时的ARGV数组

返回值

混合。参见EVAL

例子
$script = 'return 1';
$sha = $redis->script('load', $script);
$redis->evalSha($sha); // Returns 1

脚本

说明：执行Redis SCRIPT命令以在脚本子系统上执行各种操作。

用法
$redis->script('load', $script);
$redis->script('flush');
$redis->script('kill');
$redis->script('exists', $script1, [$script2, $script3, ...]);
返回值
  • SCRIPT LOAD将成功返回传递脚本的SHA1哈希，失败时返回FALSE。
  • SCRIPT FLUSH应始终返回TRUE
  • 如果脚本能够被杀死，SCRIPT KILL将返回true，否则返回false
  • SCRIPT EXISTS将为每个传递的脚本返回一个TRUE或FALSE数组

客户

说明：使用各种参数发出CLIENT命令。

Redis CLIENT命令可以通过四种方式使用。

  • 客户列表
  • 客户端GETNAME
  • 客户端SETNAME [名称]
  • CLIENT KILL [ip：port]
用法
$redis->client('list'); // Get a list of clients
$redis->client('getname'); // Get the name of the current connection
$redis->client('setname', 'somename'); // Set the name of the current connection
$redis->client('kill', <ip:port>); // Kill the process at ip:port
返回值

这将根据执行的客户端命令而有所不同。

  • CLIENT LIST将返回一个包含客户信息的数组数组。
  • CLIENT GETNAME将返回客户端名称，如果没有设置，则返回false
  • 如果可以设置，CLIENT SETNAME将返回true，否则返回false
  • 如果客户端可以被杀死，CLIENT KILL将返回true，否则返回false

注意：phpredis会尝试重新连接，所以你可以杀死自己的连接，但可能不会注意到丢失它！

GetLastError函数

说明：最后一条错误消息（如果有的话）

参数

没有

返回值

包含上次返回的基于脚本的错误消息的字符串，如果没有错误，则返回NULL

例子
$redis->eval('this-is-not-lua');
$err = $redis->getLastError();
// "ERR Error compiling script (new function): user_script:1: '=' expected near '-'"

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

_字首

说明：一种实用程序方法，将值前缀设置为phpredis的前缀。

参数

值  字符串。您希望前缀的值

返回值

如果设置了前缀，则该值现在加前缀。如果没有前缀，则该值将不会被返回。

例子
$redis->setOption(Redis::OPT_PREFIX, 'my-prefix:');
$redis->_prefix('my-value'); // Will return 'my-prefix:my-value'

_连载

说明：手动序列化值的实用程序方法。

这个方法允许你用任何序列化器配置的序列化值，手动。这对于进出EVAL命令的序列化/非序列化数据很有用，因为phpredis本身不能自动执行此操作。请注意，如果未设置序列化程序，则phpredis将将数组值更改为“数组”，将对象更改为“对象”。

参数

价值：混合。要序列化的值

例子
$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";'

_unserialize

说明：使用任何序列化程序设置的反序列化数据的实用程序方法。

如果没有设置序列化器，则该值将被返回不变。如果设置了序列化程序，并且传入的数据格式不正确，则会引发异常。如果phpredis正在序列化值，并且您在序列化的LUA脚本中从redis返回某些内容，则这可能很有用。

参数

值  字符串。要反序列化的值

例子
$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)

内省

已连接

说明：一种确定phpredis对象是否认为它已连接到服务器的方法

参数

没有

返回值

Boolean  如果phpredis认为它已连接，则返回TRUE;否则返回FALSE

和getHost

说明：检查我们连接的主机或unix插槽

参数

没有

返回值

混合连接  的主机或unix套接字，或者如果我们未连接，则为FALSE

的getPort

说明：获取我们连接的端口

参数

没有

返回值

混合  返回我们连接的端口，如果我们没有连接，则返回FALSE

getDbNum

说明：获取phpredis指向的数据库编号

参数

没有

返回值

混合  返回数据库编号（长）phpredis认为它指向或错误，如果我们没有连接

getTimeout

说明：获取用于phpredis的（写入）超时

参数

没有

返回值

混合  在我们的连接调用中指定的超时（DOUBLE），如果我们没有连接，则为FALSE

getReadTimeout

说明：如果我们未连接，请将读取超时指定为phpredis或FALSE

参数

没有

返回值

混合  返回读取超时（可以使用setOption和Redis :: OPT_READ_TIMEOUT设置）或者如果我们没有连接，则返回FALSE

getPersistentID

说明：获取phpredis正在使用的持久ID

参数

没有

返回值

混合  返回phpredis正在使用的持久性标识（仅在与pconnect连接时才会设置），如果我们不使用持久性标识，则返回NULL，如果我们未连接，则返回FALSE

getAuth

说明：获取用于认证phpredis连接的密码

参数

没有

返回值

混合  返回用于认证phpredis会话的密码，如果没有使用密码，则返回NULL;如果没有连接，则返回FALSE

posted on 2018-05-22 16:30  刘海川  阅读(329)  评论(0)  编辑  收藏  举报

导航