phpredis

头像
dejavu
    阅读 37 分钟
    7

    Redis 类和方法

    用法

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

    Redis 类

    创建Redis客户端

    示例
    $redis = new Redis();

    RedisException 类

    如果无法访问Redis服务器，phpredis抛出RedisException异常，如Redis服务关闭，Redis主机过载等。除去服务器无法访问的情形（key不存在，或无效命令等），phpredis返回FALSE

    预定义常量

    可用的Redis常量
    Redis数据类型，同方法 type 返回值

    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

    Redis 连接

    1. connect, open - 连接到Redis服务器
    2. pconnect, popen - 连接到Redis服务器（持久连接）
    3. auth - 服务器验证
    4. select - 切换数据库
    5. swapdb - 交换两个数据库
    6. close - 关闭连接
    7. setOption - 设置客户端配置
    8. getOption - 获取客户端配置
    9. ping - 查看服务是否运行
    10. echo - 输出给定字符串

    connect, open

    连接到Redis实例

    参数

    host: string 域名或unix套接字
    port: int 可选，端口号
    timeout: float 连接超时时间，秒（可选，默认0，表示无限制）
    reverved: 如果指定了retry_interval，该值应为NULL
    retry_interval: int 重连延时时间，毫秒（可选）
    read_timeout: float 读取key的超时时间，秒（可选，默认0，表示无限制）

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->connect('127.0.0.1', 6379);
$redis->connect('127.0.0.1'); // 默认6379端口
$redis->connect('127.0.0.1', 6379, 2.5); // 2.5s连接超时
$redis->connect('/tmp/redis.sock'); // unix套接字
$redis->connect('127.0.0.1', 6379, 1, NULL,100); // 1s连接超时，100ms延时重连

    pconnect, popen

    连接到Redis实例，或重用pconnect/popen建立的连接

    使用close命令或结束请求都不会关闭连接，直到php进程结束。因此，在连接到同一台redis服务器的多台服务器上使用持久连接时，要对大量的FD错误有所防备，尤其在redis服务器端。

    持久连接可以通过host + port + timeout或host + persistent_id或unix socket + timeout建立。

    该特性不适用于多线程版本。多线程版本中，pconnect和popen的工作方式和非持久连接的工作方式相同。

    参数

    host: string 域名或unix套接字
    port: int 端口号，可选
    timeout: float 连接超时时间，秒（可选，默认0，表示无限制）
    persistent_id: string 持久连接请求标识
    retry_interval: int 重连时间间隔，秒
    read_timeout: float 读取key的超时时间，秒（可选，默认0，表示无限制）

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->pconnect('127.0.0.1', 6379);
$redis->pconnect('127.0.0.1'); // 默认端口6379，和上述连接为同一连接
$redis->pconnect('127.0.0.1', 6379, 2.5); // 2.5s超时，新连接
$redis->pconnect('127.0.0.1', 6379, 2.5, 'x'); // x作为persistent_id，新连接
$redis->pconnect('/tmp/redis.sock'); // unix套接字，新连接

    auth

    使用密码验证连接，密码以纯文本形式发送。

    参数

    password: string

    返回值

    boolean: 验证通过返回TRUE，否则返回FALSE

    示例

    $redis->auth('foobared');

    select

    切换到指定数据库

    参数

    dbindex: int 数据库索引

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例

    参考 move 方法

    swapdb

    交换两数据库

    参数

    db1: int
    db2: int

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    注意：要求Redis >= 4.0.0

    示例
    $redis->swapdb(0, 1); // 交换数据库 0 和 1

    close

    断开与Redis实例的连接，除非使用pconnect

    setOption

    设置客户端配置

    参数

    parameter name
    parameter value

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // 不序列化数据
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP); // 使用内置的序列化/反序列化
$redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY); // 使用 igBinary 序列化/反序列化

$redis->setOption(Redis::OPT_PREFIX, 'myAppName'); // 在所有 key 上使用自定义前缀

/*
SCAN 系列命令配置，指示是否获取空的用户输入。如果设为 SCAN_NORETRY (默认)，phpredis 一次发出一条 SCAN 命令，有时会返回空数组。如果设为 SCAN_RETRY ，phpredis 会重复发送 SCAN 指令，直到返回 keys 或者 Redis 返回零迭代器
*/
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);

    getOption

    获取客户端配置

    参数

    parameter name

    返回值

    parameter value

    示例
    $redis->getOption(Redis::OPT_SERIALIZER); // 返回 Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP 或 Redis::SERIALIZER_IGBINARY

    ping

    检查连接状态

    参数

    无

    返回值

    string: 成功返回+PONG，失败时抛出RedisException异常

    echo

    打印字符串

    参数

    string: string 要输出的字符串

    返回值

    string: 输入的字符串

    Redis 服务器

    1. bgRewriteAOF - 异步执行一个AOF（append-only file）文件重写操作
    2. bgSave - 在后台异步保存当前数据库的数据到磁盘
    3. config - 获取/设置Redis服务器配置
    4. dbSize - 返回当前数据库的key的数量
    5. flushAll - 删除所有数据库的所有key
    6. flushDb - 删除当前数据库的所有key
    7. info - 获取Redis服务器的各种信息和统计数值
    8. lastSave - 返回最近一次Redis成功将数据保存到磁盘上的时间，以UNIX时间戳格式表示
    9. resetStat - 重置 info 命令中的某些统计数据
    10. save - 同步保存数据到硬盘
    11. slaveOf - 将当前服务器转变为指定服务器的从属服务器
    12. time - 返回当前服务器时间
    13. slowLog - 管理redis的慢日志

    bgRewriteAOF

    异步执行一个AOF（append-only file）文件重写操作

    参数

    无

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->bgRewriteAOF();

    bgSave

    在后台异步保存当前数据库的数据到磁盘

    参数

    无

    返回值

    boolean: 成功返回TRUE，失败返回FALSE。如果正在执行save操作，返回FALSE

    示例
    $redis->bgSave();

    config

    获取/设置Redis服务器配置

    参数

    operation: string GET或SET
    key: string
    value: string 可选（仅针对SET）

    返回值

    array/boolean: GET返回关联数组，SET返回布尔值

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

    dbSize

    返回当前数据库的key的数量

    参数

    无

    返回值

    int: 当前数据库的key的数量

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

    flushAll

    删除所有数据库的所有key

    参数

    无

    返回值

    boolean: 始终返回TRUE

    示例
    $redis->flushAll();

    flushDb

    删除当前数据库的所有key

    参数

    无

    返回值

    boolean: 始终返回TRUE

    示例
    $redis->flushDb();

    info

    获取Redis服务器的各种信息和统计数值

    返回Redis服务器信息组成的数组，不传递参数时，返回如下信息：

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

    通过传递一系列参数，可以让命令只返回某一部分信息。

    参数

    option: string 提供给redis的选项（COMMANDSTSTS，CPU等）

    示例
    $redis->info();
