RedisClient Redis 客户端

参考自 [Redis Doc](http://redisdoc.com/)

## 字符串相关
- [x] SET: 通过 {@link StringClient.setEx}
- [ ] SETNX
- [ ] SETEX
- [ ] PSETEX
- [x] GET
- [x] GETSET
- [x] STRLEN
- [x] APPEND
- [ ] SETRANGE
- [ ] GETRANGE
- [x] INCR
- [x] INCRBY
- [ ] INCRBYFLOAT
- [x] DECR
- [x] DECRBY
- [ ] MSET
- [ ] MSETNX
- [ ] MGET

## 哈希表
- [x] HSET
- [x] HSETNX
- [x] HGET
- [x] HEXISTS
- [x] HDEL
- [x] HLEN
- [x] HSTRLEN
- [x] HINCRBY
- [ ] HINCRBYFLOAT
- [x] HMSET
- [x] HMGET
- [x] HKEYS
- [x] HVALS
- [x] HGETALL
- [x] HSCAN

## 列表
- [x] LPUSH
- [x] LPUSHX
- [x] RPUSH
- [x] RPUSHX
- [x] LPOP
- [x] RPOP
- [x] RPOPLPUSH
- [x] LREM
- [x] LLEN
- [x] LINDEX
- [x] LINSERT
- [x] LSET
- [x] LRANGE
- [x] LTRIM
- [ ] BLPOP: 暂不提供阻塞式的命令
- [ ] BRPOP: 暂不提供阻塞式的命令
- [ ] BRPOPLPUSH: 暂不提供阻塞式的命令

## 集合
- [x] SADD
- [x] SISMEMBER
- [x] SPOP
- [x] SRANDMEMBER
- [x] SREM
- [x] SMOVE
- [x] SCARD
- [x] SMEMBERS
- [x] SSCAN
- [x] SINTER
- [x] SINTERSTORE
- [x] SUNION
- [x] SUNIONSTORE
- [x] SDIFF
- [x] SDIFFSTORE

## 有序集合
- [x] ZADD
- [x] ZSCORE
- [x] ZINCRBY
- [x] ZCARD
- [x] ZCOUNT
- [x] ZRANGE
- [x] ZREVRANGE
- [x] ZRANGEBYSCORE
- [x] ZREVRANGEBYSCORE
- [x] ZRANK
- [x] ZREVRANK
- [x] ZREM
- [x] ZREMRANGEBYRANK
- [x] ZREMRANGEBYSCORE
- [ ] ZRANGEBYLEX
- [ ] ZLEXCOUNT
- [ ] ZREMRANGEBYLEX
- [x] ZSCAN
- [ ] ZUNIONSTORE
- [ ] ZINTERSTORE

## 数据库
- [x] EXISTS
- [ ] TYPE
- [ ] RENAME
- [ ] RENAMENX
- [ ] MOVE
- [x] DEL: 之前只支持删除一个,现在改成多个,且返回被删除的key的个数。
- [ ] RANDOMKEY
- [ ] DBSIZE
- [ ] KEYS
- [ ] SCAN
- [ ] SORT
- [ ] FLUSHDB
- [ ] FLUSHALL
- [ ] SELECT
- [ ] SWAPDB

## 自动过期
- [x] EXPIRE
- [ ] EXPIREAT
- [x] TTL
- [ ] PERSIST
- [ ] PEXPIRE
- [ ] PEXPIREAT
- [ ] PTTL

由于脚本引擎的特性,会将实参类型隐式转换成兼容的入参类型,因此引擎在执行过程中可以接受非严格匹配的类型,

如 string 类型的入参可以接受 number 类型的实参, 但该行为是不可靠的,请按照方法签名指定的类型来传参。

interface RedisClient {
    append: ((key, value) => number);
    decr: ((key) => number);
    decrBy: ((key, decrement) => void);
    del: ((...keys) => number);
    exists: ((key) => boolean);
    expire: ((key, seconds) => number);
    get: ((key) => string);
    getset: ((key, value) => string);
    hdel: ((key, ...fields) => number);
    hexists: ((key, field) => number);
    hget: ((key, field) => string);
    hgetAll: ((key) => "redis".StringDict);
    hincrby: ((key, field, increment) => number);
    hkeys: ((key) => string[]);
    hlen: ((key) => number);
    hmget: ((key, ...fields) => string[]);
    hmset: ((key, map) => string);
    hscan: ((key, cursor, opt?) => HScanResult);
    hset: ((key, field, value) => number);
    hsetnx: ((key, field, value) => number);
    hstrlen: ((key, field) => number);
    hvals: ((key) => string[]);
    incr: ((key) => number);
    incrBy: ((key, increment) => number);
    lindex: ((key, index) => string);
    linsert: ((key, pos, pivot, value) => number);
    llen: ((key) => number);
    lpop: ((key) => string);
    lpush: ((key, ...values) => number);
    lpushx: ((key, value) => number);
    lrange: ((key, start, stop) => string[]);
    lrem: ((key, count, value) => number);
    lset: ((key, index, value) => number);
    ltrim: ((key, start, stop) => string[]);
    pipeline: (() => RedisPipeliner);
    rpop: ((key) => string);
    rpoplpush: ((source, destination) => string);
    rpush: ((key, ...values) => number);
    rpushx: ((key, value) => number);
    sadd: ((key, ...members) => number);
    scard: ((key) => number);
    sdiff: ((...keys) => string[]);
    sdiffstore: ((destination, ...keys) => number);
    sinter: ((...keys) => string[]);
    sinterstore: ((destination, ...keys) => number);
    sismember: ((key, member) => number);
    smembers: ((key) => string[]);
    smove: ((source, destination, member) => number);
    spop: ((key) => string);
    srandmember: ((key, count) => string[]);
    srem: ((key, ...members) => number);
    sscan: ((key, cursor, opt?) => SScanResult);
    strlen: ((key) => number);
    sunion: ((...keys) => string[]);
    sunionstore: ((destination, ...keys) => number);
    ttl: ((key) => number);
    zadd: ((key, map) => number);
    zaddPair: ((key, ...pairs) => number);
    zcard: ((key) => number);
    zcount: ((key, min, max) => number);
    zincrby: ((key, increment, member) => string);
    zrangebyscore: ((key, min, max, option?) => string[]);
    zrank: ((key, member) => number);
    zrem: ((key, ...members) => number);
    zremrangebyscore: ((key, min, max) => number);
    zrevrangebyscore: ((key, max, min, option?) => string[]);
    zrevrank: ((key, member) => number);
    zscan: ((key, cursor, opt?) => ZScanResult);
    zscore: ((key, member) => string);
    set(key, value, expireInSeconds): boolean;
    set(key, value, opt?): string;
    zrange(key, start, stop): string[];
    zrange(key, start, stop, opt?): string[];
    zremrangebyrank(key, start, stop): number;
    zrevrange(key, start, stop): string[];
    zrevrange(key, start, stop, opt?): string[];
}

Hierarchy (view full)

Properties

append: ((key, value) => number)

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

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

Type declaration

    • (key, value): number
    • Parameters

      • key: string
      • value: string

      Returns number

decr: ((key) => number)

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

Type declaration

    • (key): number
    • Parameters

      • key: string

        键值

      Returns number

decrBy: ((key, decrement) => void)

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

Type declaration

    • (key, decrement): void
    • Parameters

      • key: string

        键值

      • decrement: number

        必须是正整数

      Returns void

del: ((...keys) => number)

删除给定的一个或多个 key

Type declaration

    • (...keys): number
    • Parameters

      • Rest ...keys: string[]

        待删除的键值列表

      Returns number

exists: ((key) => boolean)

检查给定 key 是否存在。

存在返回 true, 失败返回 false

Type declaration

    • (key): boolean
    • Parameters

      • key: string

        键值

      Returns boolean

expire: ((key, seconds) => number)

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

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

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

Type declaration

    • (key, seconds): number
    • Parameters

      • key: string

        键值

      • seconds: number

        生存时间(秒)

      Returns number

get: ((key) => string)

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

Type declaration

    • (key): string
    • Parameters

      • key: string

        键值

      Returns string

getset: ((key, value) => string)

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

返回给定键 key 的旧值。

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

Type declaration

    • (key, value): string
    • Parameters

      • key: string
      • value: string

      Returns string

hdel: ((key, ...fields) => number)

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

Type declaration

    • (key, ...fields): number
    • Parameters

      • key: string

        哈希表

      • Rest ...fields: string[]

        域列表

      Returns number

Returns

被成功移除的域的数量,不包括被忽略的域

hexists: ((key, field) => number)

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

Type declaration

    • (key, field): number
    • Parameters

      • key: string

        哈希表

      • field: string

      Returns number

Returns

给定域存在时返回 1 , 在给定域不存在时返回 0

hget: ((key, field) => string)

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

Type declaration

    • (key, field): string
    • Parameters

      • key: string

        哈希表

      • field: string

      Returns string

Returns

如果存在则返回值,不存在则返回空字符串

hgetAll: ((key) => "redis".StringDict)

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

Type declaration

Returns

键值对

hincrby: ((key, field, increment) => number)

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

Type declaration

    • (key, field, increment): number
    • Parameters

      • key: string

        哈希表, 如果 key 不存在,一个新的哈希表被创建并执行 HINCRBY 命令

      • field: string

        域,如果域 field 不存在,那么在执行命令前,域的值被初始化为 0。 如果存在且值是字符串的, 则抛异常

      • increment: number

        增量,可为负数,本操作的值被限制在 64 位(bit)有符号数字表示之内

      Returns number

Returns

执行 HINCRBY 命令之后,哈希表 key 中域 field 的值

hkeys: ((key) => string[])

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

Type declaration

    • (key): string[]
    • Parameters

      • key: string

        哈希表

      Returns string[]

Returns

一个包含哈希表中所有域的表。 当 key 不存在时,返回一个空表。

hlen: ((key) => number)

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

Type declaration

    • (key): number
    • Parameters

      • key: string

        哈希表

      Returns number

Returns

哈希表中域的数量。 当 key 不存在时,返回 0 。

hmget: ((key, ...fields) => string[])

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

Type declaration

    • (key, ...fields): string[]
    • Parameters

      • key: string

        哈希表

      • Rest ...fields: string[]

        域列表

      Returns string[]

Returns

一个包含多个给定域的关联值的表,表值的排列顺序和给定域参数的请求顺序一样。

hmset: ((key, map) => string)

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

Type declaration

    • (key, map): string
    • Parameters

      • key: string

        哈希表,如果 key 不存在,一个空哈希表被创建并执行 HMSET 操作

      • map: "redis".StringDict

        必须是<string, string>键值对

      Returns string

Returns

如果命令执行成功,返回 OK。 当 key 不是哈希表(hash)类型时,返回一个错误

hscan: ((key, cursor, opt?) => HScanResult)

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

Type declaration

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;
}
}
hset: ((key, field, value) => number)

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

