Redis 命令 II

必备技能 阅读量

Redis 命令记录

string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/**
 * Redis-字符串
 * @Post("/test_string")
 */
public function test_string()
{
    // 如果 key 已经持有其他值， SET 就覆写旧值， 无视类型
    $this->redis->set('key_set', 'value_set', 3600);

    // 只在键 key 不存在的情况下， 将键 key 的值设置为 value;命令在设置成功时返回 1 ， 设置失败时返回 0 。
    $this->redis->setnx('key_setnx', 'value_setnx');

    // 将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds `秒` 钟。
    $this->redis->setex('key_setex', 3600, 'value_setex');

    // 这个命令和 SETEX 命令相似， 但它以 `毫秒` 为单位设置 key 的生存时间， 而不是像 SETEX 命令那样以秒为单位进行设置。
    $this->redis->psetex('key_psetex', 3600, 'value_psetex');

    // 如果键 key 不存在， 那么返回特殊值 nil ； 否则， 返回键 key 的值。
    $this->redis->get('key_set');

    // 将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值;
    // 如果键 key 没有旧值， 也即是说， 键 key 在被设置之前并不存在， 那么命令返回 nil 。
    $this->redis->getSet('key_get_set', 'value_get_set');

    // 返回键 key 储存的字符串值的长度; 当键 key 不存在时， 命令返回 0 ;当 key 储存的不是字符串值时， 返回一个错误。
    $this->redis->strlen('key_set');

    // 如果键 key 已经存在并且它的值是一个字符串， APPEND 命令将把 value 追加到键 key 现有值的末尾。
    // 如果 key 不存在， APPEND 就简单地将键 key 的值设为 value ， 就像执行 SET key value 一样。
    $this->redis->append('key_set', 'value_append');

    // 从偏移量 offset 开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。
    $this->redis->setRange('key_range', 0, 'value_range');

    // 返回键 key 储存的字符串值的指定部分， 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。
    $this->redis->getRange('key_range', 0, 1000);

    // 为键 key 储存的数字值加上一;如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。
    // 如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。
    $this->redis->incr('key_incr');

    // 为键 key 储存的数字值加上增量 increment 。
    $this->redis->incrBy('key_incr_by', 10);

    // 为键 key 储存的值加上浮点数增量 increment 。
    // 如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。
    $this->redis->incrByFloat('key_incr_by', '10.24');

    // 为键 key 储存的数字值减去一。
    $this->redis->decr('key_decr');

    // 将键 key 储存的整数值减去减量 decrement
    $this->redis->decrBy('key_decr', 10);

    // 同时为多个键设置值。如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值
    $this->redis->mset([
        'key_mset_1' => 'value_mset_1',
        'key_mset_2' => 'value_mset_2',
    ]);

    // 当且仅当所有给定键都不存在时， 为所有给定键设置值。
    // 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。
    $this->redis->msetnx([
        'key_mset_1' => 'value_mset_1',
        'key_mset_2' => 'value_mset_2',
    ]);

    // 返回给定的一个或多个字符串键的值。
    // 如果给定的字符串键里面， 有某个键不存在， 那么这个键的值将以特殊值 nil 表示。
    $this->redis->mget(['key_mset_1','key_mset_2']);
}

hash

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * Redis-哈希表
 * @Post("/test_hash")
 */
public function test_hash()
{
    // 将哈希表 hash 中域 field 的值设置为 value 。
    // 如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。
    $this->redis->hSet('key_hset', 'hashKey', 'value_hset');

    // 当且仅当域 field 尚未存在于哈希表的情况下， 将它的值设置为 value 。
    // 如果给定域已经存在于哈希表当中， 那么命令将放弃执行设置操作。
    $this->redis->hSetNx('key_hsetnx', 'hashKey', 'value_hsetnx');

    // 返回哈希表中给定域的值。
    $this->redis->hGet('key_hset', 'hashKey');

    // 检查给定域 field 是否存在于哈希表 hash 当中。
    // HEXISTS 命令在给定域存在时返回 1 ， 在给定域不存在时返回 0 。
    $this->redis->hExists('key_hset', 'hashKey');

    // 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
    $this->redis->hDel('key_hdel', 'hashKey', 'hashKey2');

    // 返回哈希表 key 中域的数量。
    $this->redis->hLen('key_hset');

    // 返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）。
    // $this->redis->hstrlen()

    // 为哈希表 key 中的域 field 的值加上增量 increment 。
    // 增量也可以为负数，相当于对给定域进行减法操作。
    $this->redis->hIncrBy('key_hincr', 'hashKey', 'value_hincr');

    // 为哈希表 key 中的域 field 加上浮点数增量 increment 。
    $this->redis->hIncrByFloat('hashKey', 'key_hincr', 10.24);

    // 同时将多个 field-value (域-值)对设置到哈希表 key 中。
    $this->redis->hMSet('key_hmset', [
        'hashKey1' => 'hashValue1',
        'hashKey2' => 'hashValue2'
    ]);

    // 返回哈希表 key 中，一个或多个给定域的值。
    $this->redis->hMGet('key_hmset', ['hashKey1', 'hashKey2']);

    // 返回哈希表 key 中的所有域。
    $this->redis->hKeys('hashKey');

    // 返回哈希表 key 中所有域的值。
    $this->redis->hVals('key_hset');

    // 返回哈希表 key 中，所有的域和值。
    // 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
    $this->redis->hGetAll('key_hset');

    // 用于迭代哈希键中的键值对。
    $this->redis->hScan('key_hset', '', '', '');
}