$redis->info('COMMANDSTATS'); // 已执行命令信息 (版本 >= 2.6)
$redis->info('CPU'); // CPU信息

    lastSave

    返回最近一次Redis成功将数据保存到磁盘上的时间，以UNIX时间戳格式表示

    参数

    无

    返回值

    int: UNIX时间戳

    示例
    $redis->lastSave();

    resetStat

    重置 info 命令中的某些统计数据

    清空以下统计信息：

    • Keyspace hits
    • Keyspace missed
    • Number of commands processed
    • Number of connections received
    • Number of expired keys
    参数

    无

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->resetStat();

    save

    同步保存数据到硬盘

    参数

    无

    返回值

    boolean: 成功返回TRUE，失败返回FALSE。如果save操作正在执行，返回FALSE

    示例
    $redis->save();

    slaveOf

    将当前服务器转变为指定服务器的从属服务器

    参数

    host: string
    port: int
    不传递参数表示终止从属关系

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->slaveOf('10.0.1.7', 6379);

$redis->slaveOf();

    time

    返回当前服务器时间

    参数

    无

    返回值

    array: 成功时返回一个关联数组，数组的第一个元素是unix时间戳秒数，第二个元素是微秒数

    示例
    $redis->time();

    slowLog

    管理redis的慢日志

    参数

    Operation: string GET、LEN或RESET
    Length: int 可选，如果执行SLOWLOG GET命令，可以传递该参数

    返回值

    array/int/boolean:
    SLOWLOG返回值取决于执行的操作：
    SLOWLOG GET 返回关联数组
    SLOWLOG LEN 返回slowLog长度 integer
    SLOWLOG RESET 返回Boolean

    示例
    // 获取10条slowlog记录
$redis->slowLog('get', 10);
// 获取默认条数的slowlog记录
$redis->slowLog('get');
// 重置slowlog
$redis->slowLog('reset');

// 获取slowlog长度
$redis->slowLog('len');

    Redis 字符串和 Redis 键

    Redis 字符串

    • append - 追加一个值到key
    • bitCount - 统计指定位区间上，值为 1 的位的个数
    • bitOp - 在字符串之间执行按位运算
    • decr, decrBy - 减少key的值
    • get - 获取key的值
    • getBit - 对key所储存的字符串值，获取指定偏移量上的位(bit)
    • getRange - 返回key中字符串值的子字符串
    • getSet - 将给定key的值设为value，并返回key的旧值(old value)
    • incr, incrBy - 增加key的值
    • incrByFloat - 将key所储存的值加上给定的浮点增量值（increment）
    • mGet, getMultiple - 获取所有(一个或多个)给定key的值
    • mSet, mSetNX - 同时设置一个或多个 key-value 对
    • set - 设置指定key的值
    • setBit - 对key所储存的字符串值，设置或清除指定偏移量上的位(bit)
    • setEx, pSetEx - 为key赋值，并设置过期时间
    • setNx - 只有在key不存在时设置key的值
    • setRange - 从指定偏移量开始，覆写给定key所储存的字符串值
    • strLen - 返回key所储存的字符串值的长度

    Redis 键

    • del, delete, unlink - 删除key
    • dump - 序列化给定key，并返回被序列化的值
    • exists - 检查给定key是否存在
    • expire, setTimeout, pexpire - 为给定key设置过期时间
    • expireAt, pexpireAt - 将key的过期时间设置为unix时间戳
    • keys, getKeys - 查找所有符合给定模式(pattern)的key
    • scan - 扫描所有key
    • migrate - 将key从一个Redis实例转移到另一个实例
    • move - 将当前数据库的key移动到给定的数据库当中
    • object - 获取key对象信息
    • persist - 移除key的过期时间，key将持久保持
    • randomKey - 从当前数据库中随机返回一个key
    • rename, renameKey - 修改key的名称
    • renameNx - 仅当新key不存在时，将key改名为新的key名
    • type - 返回key所储存的值的类型
    • sort - 对列表、集合或有序集中的元素进行排序
    • ttl, pttl - 获取key的剩余的过期时间
    • restore - 用通过 dump 获得的序列化值创建一个key

    get

    获取key的值

    参数

    key: string

    返回值

    string/boolean: key不存在时返回FALSE，否则返回key的值

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

    set

    设置指定key的值

    参数

    Key: string
    Value: string
    int/array: 可选，若传递int，将调用SETEX命令。如果Redis >= 2.6.12，则可以传递扩展选项

    返回值

    boolean: 成功时返回TRUE

    示例
    $redis->set('key', 'value');

// 将调用SETEX方法
$redis->set('key', 'value', 10);

// 设置key值，如果key不存在，设置10s过期
$redis->set('key', 'value', array('nx', 'ex' => 10));

// 设置key值，如果key不存在，设置1000ms过期
$redis->set('key', 'value', array('xx', 'px' => 1000));

    setEx, pSetEx

    为key赋值，并设置过期时间(setEx使用秒数，pSetEx使用毫秒)

    参数

    Key: string
    TTL: int
    Value: string

    返回值

    boolean: 成功返回TRUE

    示例
    $redis->setEx('key', 3600, 'value'); // 设置key值，1h过期
$redis->pSetEx('key', 100, 'value'); // 设置key值，100ms过期

    setNx

    只有在key不存在时设置key的值

    参数

    key: string
    value: string

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->setNx('key', 'value'); // 返回 TRUE
$redis->setNx('key', 'value'); // 返回 FALSE

    del, delete, unlink

    删除key

    参数

    array/string: keys组成的数组，或多个key: key1 key2 key3 ... keyN

    返回值

    int: 被删除的key数量

    示例
    $redis->set('key1', 'val1');