Type declaration

    • (key, field, value): number
    • Parameters

      • key: string

        哈希表

      • field: string

      • value: string

        字段值, 如果值为null或者undefined,设置成空字符串

      Returns number

Returns

当 HSET 命令在哈希表中新创建 field 域并成功为它设置值时, 命令返回 1 ; 如果域 field 已经存在于哈希表, 并且 HSET 命令成功使用新值覆盖了它的旧值, 那么命令返回 0 。

hsetnx: ((key, field, value) => number)

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

Type declaration

    • (key, field, value): number
    • Parameters

      • key: string

        哈希表

      • field: string

      • value: string

        字段值

      Returns number

Returns

HSETNX 命令在设置成功时返回 1 , 在给定域已经存在而放弃执行设置操作时返回 0

hstrlen: ((key, field) => number)

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

Type declaration

    • (key, field): number
    • Parameters

      • key: string

        哈希表

      • field: string

      Returns number

Returns

如果给定的键或者域不存在, 那么命令返回 0

hvals: ((key) => string[])

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

Type declaration

    • (key): string[]
    • Parameters

      • key: string

        哈希表

      Returns string[]

Returns

一个包含哈希表中所有值的表。 当 key 不存在时,返回一个空表。

incr: ((key) => number)

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

Type declaration

    • (key): number
    • Parameters

      • key: string

        键值

      Returns number