list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/**
 * Redis-列表
 * @Post("/test_list")
 */
public function test_list()
{
    // 将一个或多个值 value 插入到列表 key 的表头
    $this->redis->lPush('key_lpush', 'value_1', 'value_2');

    // 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
    // 当 key 不存在时， LPUSHX 命令什么也不做。
    $this->redis->lPushx('key_lpush', 'value_3');

    // 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
    $this->redis->rPush('key_rpush', 'value_1', 'value_2');

    // 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
    $this->redis->rPushx('key_rpush', 'value_3');

    // 移除并返回列表 key 的头元素。列表的头元素。 当 key 不存在时，返回 nil 。
    $this->redis->lPop('key_lpush');

    // 移除并返回列表 key 的尾元素。列表的尾元素。 当 key 不存在时，返回 nil 。
    $this->redis->rPop('key_rpush');

    // 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
    // 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
    $this->redis->rpoplpush('key_src', 'key_dst');

    // 根据参数 count 的值，移除列表中与参数 value 相等的元素。
    // count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
    // count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
    // count = 0 : 移除表中所有与 value 相等的值。
    $this->redis->lRem('key_lrem', 3, 0);

    // 返回列表 key 的长度。如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
    $this->redis->lLen('key_lpush');

    // 返回列表 key 中，下标为 index 的元素。
    $this->redis->lIndex('key_lpush', 3);

    // 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
    // 当 pivot 不存在于列表 key 时，不执行任何操作。
    $this->redis->lInsert('key_lpush', 0, 1, 'value_lpush');

    // 将列表 key 下标为 index 的元素的值设置为 value 。
    $this->redis->lSet('key_lset', 0, 'value_lset');

    // 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
    $this->redis->lRange('key_lrange', 0, 100);

    // 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
    $this->redis->lTrim('key_ltrim', 0, 100);

    // BLPOP 是列表的阻塞式(blocking)弹出原语。
    // 它是 LPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
    $this->redis->blPop(['key_blpop'], 3600);

    // BRPOP 是列表的阻塞式(blocking)弹出原语。
    // 它是 RPOP key 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
    $this->redis->brPop(['key_brpop'], 3600);

    // BRPOPLPUSH 是 RPOPLPUSH source destination 的阻塞版本
    $this->redis->brpoplpush('key_src', 'key_dst', 3600);
}

set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/**
 * Redis-集合
 * @Post("/test_set")
 */
public function test_set()
{
    // 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
    $this->redis->sAdd('key_sadd', 'value_sadd');

    // 判断 member 元素是否集合 key 的成员。
    // 如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。
    $this->redis->sIsMember('key_sadd', 'value_sadd');

    // 移除并返回集合中的一个随机元素。
    $this->redis->sPop('key_spop');

    // 如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素
    // 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
    // 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
    $this->redis->sRandMember('key_srand', 1);

    // 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
    // 被成功移除的元素的数量，不包括被忽略的元素。
    $this->redis->sRem('key_sadd', 'value_sadd', 'value_sadd2');

    // 将 member 元素从 source 集合移动到 destination 集合。
    $this->redis->sMove('key_src', 'key_dst', 'value_sadd');

    // 返回集合 key 的基数(集合中元素的数量)。集合的基数。 当 key 不存在时，返回 0 。
    $this->redis->sCard('key_scard');

    // 返回集合 key 中的所有成员。不存在的 key 被视为空集合。集合中的所有成员。
    $this->redis->sMembers('key_smembers');

    // SSCAN 命令用于迭代集合键中的元素。
    $this->redis->sScan('key_sscan', '', '', '');

    // 返回一个集合的全部成员，该集合是所有给定集合的交集。
    // 不存在的 key 被视为空集。
    $this->redis->sInter('key_sinter', 'key_sinter_2');

    // 这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    // 如果 destination 集合已经存在，则将其覆盖。
    $this->redis->sInterStore('key_dst', 'key_sinter', 'key_sinter_2');

    // 返回一个集合的全部成员，该集合是所有给定集合的并集。不存在的 key 被视为空集。
    $this->redis->sUnion('key_sunion', 'key_sunion_2');

    // 这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    // 如果 destination 已经存在，则将其覆盖。destination 可以是 key 本身。
    $this->redis->sUnionStore('key_dst', 'key_sunion', 'key_sunion_2');

    // 返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集; 一个包含差集成员的列表。
    $this->redis->sDiff('key_sdiff', 'key_sdiff_2');

    // 这个命令的作用和 SDIFF key [key …] 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    // 如果 destination 集合已经存在，则将其覆盖。结果集中的元素数量
    $this->redis->sDiffStore('key_dst', 'key_sdiff', 'key_sdiff_2');
}