$redis->set('key2' ,'val2');
$redis->set('key3', 'val3');
$redis->set('key4', 'val4');

$redis->delete('key1' ,'key2'); // 返回 2
$redis->delete(array('key3', 'key4')); // 返回 2

// Redis >= 4.0.0 时可以调用unlink方法
$redis->unlink('key1', 'key2');
$redis->unlink(array('key1', 'key2'));

    exists

    检查给定key是否存在

    参数

    key: string

    返回值

    int: 检测的keys中，key存在的数量

    示例
    $redis->set('key', 'value');
$redis->exists('key'); // 1
$redis->exists('NonExistingKey'); // 0

$redis->mSet(['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz']);
$redis->exists(['foo', 'bar', 'barz']); // 3
$redis->exists('foo', 'bar', 'baz'); // 3

    注意： Redis < 4.0.0时，该方法仅接受一个参数，返回布尔值

    incr, incrBy

    key的值自增 1， 如果传递第二个参数，则作为key的增量

    参数

    key: string
    value: int key的增量（仅对incrBy有效）

    返回值

    int: 自增后的值

    示例
    $redis->incr('key1'); // 若 key1 不存在，自增前默认为 0 ，然后自增 1
$redis->incr('key1'); // 2
$redis->incr('key1'); // 3
$redis->incr('key1'); // 4

// 将调用INCRBY
$redis->incr('key1', 10); // 14
$redis->incr('key1', 10); // 24

    incrByFloat

    将key所储存的值加上给定的浮点增量值

    参数

    key: string
    value: float 增量

    返回值

    float: 自增后的值

    示例
    $redis->incrByFloat('key1', 1.5); // 1.5

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

    decr, decrBy

    key的值自减 1，如果传递第二个参数，将该参数作为减量

    参数

    key: string
    value: int key的减量（仅对decrBy有效)

    返回值

    int: 自减后的值

    示例
    $redis->decr('key1'); // key1不存在，初始化为0，然后自减

$redis->decr('key1'); // -2
$redis->decr('key1'); // -3

// 将调用DECRBY
$redis->decr('key1', 10); // -13
$redis->decr('key1', 10); // -23

    mGet, getMultiple

    获取所有(一个或多个)给定key的值，如果有一个或多个key不存在，对应的key值为FALSE

    参数

    keys: array key列表

    返回值

    array: keys对应的值

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

    将给定key的值设为value，并返回key的旧值

    参数

    Key: string

    返回值

    string: key的旧值

    示例
    $redis->set('x', '42');
$exValue = $redis->getSet('x', 'lol'); // 返回 '42', key 的值替换为 'lol'
$newValue = $redis->get('x'); // 返回 'lol'

    randomKey

    从当前数据库中随机返回一个key

    参数

    无

    返回值

    string: 随机的一个key值

    示例
    $key = $redis->randomKey();
$surprise = $redis->get($key);

    move

    将当前数据库的key移动到给定的数据库当中

    参数

    Key: string 待移动的key
    dbindex: int 数据库索引

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->select(0); // 切换到数据库 0
$redis->set('x', '42'); // 设置 x 值为 '42'
$redis->move('x', 1); // 移动 x 到数据库 1
$redis->select(1); // 切换到数据库 1
$redis->get('x'); // 返回 '42'

    rename, renameKey

    修改key的名称

    参数

    srckey: string 旧名称
    dstkey: string 新名称

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

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

    renameNx

    仅当新key不存在时，将key改名为新的key名

    expire, setTimeout, pexpire

    为给定key设置过期时间，以秒计(pexpire为毫秒)

    参数

    Key: string
    ttl: int key存活时长

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->set('x', '42');
$redis->setTimeout('x', 3); // x 在 3s 后过期
sleep(5);
$redis->get('x'); // 返回 FALSE

    expireAt, pexpireAt

    将key的过期时间设置为unix时间戳

    参数

    Key: string
    timestamp: int Unix时间戳，key的过期时间

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->set('x', '42');
$now = time(NULL);
$redis->expireAt('x', $now + 3); // x 在 3s 后过期
sleep(5);
$redis->get('x'); // 返回 FALSE

    keys, getKeys

    查找所有符合给定模式(pattern)的key

    参数

    pattern: string 使用*作为通配符

    返回值

    array: 与特定模式匹配的key

    示例
    $allKeys = $redis->keys('*'); // 匹配所有 key
$keyWithUserPrefix = $redis->keys('user*');

    scan

    扫描所有key

    参数

    iterator: int 迭代次数的引用，初始值为NULL
    pattern: string 可选，匹配模式
    count: int 可选，每次迭代的key的数量

    返回值

    array/boolean: 返回keys数组，如果Redis中key数量为 0，返回FALSE

    示例
    // 默认不启用 Redis::SCAN_RETRY
$it = NULL;
do {
    // 扫描 keys
    $arr_keys = $redis->scan($it);
    // 返回值可能为空，预防这种情形
    if ($arr_keys !== FALSE) {
        foreach ($arr_keys as $str_key) {
            echo "Here is a key: $str_key\n";
        }
    }
} while ($it > 0);
echo "No more keys to scan!\n";

// 启用 Redis::SCAN_RETRY
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$it = NULL;
// 如果返回值为空，phpredis 会再次执行 SCAN，因此不需要检查结果是否为空
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";

    object

    获取key对象信息

    参数

    info: string 需要获取的key信息，可以为下列值：

    • encoding
    • refcount
    • idletime
    返回值

    string/int/boolean: encoding返回string，refcount返回int，如果为idletime，key不存在时返回FALSE

    示例
    $redis->object('encoding', 'l'); // ziplist
$redis->object('refcount', 'l'); // 1
$redis->object('idletime', '1'); // 400s，精度为10s

    type

    返回key所储存的值的类型

    参数

    Key: string

    返回值

    string
    根据key值的数据类型，此方法返回以下值：
    string: Redis::REDIS_STRING
    set: Redis::REDIS_SET
    list: Redis::REDIS_LIST
    zset: Redis::REDIS_ZSET
    hash: Redis::REDIS_HASH
    other: Redis::REDIS_NOT_FOUND

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

    append

    追加一个值到key

    参数

    Key: string
    Value: string

    返回值

    int: 追加指定值之后，key中字符串的长度

    示例
    $redis->set('key', 'value1');
