Options
All
  • Public
  • Public/Protected
  • All
Menu

Class RedisStringClient

Hierarchy

Index

Constructors

Connection Methods

Other Methods

Server Methods

String Methods

Constructors

constructor

Connection Methods

echo

  • echo(message: string): Promise<string>

  • 直接返回 msg 本身。

    例子：

    await client.echo('Hello World!')
// "Hello World!"

    Parameters

    • message: string

    Returns Promise<string>

ping

  • ping(msg?: string): Promise<string>

  • 如果没有提供参数返回 PONG。否则返回 msg 本身。

    例子：

    await client.ping()
// "PONG"
await client.ping('Hello World!')
// "Hello World!"

    Parameters

    • Optional msg: string

      需要发送的信息，

    Returns Promise<string>

quit

  • quit(): Promise<"OK">

  • 请求 Redis server 关闭连接。

    • Redis Server 会在前面的命令都处理完后立刻关闭连接。

    始终返回 OK。

    Returns Promise<"OK">

select

  • select(db: number): Promise<string>
    • 起始版本：1.0.0

    选择从 0 开始计数的 Redis 逻辑数据库。

    Redis 的可选数据库是一种命名空间格式。所有的数据仍然存在相同的 RDB / AOF 文件中。不同的数据库可以有相同的 key。
    像 FLUSHDB [[RedisClient.swapdb | SWAPDB]] RANDOMKEY 可以在指定的数据库工作。

    Parameters

    • db: number

    Returns Promise<string>

    查看原始定义

Other Methods

on

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns RedisStringClient

once

  • once(event: string | symbol, listener: (...args: any[]) => void): RedisStringClient

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns RedisStringClient

Server Methods

info

  • info(section?: "server" | "clients" | "memory" | "persistence" | "stats" | "replication" | "cpu" | "commandstats" | "cluster" | "keyspace" | "all" | "defaultƒ"): Promise<RedisServerInfo>

String Methods

append

  • append(key: string | Buffer, value: string | Buffer): Promise<number>
    • Redis官方文档：https://redis.io/commands/append
    • 起始版本：2.0.0
    • 时间复杂度：假设追加值很小，原始值为任意大小, 由于 Redis 使用的动态字符串会在每次重新分配时加倍字符串的存储空间，分摊时间复杂度为 O(1)。

    返回追加后的字符串长度。

    • 如果 key 不存在，则先创建为空字符串。
    • 如果已经存在并且值类型为 string，此命令会追加 value 到值的结尾。
    • 其他情况会抛出异常。

    例子：

    await client.exists('mykey')
// 0
await client.append('mykey', 'Hello')
// 5
await client.append('mykey', ' World')
// 11
await client.get('mykey')
// "Hello World"

    Parameters

    • key: string | Buffer
    • value: string | Buffer

      需要追加的内容。

    Returns Promise<number>

bitcount

  • bitcount(key: string | Buffer): Promise<number>
  • bitcount(key: string | Buffer, start: number): Promise<number>
  • bitcount(key: string | Buffer, start: number, end: number): Promise<number>

  • 统计字符串中 1 的个数（填充计数）。默认情况下将检查字符串的所有字节。 可以通过 range 参数控制指定范围的字节计数。

    如果只设置了 start 没有设置 end，end 会被设置为 -1。

    例子：

    await client.set('mykey', 'foo')
// "OK", foo 对应的字节序列为 01100110 01101111 01101111
await client.bitcount('mykey')
// 16
await client.bitcount('mykey', [0, 0])
// 4
await client.bitcount('mykey', [1, 1])
// 6

    Parameters

    • key: string | Buffer

    Returns Promise<number>

  • 统计字符串中 1 的个数（填充计数）。默认情况下将检查字符串的所有字节。 可以通过 range 参数控制指定范围的字节计数。

    如果只设置了 start 没有设置 end，end 会被设置为 -1。

    例子：

    await client.set('mykey', 'foo')
// "OK", foo 对应的字节序列为 01100110 01101111 01101111
await client.bitcount('mykey')
// 16
await client.bitcount('mykey', [0, 0])
// 4
await client.bitcount('mykey', [1, 1])
// 6

    Parameters

    • key: string | Buffer
    • start: number

    Returns Promise<number>

  • 统计字符串中 1 的个数（填充计数）。默认情况下将检查字符串的所有字节。 可以通过 range 参数控制指定范围的字节计数。

    如果只设置了 start 没有设置 end，end 会被设置为 -1。

    例子：

    await client.set('mykey', 'foo')
// "OK", foo 对应的字节序列为 01100110 01101111 01101111
await client.bitcount('mykey')
// 16
await client.bitcount('mykey', [0, 0])
// 4
await client.bitcount('mykey', [1, 1])
// 6

    Parameters

    • key: string | Buffer
    • start: number
    • end: number

    Returns Promise<number>