zset

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/**
 * Redis-有序集合
 * @Post("/test_zset")
 */
public function test_zset()
{
    // 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
    // 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
    $this->redis->zAdd('key_zadd', 'score_1', 'value_zadd');

    // 返回有序集 key 中，成员 member 的 score 值。
    $this->redis->zScore('key_zadd', 'value_zadd');

    // 为有序集 key 的成员 member 的 score 值加上增量 increment 。
    $this->redis->zIncrBy('key_zincr', 1, 'value_zadd');

    // 返回有序集 key 的基数。当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。
    $this->redis->zCard('key_zadd');

    // 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
    $this->redis->zCount('key_zadd', 0, 100);

    // 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从小到大)来排序。
    $this->redis->zRange('key_zadd', 0, 100);

    // 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递减(从大到小)来排列
    $this->redis->zRevRange('key_zadd', 0, 100);

    // 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
    $this->redis->zRangeByScore('key_zadd', 0, 100);

    // 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
    $this->redis->zRemRangeByScore('key_zadd', 0, 100);

    // 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
    $this->redis->zRank('key_zadd', 'value_zadd');

    // 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。
    $this->redis->zRevRank('key_zadd', 'value_zadd');

    // 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
    // 被成功移除的成员的数量，不包括被忽略的成员。
    $this->redis->zRem('key_zadd', 'value_zadd', 'value_zadd_2');

    // 移除有序集 key 中，指定排名(rank)区间内的所有成员。
    $this->redis->zRemRangeByRank('key_zadd', 0, 100);

    // 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
    $this->redis->zRemRangeByScore('key_zadd', 0, 100);

    // 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员。
    $this->redis->zRangeByLex('key_zadd', 0, 100);

    // 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量。
    // $this->redis->zLexCount();

    // 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会移除该集合中， 成员介于 min 和 max 范围内的所有元素。
    $this->redis->zRevRangeByLex('key_zadd', 0, 100);

    // 命令用于迭代有序集合中的元素（包括元素成员和元素分值）。
    $this->redis->zScan('key_zadd', '', '', '');

    // 计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。
    $this->redis->zUnion('key_zunion', ['key_zsets', 'key_zsets_2'], '', '');
}

key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
 * Redis-数据库
 * @Post("/test_redis_database")
 */
public function test_redis_database()
{
    // 检查给定 key 是否存在。若 key 存在，返回 1 ，否则返回 0 。
    $this->redis->exists('key');

    // 返回 key 所储存的值的类型。
    // none:key不存在; string:字符串; list:列表; set:集合; zset:有序集合; hash:哈希表; stream:流;
    $this->redis->type('key');

    // 将 key 改名为 newkey 。改名成功时提示 OK ，失败时候返回一个错误。
    $this->redis->rename('key', 'key_new');

    // 当且仅当 newkey 不存在时，将 key 改名为 newkey 。
    // 修改成功时，返回 1 ； 如果 newkey 已经存在，返回 0 。
    $this->redis->renameNx('key', 'key_new');

    // 将当前数据库的 key 移动到给定的数据库 db 当中。移动成功返回 1 ，失败则返回 0 。
    // 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
    // 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
    $this->redis->move('key', 'db_index');

    // 删除给定的一个或多个 key 。被删除 key 的数量。
    $this->redis->del('key');

    // 从当前数据库中随机返回(不删除)一个 key
    // 当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil 。
    $this->redis->randomKey();

    // 返回当前数据库的 key 的数量。
    $this->redis->dbSize();

    // 查找所有符合给定模式 pattern 的 key ， 比如说：
    // KEYS * 匹配数据库中所有 key 。
    $this->redis->keys('key*');

    // SCAN 命令及其相关的 SSCAN 命令、 HSCAN 命令和 ZSCAN 命令都用于增量地迭代（incrementally iterate）一集元素（a collection of elements）：
    $this->redis->scan('', '', '');

    // 返回或保存给定列表、集合、有序集合 key 中经过排序的元素。
    $this->redis->sort('key', 'desc');

    // 清空当前数据库中的所有 key。此命令从不失败。总是返回 OK 。
    $this->redis->flushDB();

    // 清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。此命令从不失败。总是返回 OK 。
    $this->redis->flushAll();

    // 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。默认使用 0 号数据库。
    $this->redis->select('db_index');

    // 对换指定的两个数据库， 使得两个数据库的数据立即互换。
    // $this->redis->swapdb();
}

Powered by Hexo and Hexo-theme-hiker

Copyright © 2017 - 2023 Keep It Simple And Stupid All Rights Reserved.

访客数 : | 访问量 :