$redis->append('key', 'value2'); // 返回 12
$redis->get('key'); // 'value1value'

    getRange

    返回key中字符串值的子字符串

    参数

    key: string
    start: int
    end: int

    返回值

    string: 子字符串

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

    setRange

    从指定偏移量开始，覆写给定key所储存的字符串值

    参数

    key: string
    offset: int
    value: string

    返回值

    int: 修改后的字符串长度

    示例
    $redis->set('key', 'Hello world');
$redis->setRange('key', 6, 'redis'); // 返回 11
$redis->get('key'); // 'Hello redis'

    strLen

    返回key所储存的字符串值的长度

    参数

    key: string

    返回值

    int

    示例
    $redis->set('key', 'value');
$redis->strLen('key'); // 5

    getBit

    对key所储存的字符串值，获取指定偏移量上的位(bit)

    参数

    key: string
    offset: int

    返回值

    int: 指定位上的值(0 或 1)

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

    setBit

    对key所储存的字符串值，设置或清除指定偏移量上的位(bit)

    参数

    key: string
    offset: int
    value: int 1 或 0

    返回值

    int: 0 或 1，设置之前的位值

    示例
    $redis->set('key', '*'); // ord('*') = 42 = 0x2a = '0010 1010'
$redis->setBit('key', 5, 1); // 返回 0
$redis->setBit('key', 7, 1); // 返回 0
$redis->get('key'); // chr(0x2f) = '/' = b('0010 1111')

    bitOp

    在字符串之间执行按位运算

    参数

    operation: string AND, OR, NOT, XOR
    ret_key: string 目标key
    key: string
    key2...: string

    返回值

    int: 存储在目标key中的字符串长度

    bitCount

    统计指定位区间上，值为 1 的位的个数

    参数

    key: string

    返回值

    int: 返回key值的所有位中，值为 1 的位的个数

    sort

    对列表、集合或有序集中的元素进行排序

    参数

    Key: string
    Options: array array(key => value, ...) - 可选，使用以下键值对:

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

    array: 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

    获取key的剩余的过期时间，秒数(ttl)，毫秒数(pptl)

    参数

    Key: string

    返回值

    int: key的过期时间。如果key没有过期时间，返回-1；key不存在，返回-2

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

    persist

    移除key的过期时间，key将持久保持

    参数

    Key: string

    返回值

    boolean: 成功移除过期时间，返回TRUE；key不存在，或没有过期时间，返回FALSE;

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

    mSet, mSetNx

    同时设置一个或多个 key-value 对

    参数

    Pairs: array array(key => value, ...)

    返回值

    boolean: 成功返回TRUE，失败返回FALSE

    示例
    $redis->mSet(array('key0' => 'value0', 'key1' => 'value1'));
var_dump($redis->get('key0')); // string(6) "value0"
var_dump($redis->get('key1')); // string(6) "value1"

    dump

    序列化给定key，并返回被序列化的值

    参数

    key string

    返回值

    string/boolean: 返回序列化之后的值，如果key不存在，返回FALSE

    示例
    $redis->set('foo', 'bar');
$val = $redis->dump('foo');

    restore

    用通过 dump 获得的序列化值创建一个key

    参数

    key: string
    ttl: integer key的存活时间，为 0 时不设置过期时间
    value: string dump获得的序列化值

    示例
    $redis->set('foo', 'bar');
$val = $redis->dump('foo');
$redis->restore('bar', 0, $val); // 'bar'的值不等于'foo'的值

    migrate

    将key从一个Redis实例转移到另一个实例

    参数

    host:string 目标域名
    port: int 要连接的TCP端口
    key(s): string/array
    destination-db: int 目标数据库
    timeout: int 转移超时时间
    copy: boolean 可选，是否复制
    replace: boolean 是否替换

    示例
    $redis->migrate('backup', 6379, 'foo', 0, 3600);
$redis->migrate('backup', 6379, 'foo', 0, 3600, true, true); // 复制和替换
$redis->migrate('backup', 6379, 'foo', 0, 3600, false, true); // 仅替换

// 转移多个 key，要求 Redis >= 3.0.6
$redis->migrate('backup', 6379, ['key1', 'key2', 'key3'], 0, 3600);

    Redis 哈希

    • hDel - 删除一个或多个哈希表字段
    • hExists - 查看哈希表中，指定的字段是否存在
    • hGet - 获取存储在哈希表中指定字段的值
    • hGetAll - 获取在哈希表中的所有字段和值
    • hIncrBy - 为哈希表中的指定字段的整数值加上增量
    • hIncrByFloat - 为哈希表中的指定字段的浮点数值加上增量
    • hKeys - 获取哈希表中的所有字段名
    • hLen - 获取哈希表中字段的数量
    • hMGet - 获取所有给定字段的值
    • hMSet - 同时为哈希表中的多个字段赋值
    • hSet - 为哈希表中的一个字段赋值
    • hSetNx - 只有在字段不存在时，设置哈希表字段的值
    • hVals - 获取哈希表中所有值
    • hScan - 迭代哈希表中的键值对
    • hStrLen - 获取哈希表中，字段值的长度

    hSet

    为哈希表中的一个字段赋值

    参数

    key: string
    hashkey: string
    value: string

    返回值

    int/false: 如果字段是哈希表中的一个新建字段，并且值设置成功，返回 1 。 如果哈希表中域字段已经存在且旧值已被新值覆盖，返回 0 。出错时返回FALSE

    示例
    $redis->delete('h');
$redis->hSet('h', 'key1', 'hello'); // 返回 1，'key` => 'hello'
$redis->hGet('h', 'key1'); // 返回 'hello'

$redis->hSet('h', 'key1', 'plop'); // 替换字段值，返回 0
$redis->hGet('h', 'key1'); // 返回 'plop'

    hSetNx

    只有在字段不存在时，设置哈希表字段的值

    返回值

    boolean: 成功返回TRUE，字段已存在则返回FALSE

    示例
    $redis->delete('h');