bitfield

  • 该命令将 Redis 字符串视为位数组，并且能够处理指定偏移量和位宽（不超过64bit）的整数字段，以及配置特定的溢出策略。

    支持四种子命令：

    • [[RedisClientParams.BitField.BitFieldGet | GET ]]：返回指定的位置的 bitfield。
    • SET <type> <offset> <value>：设置指定的位置的 bitfield，并返回旧的 bitfield。
    • INCRBY <type> <offset> <increment>：增加或减少指定偏移量和范围的 bitfield，并返回改变后的结果。
    • OVERFLOW [WRAP|SAT|FAIL]：通过设置不同的溢出策略修改连续调用 INCRBY 子命令的行为。

    返回子命令处理结果的列表。详细使用方式参见 pipeline 类型说明。

    例子：

    await client.bitfield('mykey', [
    ['INCRBY', 'i5', 100, 1],
    ['GET', 'u4', 0,],
]) // [1, 0]

    await client.bitfield('mystring', [
    ['SET', 'i8', '#0', 100],
    ['SET', 'i8', '#1', 200],
])

    这里展示了不同溢出策略的效果：

    await client.bitfield('mykey', [
    ['INCRBY', 'u2', 100, 1],
    ['OVERFLOW', 'SAT'],
    ['INCRBY', 'u2', 102, 1],
]) // [1, 1]
await client.bitfield('mykey', [
    ['INCRBY', 'u2', 100, 1],
    ['OVERFLOW', 'SAT'],
    ['INCRBY', 'u2', 102, 1],
]) // [2, 2]
await client.bitfield('mykey', [
    ['INCRBY', 'u2', 100, 1],
    ['OVERFLOW', 'SAT'],
    ['INCRBY', 'u2', 102, 1],
]) // [3, 3]
await client.bitfield('mykey', [
    ['INCRBY', 'u2', 100, 1],
    ['OVERFLOW', 'SAT'],
    ['INCRBY', 'u2', 102, 1],
]) // [0, 3]

    Parameters

    Returns Promise<number[]>