incrBy: ((key, increment) => number)

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

Type declaration

    • (key, increment): number
    • Parameters

      • key: string

        键值

      • increment: number

        必须是正整数

      Returns number

lindex: ((key, index) => string)

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

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

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

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

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

Type declaration

    • (key, index): string
    • Parameters

      • key: string
      • index: number

      Returns string

linsert: ((key, pos, pivot, value) => number)

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

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

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

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

Type declaration

    • (key, pos, pivot, value): number
    • Parameters

      • key: string
      • pos: Position
      • pivot: string
      • value: string

      Returns number

llen: ((key) => number)

返回列表 key 的长度。

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

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

Type declaration

    • (key): number
    • Parameters

      • key: string

      Returns number

lpop: ((key) => string)

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

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

Type declaration

    • (key): string
    • Parameters

      • key: string

      Returns string

lpush: ((key, ...values) => number)

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

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

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

Type declaration

    • (key, ...values): number
    • Parameters

      • key: string

      • Rest ...values: string[]

        值列表

      Returns number

lpushx: ((key, value) => number)

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

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

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

Type declaration

    • (key, value): number
    • Parameters

      • key: string

      • value: string

      Returns number

lrange: ((key, start, stop) => string[])

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

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

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

Type declaration

    • (key, start, stop): string[]
    • Parameters

      • key: string
      • start: number
      • stop: number

      Returns string[]