$redis->hSetNx('h', 'key1', 'hello'); // TRUE
$redis->hSetNx('h', 'key1', 'world'); // FALSE

    hGet

    获取存储在哈希表中指定字段的值，如果哈希表或key不存在，返回FALSE

    参数

    key: string
    hashKey: string

    返回值

    string/boolean: 成功时返回字段的值，失败返回FALSE

    hLen

    获取哈希表中字段的数量

    参数

    key: string

    返回值

    int: 哈希表中字段的数量，如果key不存在或非哈希表，返回FALSE

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

    hDel

    删除一个或多个哈希表字段，如果哈希表或key不存在，返回FALSE

    参数

    key: string
    hashKey1: string
    hashKey2: string

    返回值

    int/boolean: 被删除的字段数量，key不存在时返回 0，key非哈希则返回FALSE

    hKeys

    获取哈希表中的所有字段名，返回字符串数组

    参数

    Key: string

    返回值

    array: 哈希表中所有字段名称组成的数组，类似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集合的内部排序

    hVals

    获取哈希表中所有值，返回字符串数组

    参数

    Key: string

    返回值

    array: 哈希表中所有字段值组成的数组，类似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

    获取在哈希表中的所有字段和值

    参数

    Key: string

    返回值

    array: 关联数组，哈希表的字段名称为键名，字段值为键值

    示例
    $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($reids->hGetAll('h'));
/*
输出
array(4) {
  ["a"]=>
  string(1) "x"
  ["b"]=>
  string(1) "y"
  ["c"]=>
  string(1) "z"
  ["d"]=>
  string(1) "t"
}
*/

    hExists

    查看哈希表中，指定的字段是否存在

    参数

    key: string
    memberKey: string

    返回值

    boolean: 若哈希表中，指定字段存在，返回TRUE，否则返回FALSE

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

    hIncrBy

    为哈希表中的指定字段的整数值加上增量

    参数

    key: string
    member: string
    value: int 字段的增量

    返回值

    int: 自增后的字段值

    示例
    $redis->delete('h');
$redis->hIncrBy('h', 'x', 2); // 返回 2，h[x] = 2
$redis->hIncrBy('h', 'x', 1); // h[x] = 2 + 1，返回 2

    hIncrByFloat

    为哈希表中的指定字段的浮点数值加上增量

    参数

    key: string
    member: string
    value: float 字段的浮点值增量

    返回值

    float: 自增后的字段值

    示例
    $redis->delete('h');
$redis->hIncrByFloat('h', 'x', 1.5); // 返回 1.5，h[x] = 1.5
$redis->hIncrByFloat('h', 'x', 1.5); // 返回 3.0，h[x] = 3.0
$redis->hIncrByFloat('h', 'x', -3.0); // 返回 0.0，h[x] = 0.0

    hMSet

    同时为哈希表中的多个字段赋值，非字符串值将被转换为字符串，NULL值转化为空字符串

    参数

    key: string
    members: array key => value数组

    返回值

    boolean

    示例
    $redis->delete('user:1');
$redis->hMSet('user:1', array('name' => 'Joe', 'salary' => 2000));
$redis->hIncrBy('user:1', 'salary', 100);

    hMGet

    获取所有给定字段的值

    参数

    key: string
    memberKeys array

    返回值

    array: 字段名称为键名，字段值为键值的数组

    示例
    $redis->delete('h');
$redis->hSet('h', 'field1', 'value1');
$redis->hSet('h', 'field2', 'value2');
$redis->hMGet('h', ['field1', 'field2']); // 返回 array('field1' => 'value1', 'field2' => 'value2')

    hScan

    迭代哈希表中的键值对

    参数

    key: string
    iterator: int 迭代次数的引用
    pattern: string 可选，匹配模式
    count: int 每次返回的字段数

    返回值

    array: 与给定模式匹配的元素组成的数组

    示例
    $it = NULL;
// 在迭代完成之前，不返回空值
$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";
    }
}

    hStrLen

    获取哈希表中，字段值的长度

    参数

    key: string
    field: string

    返回值

    int: 字段值的长度，哈希表或字段不存在时，返回 0

    Redis 列表

    • blPop, brPop - 移出并获取列表的第一个/最后一个元素
    • bRPopLPush - 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它
    • lIndex, lGet - 通过索引获取列表中的元素
    • lInsert - 在列表的元素前或者后插入元素
    • lLen, lSize - 获取列表长度
    • lPop - 移出并获取列表的第一个元素
    • lPush - 将一个或多个值插入到列表头部
    • lPushX - 将一个值插入到已存在的列表头部
    • lRange, lGetRange - 获取列表指定范围内的元素
    • lRem, lRemove - 移除列表元素
    • lSet - 通过索引设置列表元素的值
    • lTrim, listTrim - 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
    • rPop - 移除并获取列表最后一个元素
    • rPopLPush - 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
    • rPush - 在列表中添加一个或多个值
    • rPushX - 为已存在的列表添加值

    blPop, brPop

    移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

    参数

    keys: array 包含列表中key的数组
    timeout: int 超时时间
    或
    key: string
    key2: string
    key3: string
    ...
    keyn: string
    timeout: int 超时时间

    返回值

    array: array('listName', 'element')

    示例
    // 非阻塞
$redis->lPush('key1', 'A');
$redis->delete('key2');

$redis->blPop('key1', 'key2', 10); // array('key1', 'A')
// 或
$redis->blPop(['key1', 'key2'], 10); // array('key1', 'A')

$redis->brPop('key1', 'key2', 10); // array('key1', 'A');
// 或
$redis->brPop(['key1', 'key2'], 10); // array('key1', 'A')

// 阻塞
// 进程 1
$redis->delete('key1');
$redis->blPop('key1', 10); // 阻塞 10s

// 进程 2
$redis->lPush('key1', 'A')