bitop

  • bitop(operation: "AND", dest: string | Buffer, keys: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
  • bitop(operation: "OR", dest: string | Buffer, keys: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
  • bitop(operation: "XOR", dest: string | Buffer, keys: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
  • bitop(operation: "NOT", dest: string | Buffer, keys: [string | Buffer]): Promise<number>

  • 执行按位运算并将结果存储在 dest 中。 对于多个字符串长度不统一的情况，短字符串不足长度用 0 补足。

    返回保存到 dest 的字符串的长度，该值和输入 keys 中最长的字符串长度相等。

    例子：

    await client.set('key1', 'foobar')
// "OK"
await client.set('key2', 'abcdef')
// "OK"
await client.bitop('AND', 'dest', ['key1', 'key2'])
// 6
await client.get('dest')
// "`bc`ab"

    按位与，接受多个 key。

    Parameters

    • operation: "AND"
    • dest: string | Buffer
    • keys: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

  • 执行按位运算并将结果存储在 dest 中。 对于多个字符串长度不统一的情况，短字符串不足长度用 0 补足。

    返回保存到 dest 的字符串的长度，该值和输入 keys 中最长的字符串长度相等。

    例子：

    await client.set('key1', 'foobar')
// "OK"
await client.set('key2', 'abcdef')
// "OK"
await client.bitop('AND', 'dest', ['key1', 'key2'])
// 6
await client.get('dest')
// "`bc`ab"

    按位或，接受多个 key。

    Parameters

    • operation: "OR"
    • dest: string | Buffer
    • keys: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

  • 执行按位运算并将结果存储在 dest 中。 对于多个字符串长度不统一的情况，短字符串不足长度用 0 补足。

    返回保存到 dest 的字符串的长度，该值和输入 keys 中最长的字符串长度相等。

    例子：

    await client.set('key1', 'foobar')
// "OK"
await client.set('key2', 'abcdef')
// "OK"
await client.bitop('AND', 'dest', ['key1', 'key2'])
// 6
await client.get('dest')
// "`bc`ab"

    按位异或，接受多个 key。

    Parameters

    • operation: "XOR"
    • dest: string | Buffer
    • keys: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

  • 执行按位运算并将结果存储在 dest 中。 对于多个字符串长度不统一的情况，短字符串不足长度用 0 补足。

    返回保存到 dest 的字符串的长度，该值和输入 keys 中最长的字符串长度相等。

    例子：

    await client.set('key1', 'foobar')
// "OK"
await client.set('key2', 'abcdef')
// "OK"
await client.bitop('AND', 'dest', ['key1', 'key2'])
// 6
await client.get('dest')
// "`bc`ab"

    按位取反，接受单个 key。

    Parameters

    • operation: "NOT"
    • dest: string | Buffer
    • keys: [string | Buffer]

    Returns Promise<number>

bitpos

  • bitpos(key: string | Buffer, bit: 0 | 1): Promise<number>
  • bitpos(key: string | Buffer, bit: 0 | 1, start: number): Promise<number>
  • bitpos(key: string | Buffer, bit: 0 | 1, start: number, end: number): Promise<number>

  • 将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。

    如果给定范围没有找到目标 bit，则返回 -1。

    注意：

    • 这里的 start 和 end 表示的是 byte 位置，而不是 bit 位置，但是返回值表示的是 bit 位置。
    • start 的值只是决定了开始寻找的位置，返回的 bit 位置都是从整个字符串的首位开始计算。

    例子：

    await client.set('mykey', Buffer.from([0xff, 0xf0, 0x00]))
// "OK"
await client.bitpos('mykey', 0)
// 12
await client.set('mykey', Buffer.from([0x00, 0xff, 0xf0]))
// "OK"
await client.bitpos('mykey', 1, 0)
// 8
await client.bitpos('mykey', 1, 2)
// 16
await client.set('mykey', Buffer.from([0x00, 0x00, 0x00]))
// "OK"
await client.bitpos('mykey', 1)
// -1

    Parameters

    • key: string | Buffer
    • bit: 0 | 1

      目标 bit，1 或 0。

    Returns Promise<number>

  • 将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。

    如果给定范围没有找到目标 bit，则返回 -1。

    注意：

    • 这里的 start 和 end 表示的是 byte 位置，而不是 bit 位置，但是返回值表示的是 bit 位置。
    • start 的值只是决定了开始寻找的位置，返回的 bit 位置都是从整个字符串的首位开始计算。

    例子：

    await client.set('mykey', Buffer.from([0xff, 0xf0, 0x00]))
// "OK"
await client.bitpos('mykey', 0)
// 12
await client.set('mykey', Buffer.from([0x00, 0xff, 0xf0]))
// "OK"
await client.bitpos('mykey', 1, 0)
// 8
await client.bitpos('mykey', 1, 2)
// 16
await client.set('mykey', Buffer.from([0x00, 0x00, 0x00]))
// "OK"
await client.bitpos('mykey', 1)
// -1

    Parameters

    • key: string | Buffer
    • bit: 0 | 1

      目标 bit，1 或 0。

    • start: number

      开始的字节位置。

    Returns Promise<number>

  • 将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。

    如果给定范围没有找到目标 bit，则返回 -1。

    注意：

    • 这里的 start 和 end 表示的是 byte 位置，而不是 bit 位置，但是返回值表示的是 bit 位置。
    • start 的值只是决定了开始寻找的位置，返回的 bit 位置都是从整个字符串的首位开始计算。

    例子：

    await client.set('mykey', Buffer.from([0xff, 0xf0, 0x00]))
// "OK"
await client.bitpos('mykey', 0)
// 12
await client.set('mykey', Buffer.from([0x00, 0xff, 0xf0]))
// "OK"
await client.bitpos('mykey', 1, 0)
// 8
await client.bitpos('mykey', 1, 2)
// 16
await client.set('mykey', Buffer.from([0x00, 0x00, 0x00]))
// "OK"
await client.bitpos('mykey', 1)
// -1

    Parameters

    • key: string | Buffer
    • bit: 0 | 1

      目标 bit，1 或 0。

    • start: number

      开始的字节位置。

    • end: number

      结束的字节位置。

    Returns Promise<number>

decr

  • decr(key: string | Buffer): Promise<number>
  • decr(key: string | Buffer, string_number: true): Promise<string>

  • 将 key 处存储的数字减 1，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.decr('mykey')
// 9
await client.set('mykey', '234293482390480948029348230948')
// "OK"
await client.decr('mykey')
// ReplyError: ERR value is not an integer or out of range

    Parameters

    • key: string | Buffer

    Returns Promise<number>

  • 将 key 处存储的数字减 1，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.decr('mykey')
// 9
await client.set('mykey', '234293482390480948029348230948')
// "OK"
await client.decr('mykey')
// ReplyError: ERR value is not an integer or out of range

    Parameters

    • key: string | Buffer
    • string_number: true

      是否以字符串形式返回结果。

    Returns Promise<string>

decrby

  • decrby(key: string | Buffer, delta: string | number): Promise<number>
  • decrby(key: string | Buffer, delta: string | number, string_number: true): Promise<string>

  • 将 key 处存储的数字减少 delta，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.decrby('mykey', 3)
// 7

    Parameters

    • key: string | Buffer
    • delta: string | number

      偏移量

    Returns Promise<number>

  • 将 key 处存储的数字减少 delta，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.decrby('mykey', 3)
// 7

    Parameters

    • key: string | Buffer
    • delta: string | number
    • string_number: true

      是否以字符串形式返回结果。

    Returns Promise<string>

get

  • get(key: string | Buffer): Promise<null | string>
  • get(key: string | Buffer, return_buffer: true): Promise<null | Buffer>

  • 获取 key 对应的值。

    • 如果 key 不存在返回 null。
    • 如果 key 的值类型不是 string 抛出异常。

    注意：由于 Redis 的 String 可以存储二进制数据，对于不需要解析为字符串的结果，可以通过将 return_buffer 设为 true 阻止将结果转换为字符串。

    例子：

    await client.get('nonexisting')
// null
await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.get('mykey', true)
// <Buffer 48 65 6c 6c 6f>

    Parameters

    • key: string | Buffer

    Returns Promise<null | string>

  • 获取 key 对应的值。

    • 如果 key 不存在返回 null。
    • 如果 key 的值类型不是 string 抛出异常。

    注意：由于 Redis 的 String 可以存储二进制数据，对于不需要解析为字符串的结果，可以通过将 return_buffer 设为 true 阻止将结果转换为字符串。

    例子：

    await client.get('nonexisting')
// null
await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.get('mykey', true)
// <Buffer 48 65 6c 6c 6f>

    Parameters

    • key: string | Buffer
    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

getbit

  • getbit(key: string | Buffer, offset: number): Promise<0 | 1>

  • 返回指定 key 的 offset 处的 bit 值。

    • 如果 offset 超过字符串的长度，返回 0。
    • 如果 key 不存在，则被认为是个空字符串，此时 offset 是溢出的，同样返回 0。

    例子：

    await client.setbit('mykey', 7, 1)
// 0
await client.getbit('mykey', 0)
// 0
await client.getbit('mykey', 7)
// 1
await client.getbit('mykey', 100)
// 0

    Parameters

    • key: string | Buffer
    • offset: number

    Returns Promise<0 | 1>

getrange

  • getrange(key: string | Buffer, start: number, end: number): Promise<string>
  • getrange(key: string | Buffer, start: number, end: number, return_buffer: true): Promise<Buffer>
    • Redis官方文档：https://redis.io/commands/getrange
    • 起始版本：2.4.0
    • 时间复杂度：O(N)，N 是返回字符串的长度。
      复杂度最终取决于返回的长度，但是鉴于从现有字符串创建子串性能很好，所以对于小字符串可以认为复杂度为 O(1)。

    返回指定 key 的字符串的子串。key 的类型如果不是 string 则抛出异常。

    • 选取范围为闭区间 [start, end]。
    • -1 表示最后一个元素，-2 为倒数第二个，以此类推。

    注意：在 2.0.0 及更早的版本，命令名称为 SUBSTR。

    例子：

    await client.set('myey', 'This is a string')
// "OK"
await client.getrange('mykey', 0, 3)
// "This"
await client.getrange('mykey', -3, -1)
// "ing"
await client.getrange('mykey', 0, -1)
// "This is a string"
await client.getrange('mykey', 10, 100)
// "string"
await client.getrange('mykey', 10, 100, true)
// <Buffer 73 74 72 69 6e 67>

    Parameters

    • key: string | Buffer
    • start: number

      开始的字节数。

    • end: number

      结束的字节数。

    Returns Promise<string>

    • Redis官方文档：https://redis.io/commands/getrange
    • 起始版本：2.4.0
    • 时间复杂度：O(N)，N 是返回字符串的长度。
      复杂度最终取决于返回的长度，但是鉴于从现有字符串创建子串性能很好，所以对于小字符串可以认为复杂度为 O(1)。

    返回指定 key 的字符串的子串。key 的类型如果不是 string 则抛出异常。

    • 选取范围为闭区间 [start, end]。
    • -1 表示最后一个元素，-2 为倒数第二个，以此类推。

    注意：在 2.0.0 及更早的版本，命令名称为 SUBSTR。

    例子：

    await client.set('myey', 'This is a string')
// "OK"
await client.getrange('mykey', 0, 3)
// "This"
await client.getrange('mykey', -3, -1)
// "ing"
await client.getrange('mykey', 0, -1)
// "This is a string"
await client.getrange('mykey', 10, 100)
// "string"
await client.getrange('mykey', 10, 100, true)
// <Buffer 73 74 72 69 6e 67>

    Parameters

    • key: string | Buffer
    • start: number

      开始的字节数。

    • end: number

      结束的字节数。

    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<Buffer>

getset

  • getset(key: string | Buffer, value: string | Buffer): Promise<null | string>
  • getset(key: string | Buffer, value: string | Buffer, return_buffer: true): Promise<null | Buffer>

  • 原子性的设置 key，并返回原值。如果 key 已经存在但值不是 string 类型，抛出异常。

    注意：在 6.2 版本，此方法可能会被废弃。请使用 SET 命令以及 GET 选项。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.getset('mykey', 'World')
// "Hello"
await client.get('mykey')
// "World"
await client.getset('mykey', 'Whatever', true)
// <Buffer 57 6f 72 6c 64>
await client.get('mykey')
// "Whatever"

    Parameters

    • key: string | Buffer
    • value: string | Buffer

    Returns Promise<null | string>

  • 原子性的设置 key，并返回原值。如果 key 已经存在但值不是 string 类型，抛出异常。

    注意：在 6.2 版本，此方法可能会被废弃。请使用 SET 命令以及 GET 选项。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.getset('mykey', 'World')
// "Hello"
await client.get('mykey')
// "World"
await client.getset('mykey', 'Whatever', true)
// <Buffer 57 6f 72 6c 64>
await client.get('mykey')
// "Whatever"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • return_buffer: true

    Returns Promise<null | Buffer>

incr

  • incr(key: string | Buffer): Promise<number>
  • incr(key: string | Buffer, string_number: true): Promise<string>

  • 将 key 处存储的数字加 1，并返回处理之后的结果。

    INCRBY DECR DECRBY 三个命令的行为和 INCR
    很基本一致。都具有如下特点：

    • 如果 key 不存在，在加 1 之前会先将 key 设置为 0。
    • 如果 key 包含的类型不是数字形式的字符串，则会抛出异常。
    • 能处理数据极限为 64 位有符号整型，溢出时会抛出异常。

    注意：Javascript 的 number 类型实际为 64 位浮点型。精确表示的整型范围达不到 64 位有符号整型的最大值和最小值。 可以参考 Javascript 的 Number.MAX_SAFE_INTEGER
    和 Number.MIN_SAFE_INTEGER。 此命令默认按照 Redis 的返回类型 integer 进行解析。当处理结果很大时，为了避免丢失精度，可以通过将 string_number 设为 true 阻止将结果转换为数字。

    对于 INCRBY DECRBY delta 也可能超过 Javascript 的最大整型值，此时请使用 string
    类型传递参数。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.incr('mykey')
// 11
await client.get('mykey')
// "11"
await client.incr('mykey', true)
// "12"
await client.get('mykey')
// "12"

    Parameters

    • key: string | Buffer

    Returns Promise<number>

  • 将 key 处存储的数字加 1，并返回处理之后的结果。

    INCRBY DECR DECRBY 三个命令的行为和 INCR
    很基本一致。都具有如下特点：

    • 如果 key 不存在，在加 1 之前会先将 key 设置为 0。
    • 如果 key 包含的类型不是数字形式的字符串，则会抛出异常。
    • 能处理数据极限为 64 位有符号整型，溢出时会抛出异常。

    注意：Javascript 的 number 类型实际为 64 位浮点型。精确表示的整型范围达不到 64 位有符号整型的最大值和最小值。 可以参考 Javascript 的 Number.MAX_SAFE_INTEGER
    和 Number.MIN_SAFE_INTEGER。 此命令默认按照 Redis 的返回类型 integer 进行解析。当处理结果很大时，为了避免丢失精度，可以通过将 string_number 设为 true 阻止将结果转换为数字。

    对于 INCRBY DECRBY delta 也可能超过 Javascript 的最大整型值，此时请使用 string
    类型传递参数。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.incr('mykey')
// 11
await client.get('mykey')
// "11"
await client.incr('mykey', true)
// "12"
await client.get('mykey')
// "12"

    Parameters

    • key: string | Buffer
    • string_number: true

      是否以字符串形式返回结果。

    Returns Promise<string>

incrby

  • incrby(key: string | Buffer, delta: string | number): Promise<number>
  • incrby(key: string | Buffer, delta: string | number, string_number: true): Promise<string>

  • 将 key 处存储的数字减少 delta，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.incrby('mykey', 5)
// 15
await client.incrby('mykey', '50', true)
// "65"

    Parameters

    • key: string | Buffer
    • delta: string | number

    Returns Promise<number>

  • 将 key 处存储的数字减少 delta，并返回处理之后的结果。

    详情参考 INCR。

    例子：

    await client.set('mykey', '10')
// "OK"
await client.incrby('mykey', 5)
// 15
await client.incrby('mykey', '50', true)
// "65"

    Parameters

    • key: string | Buffer
    • delta: string | number
    • string_number: true

      是否以字符串形式返回结果。

    Returns Promise<string>

incrbyfloat

  • incrbyfloat(key: string | Buffer, increment: `${number}`): Promise<`${number}`>

  • 将 key 处存储的浮点数增加 increment。

    • 如果 increment 传递负值，则效果是减小。
    • INCRBYFLOAT 的返回格式是字符串，基于保持输入输出一致以及避免精度损失。这里的 increment 使用字符串形式。
    • 如果 key 不存在，先将 key 设为 0。
    • 如果 key 对应的值不能解析为数字或者压根不是 string，将抛出异常。

    当命令执行成功，则将递增后的新值存储到 key 上（替换旧的值），并以字符串形式返回新的值。

    key 值以及提供的增量（increment）都可以使用指数表示法，但是计算后的结果始终使用小数形式，且后缀的 0 始终会被清除。

    例子：

    await client.set('mykey', '10.50')
// "OK"
await client.incrbyfloat('mykey', '0.1')
// "10.6"
await client.incrbyfloat('mykey', '-5')
// "5.6"
await client.set('mykey', '5.0e3')
// "OK"
await client.incrbyfloat('mykey', '2.0e2')
// "5200"

    Parameters

    • key: string | Buffer
    • increment: `${number}`

    Returns Promise<`${number}`>

mget

  • mget(keys: [string | Buffer, ...(string | Buffer)[]]): Promise<(null | string)[]>
  • mget(keys: [string | Buffer, ...(string | Buffer)[]], return_buffer: true): Promise<(null | Buffer)[]>

  • 返回所有指定的 key 对应的值的列表。

    • 对于不存在的或者类型不是 string 的 key，统一返回 null。所以此命令永远不会失败。

    例子：

    await client.set('key1', 'Hello')
// "OK"
await client.set('key2', 'World')
// "OK"
await client.mget(['key1', 'key2', 'nonexisting'])
// ["Hello", "World", null]
await client.mget(['key1', 'key2', 'nonexisting'], true)
// [ <Buffer 48 65 6c 6c 6f>, <Buffer 57 6f 72 6c 64>, null ]

    Parameters

    • keys: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<(null | string)[]>

  • 返回所有指定的 key 对应的值的列表。

    • 对于不存在的或者类型不是 string 的 key，统一返回 null。所以此命令永远不会失败。

    例子：

    await client.set('key1', 'Hello')
// "OK"
await client.set('key2', 'World')
// "OK"
await client.mget(['key1', 'key2', 'nonexisting'])
// ["Hello", "World", null]
await client.mget(['key1', 'key2', 'nonexisting'], true)
// [ <Buffer 48 65 6c 6c 6f>, <Buffer 57 6f 72 6c 64>, null ]

    Parameters

    • keys: [string | Buffer, ...(string | Buffer)[]]
    • return_buffer: true

      是否按 Buffer 形式返回结果。

    Returns Promise<(null | Buffer)[]>

mset

  • mset(kvs: {}): Promise<"OK">

  • 按照给定的 key value 批量进行 set 操作。

    • MSET 命令是原子性的，要么全部成功，要么全部失败。
    • 对于已经存在的 key，MSET 会进行重写。如果你不希望重写，请参考 MSETNX。

    MSET 始终返回 OK。

    例子：

    await client.mset({ key1: 'Hello', key2: 'World' })
// "OK"
await client.get('key1')
// "Hello"
await client.get('key2')
// "World"

    Parameters

    • kvs: {}
      • [key: string]: StringValue

        键值对，值可以是 Buffer 或 string

    Returns Promise<"OK">

msetnx

  • msetnx(kvs: {}): Promise<0 | 1>

  • 按照给定参数设置 key value。只要有任何一个 key 是已经存在的，MSETNX 都不会执行。

    • 基于 MSETNX 的这种语义，可以用来设置同一逻辑对象的不同 key。

    返回值含义：

    • 1 全部 key 设置成功。
    • 0 设置失败。

    例子：

    await client.msetnx({ key1: 'Hello', key2: 'there' })
// 1
await client.msetnx({ key2: 'new', key3: 'world' })
// 0
await client.mget(['key1', 'key2', 'key3'])
// ["Hello", "there", null]

    Parameters

    • kvs: {}
      • [key: string]: StringValue

        键值对，值可以是 Buffer 或 string

    Returns Promise<0 | 1>

psetex

  • psetex(key: string | Buffer, value: string | Buffer, milli_ex: number): Promise<"OK">

  • PSETEX 的行为和 SETEX 一致。 唯一区别是到期时间是毫秒单位。

    例子：

    await client.psetex('mykey', 'Hello', 1000)
// "OK"
await client.pttl('mykey')
// 961，不是固定值，取决于 执行 PTTL 和 PSETEX 的时间间隔。
await client.get('mykey')
// "Hello"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • milli_ex: number

    Returns Promise<"OK">

set

  • set(key: string | Buffer, value: string | Buffer): Promise<"OK">
  • set(key: string | Buffer, value: string | Buffer, get: true): Promise<null | string>
  • set(key: string | Buffer, value: string | Buffer, get: true, return_buffer: true): Promise<null | Buffer>
  • set(key: string | Buffer, value: string | Buffer, options: SetOptions): Promise<null | "OK">
  • set(key: string | Buffer, value: string | Buffer, get: true, options: SetOptions): Promise<null | string>
  • set(key: string | Buffer, value: string | Buffer, get: true, return_buffer: true, options: SetOptions): Promise<null | Buffer>

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer

    Returns Promise<"OK">

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • get: true

      是否需要返回原值。6.2.0 及以上版本可用。

    Returns Promise<null | string>

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • get: true

      是否需要返回原值。6.2.0 及以上版本可用。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • options: SetOptions

    Returns Promise<null | "OK">

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • get: true

      是否需要返回原值。6.2.0 及以上版本可用。

    • options: SetOptions

    Returns Promise<null | string>

  • 设置 key 的值为一个 string。

    • 如果 key 已经存在，则值会被覆盖。
    • 如果没有设置 ttl 相关选项，当命令成功之后，所有 ttl 会被清除。

    RedisClientParams.SetOptions 中 Expires 相关的三个选项 expire、pexpire、keepttl 是互斥的。
    存在多个时选择优先级最高的生效。优先级 keepttl > expire > pexpire。

    注意：由于 SET 的现有的选项可以使其实现 SETNX、SETEX、PSETEX 以及 GETSET 命令。
    所以在未来的版本 Redis 可能删除这些命令。

    例子：

    await client.set('mykey', 'Hello')
// "OK"
await client.get('mykey')
// "Hello"
await client.set('anotherkey', 'will expire in a minute', { expire: 60 })
// "OK"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • get: true

      是否需要返回原值。6.2.0 及以上版本可用。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    • options: SetOptions

    Returns Promise<null | Buffer>

setbit

  • setbit(key: string | Buffer, offset: number, value: 0 | 1): Promise<0 | 1>

  • 将 string 类型的 key 是做一个 bit 数组。将下标为 offset 的 bit 设为 1 或 0，并返回旧的 bit 的值。

    • 如果 key 不存在，先创建空字符串。
    • offset 参数取值范围为左闭右开区间 [0, 2^32)。这限制了 bitmap 最大为 512M。
    • 跳过的位会被设置为 0。比如 mykey 不存在。client.setbit('mykey', 7, 1) 会将 mykey 设置为 00000001。

    注意：当设置了最大有效位（offset 2^32 - 1 512M），但是 key 不存在或者存在但是是个小字符串， 此时 Redis 需要分配完整大小的内存，这可能会阻塞服务一段可观的时间。

    在 2010 款的 MacBook Pro上：

    • 设置 offset 2^32 - 1（512M），大约消耗 300ms。
    • 设置 offset 2^30 - 1（128M），大约消耗 80ms。
    • 设置 offset 2^28 - 1（32M），大约消耗 30ms。
    • 设置 offset 2^26 - 1（8M），大约消耗 8ms。

    例子：

    await client.setbit('mykey', 7, 1)
// 0
await client.setbit('mykey', 7, 0)
// 1
await client.get('mykey')
// "\u0000"

    Parameters

    • key: string | Buffer
    • offset: number
    • value: 0 | 1

    Returns Promise<0 | 1>

setex

  • setex(key: string | Buffer, value: string | Buffer, ttl: number): Promise<"OK">

  • 设置 key 的值为一个 string，同时设置过期时间。

    • 此命令是原子性的，常用作缓存。

    例子：

    await client.setex('mykey', 'Hello', 10)
// "OK"
await client.ttl('mykey')
// 10
await client.get('mykey')
// "Hello"

    Parameters

    • key: string | Buffer
    • value: string | Buffer
    • ttl: number

    Returns Promise<"OK">

setnx

  • setnx(key: string | Buffer, value: string | Buffer): Promise<0 | 1>

  • 如果 key 不存在，则设置 key 的值为一个 string。

    返回值：

    • 1 表示 key 设置成功。
    • 0 表示 key 没有设置成功。

    例子：

    await client.setnx('mykey', 'Hello')
// 1
await client.setnx('mykey', 'World')
// 0
await client.get('mykey')
// "Hello"

    Parameters

    • key: string | Buffer
    • value: string | Buffer

    Returns Promise<0 | 1>

setrange

  • setrange(key: string | Buffer, offset: number, value: string | Buffer): Promise<number>
    • Redis官方文档：https://redis.io/commands/setrange
    • 起始版本：2.2.0
    • 时间复杂度：不考虑复制新字符串花费的时间的话复杂度是 O(1)。
      通常这个字符串很小，所以基本上可以认为复杂度就是 O(1)。否则的话，复杂度是 O(M) M 是参数字符串的长度。

    部分重写 key 对应的值。从指定的 offset 开始，写入新的值。返回修改后的字符串长度。

    • 如果 offset 超过了原字符串的长度，则超过的部分会补充 \0，之后填充新的 value。
    • key 不存在会先设置为空字符串。

    注意：当 offset 很大，而原字符串不存在或者很小，此时引起的 Redis 重新分配内存耗时会比较大。 具体数据参见 SETBIT 命令。

    例子：

    await client.set('key1', 'Hello World')
// "OK"
await client.setrange('key1', 6, 'Redis')
// 11
await client.get('key1')
// "Hello Redis"
await client.setrange('key2', 6, 'Redis')
// 11
await client.get('key2')
// "\0\0\0\0\0\0Redis"

    Parameters

    • key: string | Buffer
    • offset: number

      偏移量，字节为单位。

    • value: string | Buffer

      需要写入的值。

    Returns Promise<number>

stralgo_lcs

  • stralgo_lcs(input_mode: "keys" | "strings", k1: string, k2: string): Promise<string>
  • stralgo_lcs(input_mode: "keys" | "strings", k1: string, k2: string, return_mode: "LEN"): Promise<number>
  • stralgo_lcs(input_mode: "keys" | "strings", k1: string, k2: string, return_mode: "IDX", min_match_len?: number): Promise<AlgorithmLCSResult>

  • STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
    目前唯一实现的算法是 LCS 算法（最长公共子序列）。

    注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。

    输入模式：

    • keys：根据提供的 key 查询值进行运算。如果 key 对应的值不是 string 类型抛出异常。
    • strings：直接提供进行运算的字符串。

    返回模式：

    • 普通模式：不设置 return_mode 即为普通模式，此时返回匹配到的子串。
    • 长度模式：设置 return_mode 为 LEN，此时返回匹配到的子串长度。
    • 索引模式：设置 return_mode 为 IDX，此时返回匹配详细信息。

    默认的返回模式为返回匹配到的子序列。

    Parameters

    • input_mode: "keys" | "strings"

      输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。

    • k1: string

      第一个输入值。

    • k2: string

      第二个输入值。

    Returns Promise<string>

  • STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
    目前唯一实现的算法是 LCS 算法（最长公共子序列）。

    注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。

    输入模式：

    • keys：根据提供的 key 查询值进行运算。如果 key 对应的值不是 string 类型抛出异常。
    • strings：直接提供进行运算的字符串。

    返回模式：

    • 普通模式：不设置 return_mode 即为普通模式，此时返回匹配到的子串。
    • 长度模式：设置 return_mode 为 LEN，此时返回匹配到的子串长度。
    • 索引模式：设置 return_mode 为 IDX，此时返回匹配详细信息。

    Parameters

    • input_mode: "keys" | "strings"

      输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。

    • k1: string

      第一个输入值。

    • k2: string

      第二个输入值。

    • return_mode: "LEN"

      返回结果模式 LEN 表示值返回匹配结果长度。

    Returns Promise<number>

  • STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
    目前唯一实现的算法是 LCS 算法（最长公共子序列）。

    注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。

    输入模式：

    • keys：根据提供的 key 查询值进行运算。如果 key 对应的值不是 string 类型抛出异常。
    • strings：直接提供进行运算的字符串。

    返回模式：

    • 普通模式：不设置 return_mode 即为普通模式，此时返回匹配到的子串。
    • 长度模式：设置 return_mode 为 LEN，此时返回匹配到的子串长度。
    • 索引模式：设置 return_mode 为 IDX，此时返回匹配详细信息。

    Parameters

    • input_mode: "keys" | "strings"

      输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。

    • k1: string

      第一个输入值。

    • k2: string

      第二个输入值。

    • return_mode: "IDX"

      返回结果模式 IDX 表示值返回匹配结果的详细信息。

    • Optional min_match_len: number

      最小匹配长度，这个参数只是在返回时用来过滤结果中 results 的内容，不会影响整个算法的匹配过程。

    Returns Promise<AlgorithmLCSResult>

strlen

  • strlen(key: string | Buffer): Promise<number>

  • 返回指定 key 的 string 长度，如果 key 存储的值不是 string 类型，则会抛出异常。

    • key 不存在返回 0。

    例子：

    await client.set('mykey', 'Hello World')
// "OK"
await client.strlen('mykey')
// 11
await client.strlen('nonexisting')
// 0

    Parameters

    • key: string | Buffer

    Returns Promise<number>

Generated using TypeDoc