lrem: ((key, count, value) => number)

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

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

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

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

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

Type declaration

    • (key, count, value): number
    • Parameters

      • key: string
      • count: number
      • value: string

      Returns number

lset: ((key, index, value) => number)

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

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

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

Type declaration

    • (key, index, value): number
    • Parameters

      • key: string
      • index: number
      • value: string

      Returns number

ltrim: ((key, start, stop) => string[])

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

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

命令执行成功时,返回 ok

Type declaration

    • (key, start, stop): string[]
    • Parameters

      • key: string
      • start: number
      • stop: number

      Returns string[]

pipeline: (() => RedisPipeliner)

Type declaration

rpop: ((key) => string)

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

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

Type declaration

    • (key): string
    • Parameters

      • key: string

      Returns string

rpoplpush: ((source, destination) => string)

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

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

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

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

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

返回被弹出的元素

Type declaration

    • (source, destination): string
    • Parameters

      • source: string
      • destination: string

      Returns string

rpush: ((key, ...values) => number)

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

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

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

Type declaration

    • (key, ...values): number
    • Parameters

      • key: string

      • Rest ...values: string[]

        值列表

      Returns number

rpushx: ((key, value) => number)

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

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

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

Type declaration

    • (key, value): number
    • Parameters

      • key: string
      • value: string

      Returns number

sadd: ((key, ...members) => number)

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

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

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

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

Type declaration

    • (key, ...members): number
    • Parameters

      • key: string
      • Rest ...members: string[]

      Returns number

scard: ((key) => number)

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

Type declaration

    • (key): number
    • Parameters

      • key: string

      Returns number

sdiff: ((...keys) => string[])

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

Type declaration

    • (...keys): string[]
    • Parameters

      • Rest ...keys: string[]

      Returns string[]

sdiffstore: ((destination, ...keys) => number)

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

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

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

Type declaration

    • (destination, ...keys): number
    • Parameters

      • destination: string
      • Rest ...keys: string[]

      Returns number

sinter: ((...keys) => string[])

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

Type declaration

    • (...keys): string[]
    • Parameters

      • Rest ...keys: string[]

      Returns string[]

sinterstore: ((destination, ...keys) => number)

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

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

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

Type declaration

    • (destination, ...keys): number
    • Parameters

      • destination: string
      • Rest ...keys: string[]

      Returns number

sismember: ((key, member) => number)

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

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

Type declaration

    • (key, member): number
    • Parameters

      • key: string
      • member: string

      Returns number

smembers: ((key) => string[])

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

Type declaration

    • (key): string[]
    • Parameters

      • key: string

      Returns string[]

smove: ((source, destination, member) => number)

将 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 必须在同一个分片上。

Type declaration

    • (source, destination, member): number
    • Parameters

      • source: string
      • destination: string
      • member: string

      Returns number

spop: ((key) => string)

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

Type declaration

    • (key): string
    • Parameters

      • key: string

      Returns string

srandmember: ((key, count) => string[])

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

count 参数:

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

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

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

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

Type declaration

    • (key, count): string[]
    • Parameters

      • key: string
      • count: number

      Returns string[]

srem: ((key, ...members) => number)

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

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

Type declaration

    • (key, ...members): number
    • Parameters

      • key: string
      • Rest ...members: string[]

      Returns number

sscan: ((key, cursor, opt?) => SScanResult)

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

Type declaration

strlen: ((key) => number)

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

Type declaration

    • (key): number
    • Parameters

      • key: string

      Returns number

sunion: ((...keys) => string[])

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

Type declaration

    • (...keys): string[]
    • Parameters

      • Rest ...keys: string[]

      Returns string[]

sunionstore: ((destination, ...keys) => number)

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

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

返回结果集中的元素数量

Type declaration

    • (destination, ...keys): number
    • Parameters

      • destination: string
      • Rest ...keys: string[]

      Returns number

ttl: ((key) => number)

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

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

Type declaration

    • (key): number
    • Parameters

      • key: string

        键值

      Returns number

zadd: ((key, map) => number)

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

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