// 进程 1
// 返回 array('key1', 'A')

    bRPopLPush

    rPopLPush的阻塞版本，第三个参数为等待超时时间

    参数

    srcKey: string
    dstKey: string
    timeout: int 超时时间

    返回值

    string/boolean: 返回被移除的元素，等待超时则返回FALSE

    lIndex, lGet

    返回列表中，指定位置的元素

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

    如果key未指向列表，或索引值无效，返回FALSE

    参数

    key: string
    index: int

    返回值

    string/boolean: 返回指定索引处的元素。如果索引对应的元素不存在，或非字符串类型，返回FALSE

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

    在列表的元素前或者后插入元素

    当列表不存在，或指定元素不存在与列表中时，不执行任何操作

    参数

    key: string
    position: string Redis::BEFORE | Redis::AFTER
    pivot: string
    value: string

    返回值

    int: 返回插入操作完成之后，列表的长度。如果没有找到指定元素，返回 -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

    移出并获取列表的第一个元素

    参数

    key: string

    返回值

    string/boolean: 返回列表的第一个元素，失败时(空列表)返回FALSE

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

    lPush

    将一个或多个值插入到列表头部。如果key不存在，一个空列表会被创建并执行lPush操作。当key存在但不是列表类型时，返回FALSE

    参数

    key: string
    value: string 要插入到列表中的字符串

    返回值

    int: 返回执行插入操作后，列表的长度。失败时返回FALSE

    示例
    $redis->delete('key1');
$redis->lPush('key1', 'C'); // 返回 1
$redis->lPush('key1', 'B'); // 返回 2
$redis->lPush('key1', 'A'); // 返回 3
// key1 现在指向列表: ['A', 'B', 'C']

    lPushX

    将一个值插入到已存在的列表头部

    参数

    key: string
    value: string 要插入到列表中的字符串

    返回值

    int: 返回执行插入操作后，列表的长度。失败时返回FALSE

    示例
    $redis->delete('key1');
$redis->lPushX('key1', 'A'); // 返回 0
$redis->lPush('key1', 'A'); // 返回 1
$redis->lPushX('key1', 'B'); // 返回 2
$redis->lPushX('key1', 'C'); // 返回 3
// key1 现在指向列表: ['A', 'B', 'C']

    lRange, lGetRange

    返回列表中指定区间内的元素，区间以偏移量start和end指定。
    其中 0 表示列表的第一个元素， 1 表示列表的第二个元素...
    以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素...

    参数

    key: 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')

    lRem, lRemove

    根据参数count的值，移除列表中与参数value相等的元素。
    如果count = 0，移除表中所有与value相等的值；
    如果count < 0，从表尾开始向表头搜索，移除与value相等的元素，数量为count的绝对值；
    如果count > 0，从表头开始向表尾搜索，移除与value相等的元素，数量为count

    参数

    key: string
    value: string
    count: int

    返回值

    int/boolean: 返回被移除元素的数量。列表不存在时返回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

    通过索引设置列表元素的值

    参数

    key: string
    index: int
    value: string

    返回值

    boolean: 操作成功返回TRUE。如果索引超出范围，或者key不指向列表，返回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

    对一个列表进行修剪(trim)，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除

    参数

    key: string
    start: int
    stop: int

    返回值

    array: 返回列表中剩余元素组成的数组。如果key值不是列表，返回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')

    rPop

    移除并获取列表最后一个元素

    参数

    key: string

    返回值

    string: 返回被移除的元素。失败(列表为空)返回FALSE

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

    rPopLPush

    移除列表的最后一个元素，并将该元素添加到另一个列表并返回

    参数

    srcKey: string
    dstKey: string

    返回值

    string: 返回被移除的元素。失败返回FALSE

    示例
    $redis->delete('x', 'y');

$redis->lPush('x', 'abc');
$redis->lPush('x', 'def');
$redis->lPush('y', '123');
$redis->lPush('y', '456');

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

    将一个或多个值插入到列表的尾部(最右边)，如果列表不存在，一个空列表会被创建并执行rPush操作。 当列表存在但不是列表类型时，返回FALSE

    参数

    key: string
    value: string 要插入到列表的字符串

    返回值

    int: 执行插入操作后，列表的长度。失败返回FALSE

    示例
    $redis->delete('key1');
$redis->rPush('key1', 'A'); // 返回 1
$redis->rPush('key1', 'B'); // 返回 2
$redis->rPush('key1', 'C'); // 返回 3
// key1 => ['A', 'B', 'C']

    rPushX

    将一个值插入到已存在的列表尾部(最右边)。失败返回FALSE

    参数

    key: string
    value: string 要插入到列表的字符串

    返回值

    int: 执行插入操作后，列表的长度。失败返回FALSE

    示例
    $redis->delete('key1');
