Interface RedisClient

如果键 key 已经存在并且它的值是一个字符串， APPEND 命令将把 value 追加到键 key 现有值的末尾。

如果 key 不存在， APPEND 就简单地将键 key 的值设为 value ， 就像执行 SET key value 一样。

为键 key 储存的数字值减去一。

将键 key 储存的整数值减去减量 decrement 。

删除给定的一个或多个 key

检查给定 key 是否存在。

存在返回 true， 失败返回 false

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。

可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。

设置成功返回 1 。 当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

返回与键 key 相关联的字符串值。

将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值。

返回给定键 key 的旧值。

如果键 key 没有旧值， 也即是说， 键 key 在被设置之前并不存在， 那么命令返回 nil 。

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略

检查给定域 field 是否存在于哈希表 hash 当中

返回哈希表中给定域的值。

返回哈希表 key 中，所有的域和值。

为哈希表 key 中的域 field 的值加上增量 increment

返回哈希表 key 中的所有域。

返回哈希表 key 中域的数量。

返回哈希表 key 中，一个或多个给定域的值。

同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。

哈希表的增量式迭代命令， 用于增量地迭代一个哈希表上的元素。

Example

import * as redis from 'redis';

let cli = redis.newClient("test");
let key = "hash_test_scan_1";

// 预置数据用于测试
// for (let i = 0; i < 2000; i++) {
//     cli.hset(key, `F:${i}`, `VBCCCCC_${i}`);
// }

// console.log(cli.hmset(key, { A: "A", B: "B", C: "C2", D: "D2" }));
console.log("no option", cli.hscan(key, 0));
console.log("empty option", cli.hscan(key, 0, {}));
console.log("count 5", cli.hscan(key, 0, { match: "F:1*", count: 5 }));


// scan all
let pattern = "F:1*";
let count = 100;

console.log("scan all with iteration ", hscan(key, count, pattern));
console.log("scan all with iteration ", hscan(key, 50, pattern));

functionhscan: (key: string, count: number, pattern: string) => number {
   let cursor = 0;
   let iter = 1;
   let m = {}
   while (true) {
       console.log("iteration ", iter, "cursor ", cursor);
       let res = cli.hscan(key, cursor, { match: pattern, count: count });
       // 仅用于检查是否会出现重复，按cursor迭代不会出现重复。
       for (let k in res.hash) {
           if (m[k]) {
               throw new Error(`duplicated hash field ${k}`);
           }
           m[k] = res.hash[k];
           console.log(k, " => ", res.hash[k]);
       }
       // 如果 cursor 为 0 代表已经遍历完了整个数据集
       if (res.cursor == 0) {
           // console.log("end with iteration ", iter);
           console.log("all fields ", Object.keys(m).length)
           return iter;
       }
       iter++;
       cursor = res.cursor;
   }
}

Copy

将哈希表 hash 中域 field 的值设置为 value

当且仅当域 field 尚未存在于哈希表的情况下， 将它的值设置为 value

返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度（string length）

返回哈希表 key 中所有域的值。

为键 key 储存的数字值加上 1

为键 key 储存的数字值加上增量 increment

返回列表 key 中，下标为 index 的元素。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

如果 key 不是列表类型，返回一个错误。

返回列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil

将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

当 pivot 不存在于列表 key 时，不执行任何操作。

当 key 不存在时， key 被视为空列表，不执行任何操作。

如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0

返回列表 key 的长度。

如果 key 不存在，则 key 被解释为一个空列表，返回 0 .

如果 key 不是列表类型，返回一个错误。

移除并返回列表 key 的头元素。

列表的头元素。 当 key 不存在时，返回 nil 。

将一个或多个值 value 插入到列表 key 的表头

如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作

返回执行 LPUSH 命令后，列表的长度。

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。

和 lpush 命令相反，当 key 不存在时， LPUSHX 命令什么也不做

返回 LPUSHX 命令执行之后，表的长度。

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

返回一个列表，包含指定区间内的元素。

根据参数 count 的值，移除列表中与参数 value 相等的元素 count 的值可以是以下几种：

1. count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。

2. count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。

3. count = 0 : 移除表中所有与 value 相等的值。

返回被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

将列表 key 下标为 index 的元素的值设置为 value 。

当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

操作成功返回 ok ，否则返回错误信息。

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

下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

命令执行成功时，返回 ok

移除并返回列表 key 的尾元素。

返回列表的尾元素。 当 key 不存在时，返回 nil 。

命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

1. 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
2. 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。

如果 source 不存在，值 nil 被返回，并且不执行其他动作。

如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

注意， 如果redis是集群模式的，source 与 destination 必须是同一个分片下的。 可以通过添加花括号的方式， 如{key}1 {key}2 模式来的保证。

返回被弹出的元素

将一个或多个值 value 插入到列表 key 的表尾(最右边)。

如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。

返回执行 RPUSH 操作后，表的长度。

将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。

和 rpush命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

返回 RPUSHX 命令执行之后，表的长度

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略

假如 key 不存在，则创建一个只包含 member 元素作成员的集合。

当 key 不是集合类型时，返回一个错误。

返回被添加到集合中的新元素的数量，不包括被忽略的元素。

返回集合 key 的基数(集合中元素的数量)。

返回一个集合的全部成员，该集合是所有给定集合之间的差集。

这个命令的作用和 sdiff类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 集合已经存在，则将其覆盖。

返回结果集中的元素数量。

返回一个集合的全部成员，该集合是所有给定集合的交集

这个命令类似于 sinter命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 集合已经存在，则将其覆盖。

返回结果集中的成员数量。

判断 member 元素是否集合 key 的成员。

如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

返回集合 key 中的所有成员。

将 member 元素从 source 集合移动到 destination 集合, SMOVE 是一个原子操作。

如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。 否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。

当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

如果 member 元素被成功移除，返回 1 。 如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

注意如果是 redis 集群的话， source 与 destination 必须在同一个分片上。

移除并返回集合中的一个随机元素。

如果命令执行时，只提供了 key 参数，那么返回集合中的一个随机元素。

count 参数：

如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。

如果 count 大于等于集合基数，那么返回整个集合。

如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

如果集合为空，返回空数组。

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

返回被成功移除的元素的数量，不包括被忽略的元素。

集合的增量式迭代命令， 用于增量地迭代一个集合上的元素。

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

返回一个集合的全部成员，该集合是所有给定集合的并集。

这个命令类似于 sunion 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。

如果 destination 集合已经存在，则将其覆盖。

返回结果集中的元素数量

以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。

当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间。

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

返回被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

功能同 zadd

返回有序集 key 的基数

返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量.

为有序集 key 的成员 member 的 score 值加上增量 increment

member 成员的新 score 值，以字符串形式表示

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列

min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。

默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。

Example

import * as redis from 'redis';

let cli = redis.newClient("test");

console.log(cli.zrangebyscore("test_key", "(1", "5"));

Copy

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。

如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。

返回被成功移除的成员的数量，不包括被忽略的成员。

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。

返回被移除成员的数量

返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。 有序集成员按 score 值递减(从大到小)的次序排列。

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。

如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil

有序集合的增量式迭代命令， 用于增量地迭代一个有序集合上的元素。

返回有序集 key 中，成员 member 的 score 值。 如果 member 元素不是有序集 key 的成员，或 key 不存在，则报错