Type declaration

    • (key, map): number
    • Parameters

      • key: string

        键值

      • map: "redis".StringDict

        <score,member>键值对, 即key为score,value是member

      Returns number

zaddPair: ((key, ...pairs) => number)

功能同 zadd

Type declaration

zcard: ((key) => number)

返回有序集 key 的基数

Type declaration

    • (key): number
    • Parameters

      • key: string

        键值

      Returns number

zcount: ((key, min, max) => number)

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

Type declaration

    • (key, min, max): number
    • Parameters

      • key: string

        键值

      • min: string

        最小值

      • max: string

        最大值

      Returns number

zincrby: ((key, increment, member) => string)

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

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

Type declaration

    • (key, increment, member): string
    • Parameters

      • key: string

        键值

      • increment: string

        增量, 可以是负数值

      • member: string

        成员

      Returns string

zrangebyscore: ((key, min, max, option?) => string[])

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

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

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

Type declaration

    • (key, min, max, option?): string[]
    • Parameters

      Returns string[]

Example

import * as redis from 'redis';

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

console.log(cli.zrangebyscore("test_key", "(1", "5"));
zrank: ((key, member) => number)

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

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

Type declaration

    • (key, member): number
    • Parameters

      • key: string

        键值

      • member: string

        成员

      Returns number

zrem: ((key, ...members) => number)

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

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

Type declaration

    • (key, ...members): number
    • Parameters

      • key: string

        键值

      • Rest ...members: string[]

        成员列表

      Returns number

zremrangebyscore: ((key, min, max) => number)

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

返回被移除成员的数量

Type declaration

    • (key, min, max): number
    • Parameters

      • key: string

        键值

      • min: string

        最小值

      • max: string

        最大值

      Returns number

zrevrangebyscore: ((key, max, min, option?) => string[])

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

Type declaration

    • (key, max, min, option?): string[]
    • Parameters

      Returns string[]

zrevrank: ((key, member) => number)

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

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

Type declaration

    • (key, member): number
    • Parameters

      • key: string

        键值

      • member: string

        成员

      Returns number

zscan: ((key, cursor, opt?) => ZScanResult)

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

Type declaration

zscore: ((key, member) => string)

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

Type declaration

    • (key, member): string
    • Parameters

      • key: string

        键值

      • member: string

        成员

      Returns string

Methods

  • 将字符串值 value 关联到 key

    Parameters

    • key: string

    • value: string

    • expireInSeconds: number

      超时时间,如果为0表示永不超时

    Returns boolean

  • 将字符串值 value 关联到 key

    只在设置操作成功完成时才返回 OK ; 如果命令使用了 NX 或者 XX 选项, 但是因为条件没达到而造成设置操作未执行, 那么命令将返回空批量回复

    Parameters

    • key: string

    • value: string

    • Optional opt: SetOption

      可选参数,参考 setOption

    Returns string

  • 返回有序集 key 中,指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。

    下标参数 start 和 stop 都以 0 为底,也就是说,以 0 表示有序集第一个成员,以 1 表示有序集第二个成员,以此类推。 你也可以使用负数下标,以 -1 表示最后一个成员, -2 表示倒数第二个成员,以此类推。

    Parameters

    • key: string

      键值

    • start: string

      起始位置

    • stop: string

      结束位置

    Returns string[]

  • 返回有序集 key 中,指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。

    下标参数 start 和 stop 都以 0 为底,也就是说,以 0 表示有序集第一个成员,以 1 表示有序集第二个成员,以此类推。 你也可以使用负数下标,以 -1 表示最后一个成员, -2 表示倒数第二个成员,以此类推。

    Parameters

    Returns string[]

  • 移除有序集 key 中,指定排名(rank)区间内的所有成员。 区间分别以下标参数 start 和 stop 指出,包含 start 和 stop 在内。 下标参数 start 和 stop 都以 0 为底,也就是说,以 0 表示有序集第一个成员,以 1 表示有序集第二个成员,以此类推。 你也可以使用负数下标,以 -1 表示最后一个成员, -2 表示倒数第二个成员,以此类推。

    返回被移除成员的数量

    Parameters

    • key: string

      键值

    • start: string

      起始位置

    • stop: string

      结束位置

    Returns number

  • 返回有序集 key 中,指定区间内的成员 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。

    Parameters

    • key: string

      键值

    • start: string

      其实位置

    • stop: string

      结束位置

    Returns string[]

  • 返回有序集 key 中,指定区间内的成员 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。

    Parameters

    Returns string[]