$redis->rPushX('key1', 'A'); // 返回 0
$redis->rPush('key1', 'A'); // 返回 1
$redis->rPushX('key1', 'B'); // 返回 2
$redis->rPushX('key1', 'C'); // 返回 3
// key1 => ['A', 'B', 'C']

    lLen, lSize

    返回列表的长度。
    如果列表key不存在或为空列表，返回 0 。如果key不是列表类型，返回FALSE

    参数

    Key: string

    返回值

    int: 返回列表的长度。如果key不是列表，返回FALSE

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

    Redis 集合

    • sAdd - 向集合添加一个或多个成员
    • sCard, sSize - 获取集合的成员数
    • sDiff - 返回给定所有集合的差集
    • sDiffStore - 返回给定所有集合的差集并存储在key中
    • sInter - 返回给定所有集合的交集
    • sInterStore - 返回给定所有集合的交集并存储在key中
    • sIsMember, sContains - 判断元素是否是集合的成员
    • sMembers, sGetMembers - 返回集合中的所有成员
    • sMove - 将元素从一个集合移动到另一个集合
    • sPop - 移除并返回集合中的一个或多个随机元素
    • sRandMember - 返回集合中一个或多个随机元素
    • sRem, sRemove - 移除集合中一个或多个成员
    • sUnion - 返回所有给定集合的并集
    • sUnionStore - 所有给定集合的并集存储在key集合中
    • sScan - 迭代集合中的元素

    sAdd

    将一个或多个成员元素加入到集合中。如果元素已存在于集合中，返回FALSE

    参数

    key: string
    value: string

    返回值

    int: 返回被添加到集合中的新元素的数量

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

    sCard, sSize

    返回集合中元素的数量

    参数

    key: string

    返回值

    int: 返回集合中元素的数量。 当集合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

    返回给定集合之间的差集

    参数

    Keys: string key, key2, ..., keyN 指向集合的任意数量的key

    *返回值`

    array: 第一个集合与其他所有集合差集元素组成的数组

    示例
    $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'));
/*
返回所有存在于 s0，但既不存在于 s1 也不存在于 s2 中的元素
array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}
*/

    sDiffStore

    将给定集合之间的差集存储在指定的集合中

    参数

    dstKey: string 用于存储差集的key
    keys: string key1, key2, ..., keyN 指向集合的任意数量的key

    返回值

    int: 返回差集中的元素数量。如果某个key不存在，返回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'));
/*
返回所有存在于 s0，但既不存在于 s1 也不存在于 s2 中的元素
int(2)
array(2) {
  [0]=>
  string(1) "4"
  [1]=>
  string(1) "2"
}
*/

    sInter

    返回给定所有给定集合的交集

    当给定集合当中有一个空集时，结果也为空集。如果某个key不存在，返回FALSE

    参数

    keys: string key1, key2, ..., keyN: string，指向集合的任意数量的key

    返回值

    array: 返回交集成员组成的数组。如果交集为空，返回空数组

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

    将给定集合之间的交集存储在指定的集合中

    参数

    dstKey: string 用于存储交集的key
    keys: string key, key2, ..., keyN 指向集合的任意数量的key

    返回值

    int: 返回存储交集的集合的元素数量。如果某个key不存在，返回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

    判断成员元素是否是集合的成员

    参数

    key: string
    value: string

    返回值

    boolean: 如果元素是集合的成员，返回TRUE。否则返回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

    返回集合中的所有的成员

    参数

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

    顺序随机，对应于Redis集合内部的排序

    sMove

    将指定元素从当前集合移动到目标集合

    参数

    srcKey: string
    dstKey: string
    member: string

    返回值

    boolean: 操作成功返回TRUE。如果当前key或目标key不存在，或元素不存在于当前key中，返回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: string
    count: int 可选

    返回值（不传递count参数）

    string/boolean: 被移除的元素。集合不存在或为空，返回FALSE

    返回值（传递count参数）

    array/boolean: 被移除元素组成的数组。集合不存在时，返回空数组。key不是集合，返回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'}

// 传递 count 参数
$redis->sAdd('key2', 'member1', 'member2', 'member3');
$redis->sPop('key2', 3); // 返回所有成员，顺序随机

    sRandMember

    返回集合中的一个随机元素

    参数

    key: string
    count: int 可选

    返回值

    string/array/boolean:
    不提供count参数：返回一个随机元素(String)。
    提供count参数：如果count为正数，且小于集合基数，返回一个包含count个元素的数组，数组中的元素各不相同。如果count大于等于集合基数，那么返回整个集合。如果count为负数，返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为count的绝对值。集合不存在，返回FALSE

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

// 无 count 参数
$redis->sRandMember('key1'); // 'member1', key1 => {'member3', 'member1', 'member2'}
$redis->sRandMember('key1'); // 'member3', key1 => {'member3', 'member1', 'member2'}

// 有 count 参数
$redis->sRandMember('key1', 3); // 返回集合所有元素组成的数组
$redis->sRandMember('key1', 2); // 返回集合中 2 个元素组成的数组
$redis->sRandMember('key1', -100); // 返回 100 个元素组成的数
$redis->sRandMember('empty-set', 100); // 返回空数组
$redis->sRandMember('not-a-set', 100); // 返回 FALSE

    sRem, sRemove

    移除集合中的一个或多个成员元素，不存在的成员元素会被忽略

    参数

    key: string
    member: string

    返回值

    int: 返回被成功移除的元素的数量

    示例
    $redis->sAdd('key1', 'member1');
$redis->sAdd('key1', 'member2');
$redis->sAdd('key1', 'member3'); // key1 => {'member1', 'member2', 'member3'}
$redis->sRem('key1', 'member2', 'member3'); // 返回 2, key1 => {'member1'}

    sUnion

    返回给定集合的并集。不存在的集合key被视为空集

    参数

    Keys: string key, key2, ..., keyN 任意数量指向集合的key

    返回值

    array: 并集成员组成的数组

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

    将给定集合的并集存储在指定的集合key中

    参数

    dstKey: string 用于存储并集的key
    Keys: string key, key2, ..., keyN 任意数量指向集合的key

    返回值

    int: 返回结果集中的元素数量。某个key不存在则返回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: string 待迭代的key
    iterator: int (引用) 迭代次数
    pattern: string 可选，匹配模式
    count: int 每次迭代返回的元素数量

    返回值

    array/boolean: 返回元素数组或者FALSE

    示例
    $it = NULL;
$redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY); // 迭代完成前，不要返回空值
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_RETRY); // 每次迭代都返回结果，无论结果是否为空
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";
    }
}

    Redis 有序集和

    • zAdd - 向有序集合添加一个或多个成员，或者更新已存在成员的分数
    • zCard, zSize - 获取有序集合的成员数
    • zCount - 计算在有序集合中指定区间分数的成员数
    • zIncrBy - 有序集合中对指定成员的分数加上增量
    • zInter - 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合中
    • zRange - 通过索引区间返回有序集合成指定区间内的成员
    • zRangeByScore, zRevRangeByScore - 通过分数返回有序集合指定区间内的成员
    • zRangeByLex - 通过字典区间返回有序集合的成员
    • zRank, zRevRank - 返回有序集合中指定成员的索引
    • zRem, zDelete - 移除有序集合中的一个或多个成员
    • zRemRangeByRank, zDeleteRangeByRank - 移除有序集合中给定的排名区间的所有成员
    • zRemRangeByScore, zDeleteRangeByScore - 移除有序集合中给定的分数区间的所有成员
    • zRevRange - 返回有序集中指定区间内的成员，通过索引，分数从高到底
    • zScore - 返回有序集中，成员的分数值
    • zUnion - 计算给定的一个或多个有序集的并集，并存储在新的有序集合中
    • zScan - 迭代有序集合中的元素（包括元素成员和元素分值）

    zAdd

    向有序集合添加一个或多个成员，或者更新已存在成员的分数

    参数

    key: string
    score: double
    value: string

    返回值

    int: 成员添加成功返回 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

    计算集合中元素的数量

    参数

    key: string

    返回值

    int: 返回有序集的基数

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

    zCount

    计算有序集合中指定分数区间的成员数量

    参数

    key: string
    start: float
    end: float

    返回值

    int: 分数值在指定间的成员的数量

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

    zIncrBy

    对有序集合中指定成员的分数加上增量

    参数

    key: string
    value: float 分数的增量
    member: string

    返回值

    float: 返回成员的新分数值

    示例
    $redis->delete('key');
$redis->zIncrBy('key', 2.5, 'member1'); // key 或 member1 不存在，member1 的分数被初始化为 0。现在 member1 的分数为 2.5
$redis->zIncrBy('key', 1, 'member1'); // 3.5

    zInter

    参数

    keyOutput: string
    ZSetKeys: array
    Weights: array 可选，权重，聚合操作之前，集合中所有元素的分数值先乘上权重
    aggregateFunction: string 可选，SUM或MIN或MAX，定义如何计算结果集中某个成员的分数值

    返回值

    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', ['k1', 'k2']); // 2, ko1 => array('val1', 'val3')
$redis->zInter('ko2', ['k1', 'k2'], [1, 1]); // 2, ko2 => array('val1', 'val3')

// 使用 Weights 参数
$redis->zInter('ko3', ['k1', 'k2'], [1, 5], 'min'); // 2, ko3 => array('val1', 'val3')
$redis->zInter('ko4', ['k1', 'k2'], [1, 5], 'max'); // 2, ko4 => array('val3', 'val1')

    zRange

    通过索引区间返回有序集合成指定区间内的成员

    下标参数start和stop都以0为底，0表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
    以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

    参数

    key: string
    start: int
    end: int
    withscores: bool 默认FALSE

    返回值

    array: 指定区间内，带有分数值(可选)的有序集成员的列表

    示例
    $redis->zAdd('key1', 0, 'val0');
$redis->zAdd('key1', 2, 'val2');
$redis->aAdd('key1', 10, 'val10');
$redis->zRange('key1', 0, -1); // array('val0', 'val2', 'val10')

// 带上分值
$redis->zRange('key1', 0, -1, true); // array('val0' => 0, 'val2' => 2, 'val10' => 10)

    zRangeByScore, zRevRangeByScore

    返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大，zRevRangeByScore为从大到小)次序排列

    参数

    key: string
    start: string
    end: string
    options: array 有两种可用options: withscores => TRUE和limit => array($offset, $count)

    返回值

    array: 指定区间内，带有分数值(可选)的有序集成员的列表

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

    zRangeByLex

    通过字典区间返回有序集合的成员
    min和max参数必须以(、[开头，或者为-和+。
    必须使用三个或五个参数调用该方法，否则将返回FALSE

    参数

    key: string
    min: string
    max: string
    offset: int 可选，起始位置
    limit: int 可选，返回元素的个数

    返回值

    array: 指定区间内的元素列表

    示例
    foreach (['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->zRangeByLext('key', '-', '[c', 1, 2); // array('b', 'c')

    zRange, zRevRank

    返回有序集中指定成员的排名，排名以 0 开始。其中有序集成员按分数值递增(从小到大，zRevRank有大到小)顺序排列

    参数

    key: string
    member: string

    返回值

    int: 元素在集合中的排名

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

    移除有序集合中的一个或多个成员

    参数

    key: string
    member: string

    返回值

    int: 成功返回 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

    移除有序集合中给定的排名区间的所有成员

    参数

    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, ['withscores' => TRUE]); // array('three' => 3)

    zRemRangeByScore, zDeleteRangeByScore

    移除有序集合中给定的分数区间的所有成员

    参数

    key: string
    start: float/string
    end: float/string

    返回值

    int: 被移除成员的数量

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

    zRevRange

    返回有序集中指定区间内的成员，通过索引，分数从高到底
    下标参数start和stop都以0为底，0表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
    以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推

    参数

    key: string
    start: int
    end: int
    withscores: bool 默认FALSE

    返回值

    array: 指定区间内，带有分数值(可选)的有序集成员的列表

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

// 带分数值
$redis->zRevRange('key', 0, -1, true); // array('val10' => 10, 'val2' => 2, 'val0' => 0)

    zScore

    返回有序集中，成员的分数值

    参数

    key: string
    member: string

    返回值

    float

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

    zUnion

    计算给定的一个或多个有序集的并集，并存储在新的key中

    参数

    keyOutput: string
    ZSetKeys: array
    Weights: array 权重，聚合操作之前，集合的所有元素分数值乘上权重
    aggregateFunction: string SUM、MIN或MAX，定义如何计算结果集中某个成员的分数值

    返回值

    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', ['k1', 'k2']); // 4, ko1 => array('val0', 'val1', 'val2', 'val3')

// 使用 Weights 参数
$redis->zUnion('ko2', ['k1', 'k2'], [1, 1]); // 4, ko2 => array('val0', 'val1', 'val2', 'val3')
$redis->zUnion('ko3', ['k1', 'k2'], array(5, 1)); // 4, ko3 => array('val0', 'val2', 'val3', 'val1')

    zScan

    迭代有序集合中的元素（包括元素成员和元素分值）

    参数

    key: string
    iterator: int 迭代次数的引用，初始值为 0
    pattern: string 可选，匹配模式

    返回值

    array/boolean: 返回符合匹配模式的元素集合，迭代完成时返回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";
    }
}
    phpredis
    本文系翻译，阅读原文
    https://github.com/phpredis/phpredis
    dejavu
    84 声望5 粉丝
    « 上一篇
    Phalcon模型
    下一篇 »
    Phalcon控制器

    引用和评论

    推荐阅读
    头像
    Phalcon控制器

    dejavu阅读 3.6k

    头像
    如何实现一个楼中楼的评论系统

    小蚊酱赞 23阅读 10.1k

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 7阅读 1.2k

    头像
    Just for fun——迅速写完快速排序

    ufdf赞 3阅读 2.5k

    头像
    Swoole 协程是否支持 PHP 的 JIT ？

    韩天峰赞 4阅读 688

    头像
    PHPy 实践：从 Python 脚本到 PHP 应用的无缝衔接

    汤青松赞 3阅读 1.2k

    头像
    这些年

    注销赞 2阅读 3.9k

    0 条评论
    得票最新