Options
All
  • Public
  • Public/Protected
  • All
Menu

Class RedisListClient

Hierarchy

Index

Constructors

Connection Methods

List Methods

Other Methods

Server 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>

    查看原始定义

List Methods

blmove

  • blmove(src: string | Buffer, dest: string | Buffer, src_direct: "LEFT" | "RIGHT", dest_direct: "LEFT" | "RIGHT", timeout: number): Promise<null | string>
  • blmove(src: string | Buffer, dest: string | Buffer, src_direct: "LEFT" | "RIGHT", dest_direct: "LEFT" | "RIGHT", timeout: number, return_buffer: true): Promise<null | Buffer>

  • BLMOVE 是阻塞版本的 ｜ LMOVE 命令。

    • 当 src 中没有元素时，Redis 会阻塞连接，直到有其他的客户端向 src 中推入元素或者超时。
    • 当 src 中有元素时，它的行为和 ｜ LMOVE 一致。
    • 在 MULTI/EXEC 中时，它的行为和 ｜ LMOVE 一致。
    • timeout 设置为 0，表示不限时阻塞。

    返回从 src pop 出来的元素。如果超时则会返回 null。

    Parameters

    • src: string | Buffer

      需要 pop 元素的 list。

    • dest: string | Buffer

      需要 push 元素的 list。

    • src_direct: "LEFT" | "RIGHT"

      取出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。

    • dest_direct: "LEFT" | "RIGHT"

      推入方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。

    • timeout: number

      以秒为单位的过期时间，双精度浮点数。

    Returns Promise<null | string>

  • BLMOVE 是阻塞版本的 ｜ LMOVE 命令。

    • 当 src 中没有元素时，Redis 会阻塞连接，直到有其他的客户端向 src 中推入元素或者超时。
    • 当 src 中有元素时，它的行为和 ｜ LMOVE 一致。
    • 在 MULTI/EXEC 中时，它的行为和 ｜ LMOVE 一致。
    • timeout 设置为 0，表示不限时阻塞。

    返回从 src pop 出来的元素。如果超时则会返回 null。

    Parameters

    • src: string | Buffer

      需要 pop 元素的 list。

    • dest: string | Buffer

      需要 push 元素的 list。

    • src_direct: "LEFT" | "RIGHT"

      取出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。

    • dest_direct: "LEFT" | "RIGHT"

      推入方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。

    • timeout: number

      以秒为单位的过期时间，双精度浮点数。

    • return_buffer: true

      以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

blpop

  • blpop(keys: [string | Buffer, ...(string | Buffer)[]], timeout: number): Promise<[string | Buffer, string]>
  • blpop(keys: [string | Buffer, ...(string | Buffer)[]], timeout: number, return_buffer: true): Promise<[Buffer, Buffer]>

  • BLPOP 是阻塞版本的 ｜ LPOP 命令。

    • 当参数中指定的所有 list 都没有元素的时候，它会阻塞连接。
    • 当有 list 非空时，它会按照给定的 key 顺序从第一个非空 list 的头部弹出一个元素。
    • 当 timeout 被设置为 0 时表示不限时阻塞。
    • 超时后会返回 null。

    非阻塞行为

    当 BLPOP 被调用时，如果指定的 key 中至少有一个包含了非空列表，则会从其头部弹出一个元素并返回。

    考虑命令：

    await client.blpop(['list1', 'list2', 'list3'], 0)

    因为 list2 时这一系列 key 中第一个非空 list 是 list2，BLPOP 会保证返回 list2 的第一个元素。

    阻塞行为
    • 如果没有没有指定的 key 存在，BLPOP 会阻塞连接并等待其他客户端向其中某个 key 执行 LPUSH 或 RPUSH
      命令。
    • 一旦新的数据出现在列表中，客户端会结束阻塞，弹出元素并以数组形式返回 key 的名字和元素本身。
    • 当 BLPOP 命令引起了客户端阻塞并且设置了非零的阻塞时间，超时后会返回 null。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    哪一个 key/client/element 会被优先处理？优先级详情

    • 如果传递了多个 key，但是至少有一个 key 包含了元素。则返回的 key 是从左向右找到的第一个非空列表，此时不会发生阻塞。 所以对于命令：

      await client.blpop(['key1', 'key2', 'key3', 'key4'], 0)

      假设其中 key2 和 key4 是非空的，那么返回的是 key2 和它的第一个元素。

    • 如果多个客户端阻塞了相同的 key，优先被处理的客户端是等待时间最长的那个，也就是第一个产生阻塞的客户端。
      一旦这个客户端结束了阻塞，它将不会保留任何优先级，再次阻塞时从 0 开始记录阻塞时间。

    • 当客户端同时阻塞多个 key，并且元素同时在多个 key 中可用（因事务或Lua脚本同时向多个列表添加元素）时，
      将使用第一个接受 push 操作的 key 解除客户端的阻塞（假设它有足够的元素，因为可能还有其他在等待这个 key 的客户端）。
      一般每执行一个命令，Redis 都会对所有接收过数据并且至少有一个客户端在阻塞的 key 进行检查。
      这些 key 按照新的元素到达时间顺序排列。对于每个 key，在其清空之前 Redis 按照 FIFO 的顺序处理等待中的客户端。
      当 key 清空或者不再有客户端等待这个 key，Redis 才会开始下一个命令/脚本/事务的处理。

    在事务（MULTI/EXEC）中运行 BLPOP

    BLPOP 可以在 pipeline 中运行（发送多个命令，并且批量读取结果），然而这个命令仅在作为 pipeline 的最后一个命令时才有意义。
    在（MULTI/EXEC）事务中使用 BLPOP 一般没什么意义，因为他需要阻塞整个服务器来保证事务原子性的执行，此时其他的客户端也无法执行一个 push 操作。
    鉴于这个原因，在（MULTI/EXEC）事务中，当 BLPOP 等待的列表为空时，会直接返回 null。这跟等待超时的效果是一样的。

    如果你喜欢科幻小说，可以想象一下在（MULTI/EXEC）事务块中，时间以无限的长度流动……

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    Parameters

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

      以秒为单位的过期时间，双精度浮点数。

    Returns Promise<[string | Buffer, string]>

  • BLPOP 是阻塞版本的 ｜ LPOP 命令。

    • 当参数中指定的所有 list 都没有元素的时候，它会阻塞连接。
    • 当有 list 非空时，它会按照给定的 key 顺序从第一个非空 list 的头部弹出一个元素。
    • 当 timeout 被设置为 0 时表示不限时阻塞。
    • 超时后会返回 null。

    非阻塞行为

    当 BLPOP 被调用时，如果指定的 key 中至少有一个包含了非空列表，则会从其头部弹出一个元素并返回。

    考虑命令：

    await client.blpop(['list1', 'list2', 'list3'], 0)

    因为 list2 时这一系列 key 中第一个非空 list 是 list2，BLPOP 会保证返回 list2 的第一个元素。

    阻塞行为
    • 如果没有没有指定的 key 存在，BLPOP 会阻塞连接并等待其他客户端向其中某个 key 执行 LPUSH 或 RPUSH
      命令。
    • 一旦新的数据出现在列表中，客户端会结束阻塞，弹出元素并以数组形式返回 key 的名字和元素本身。
    • 当 BLPOP 命令引起了客户端阻塞并且设置了非零的阻塞时间，超时后会返回 null。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    哪一个 key/client/element 会被优先处理？优先级详情

    • 如果传递了多个 key，但是至少有一个 key 包含了元素。则返回的 key 是从左向右找到的第一个非空列表，此时不会发生阻塞。 所以对于命令：

      await client.blpop(['key1', 'key2', 'key3', 'key4'], 0)

      假设其中 key2 和 key4 是非空的，那么返回的是 key2 和它的第一个元素。

    • 如果多个客户端阻塞了相同的 key，优先被处理的客户端是等待时间最长的那个，也就是第一个产生阻塞的客户端。
      一旦这个客户端结束了阻塞，它将不会保留任何优先级，再次阻塞时从 0 开始记录阻塞时间。

    • 当客户端同时阻塞多个 key，并且元素同时在多个 key 中可用（因事务或Lua脚本同时向多个列表添加元素）时，
      将使用第一个接受 push 操作的 key 解除客户端的阻塞（假设它有足够的元素，因为可能还有其他在等待这个 key 的客户端）。
      一般每执行一个命令，Redis 都会对所有接收过数据并且至少有一个客户端在阻塞的 key 进行检查。
      这些 key 按照新的元素到达时间顺序排列。对于每个 key，在其清空之前 Redis 按照 FIFO 的顺序处理等待中的客户端。
      当 key 清空或者不再有客户端等待这个 key，Redis 才会开始下一个命令/脚本/事务的处理。

    在事务（MULTI/EXEC）中运行 BLPOP

    BLPOP 可以在 pipeline 中运行（发送多个命令，并且批量读取结果），然而这个命令仅在作为 pipeline 的最后一个命令时才有意义。
    在（MULTI/EXEC）事务中使用 BLPOP 一般没什么意义，因为他需要阻塞整个服务器来保证事务原子性的执行，此时其他的客户端也无法执行一个 push 操作。
    鉴于这个原因，在（MULTI/EXEC）事务中，当 BLPOP 等待的列表为空时，会直接返回 null。这跟等待超时的效果是一样的。

    如果你喜欢科幻小说，可以想象一下在（MULTI/EXEC）事务块中，时间以无限的长度流动……

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    Parameters

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

      以秒为单位的过期时间，双精度浮点数。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<[Buffer, Buffer]>

brpop

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

  • BRPOP 是阻塞版本的 ｜ RPOP 命令。

    BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    Parameters

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

      以秒为单位的过期时间，双精度浮点数。

    Returns Promise<null | [string | Buffer, string]>

  • BRPOP 是阻塞版本的 ｜ RPOP 命令。

    BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    Parameters

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

      以秒为单位的过期时间，双精度浮点数。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<null | [Buffer, Buffer]>

brpoplpush

  • brpoplpush(source: string | Buffer, destination: string | Buffer, timeout: number): Promise<null | string>
  • brpoplpush(source: string | Buffer, destination: string | Buffer, timeout: number, return_buffer: true): Promise<null | Buffer>

  • BRPOPLPUSH 是阻塞版本的 ｜ RPOPLPUSH 命令。

    • 当 source 包含元素的时候，此命令的行为和 ｜ RPOPLPUSH 一致，返回弹出的元素。
    • 在事务（MULTI/EXEC）中，此命令的行为和 ｜ RPOPLPUSH 一致，返回弹出的元素。
    • 超时后返回 null。

    BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    注意：6.2.0 增加了 BLMOVE 命令，BRPOPLPUSH 有可能被弃用。考虑使用 BLMOVE 替代 BRPOPLPUSH。

    Parameters

    • source: string | Buffer
    • destination: string | Buffer
    • timeout: number

      以秒为单位的过期时间，双精度浮点数。

    Returns Promise<null | string>

  • BRPOPLPUSH 是阻塞版本的 ｜ RPOPLPUSH 命令。

    • 当 source 包含元素的时候，此命令的行为和 ｜ RPOPLPUSH 一致，返回弹出的元素。
    • 在事务（MULTI/EXEC）中，此命令的行为和 ｜ RPOPLPUSH 一致，返回弹出的元素。
    • 超时后返回 null。

    BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。

    注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。

    注意：6.2.0 增加了 BLMOVE 命令，BRPOPLPUSH 有可能被弃用。考虑使用 BLMOVE 替代 BRPOPLPUSH。

    Parameters

    • source: string | Buffer
    • destination: string | Buffer
    • timeout: number

      以秒为单位的过期时间，双精度浮点数。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

lindex

  • lindex(key: string | Buffer, index: number): Promise<null | string>
  • lindex(key: string | Buffer, index: number, return_buffer: true): Promise<null | Buffer>
    • Redis官方文档：https://redis.io/commands/lindex
    • 起始版本：1.0.0
    • 时间复杂度：O(N) N 为到达 index 指定位置需要遍历的元素个数。所以访问 index 为 1 或 -1 的情况下，复杂度为 O(1)。

    返回指定列表的 index 处的元素。

    • index 是从 0 开始计算的。index 为 0 表示第一个元素，index 为 1 表示第二个元素，以此类推。
    • 当 index 为负数时，表示从 list 末端开始遍历。-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
    • 当指定的 key 不是 list 类型的时候抛出异常。
    • 当指定 index 超出列表长度限制返回 null。

    例子：

    await client.lpush('mylist', 'World')
// 1
await client.lpush('mylist', 'Hello')
// 2
await client.lindex('mylist', 0)
// "Hello"
await client.lindex('mylist', -1)
// "World"
await client.lindex('mylist', 3)
// null

    Parameters

    • key: string | Buffer
    • index: number

    Returns Promise<null | string>

    • Redis官方文档：https://redis.io/commands/lindex
    • 起始版本：1.0.0
    • 时间复杂度：O(N) N 为到达 index 指定位置需要遍历的元素个数。所以访问 index 为 1 或 -1 的情况下，复杂度为 O(1)。

    返回指定列表的 index 处的元素。

    • index 是从 0 开始计算的。index 为 0 表示第一个元素，index 为 1 表示第二个元素，以此类推。
    • 当 index 为负数时，表示从 list 末端开始遍历。-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
    • 当指定的 key 不是 list 类型的时候抛出异常。
    • 当指定 index 超出列表长度限制返回 null。

    例子：

    await client.lpush('mylist', 'World')
// 1
await client.lpush('mylist', 'Hello')
// 2
await client.lindex('mylist', 0)
// "Hello"
await client.lindex('mylist', -1)
// "World"
await client.lindex('mylist', 3)
// null

    Parameters

    • key: string | Buffer
    • index: number
    • return_buffer: true

      以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

linsert

  • linsert(key: string | Buffer, pos: "BEFORE" | "AFTER", pivot: string | Buffer, value: string | Buffer): Promise<number>
    • Redis官方文档：https://redis.io/commands/linsert
    • 起始版本：2.2.0
    • 时间复杂度：O(N) N 为到达指定位置 pivot 需要遍历的元素个数。这意味着从列表左侧插入元素为 O(1)，从右侧插入元素为 O(N)。

    在 list 指定位置 pivot 的前面或者后面插入 element。

    • 如果 key 不存在，则被认为是一个空 list，意味着什么也不会执行。
    • 当 key 存在但是值的类型不是 list，则会抛出异常。

    返回插入后的 list 长度。如果 没找到 pivot 则会返回 -1。

    例子：

    await client.rpush('mylist', 'Hello')
// 1
await client.rpush('mylist', 'World')
// 2
await client.linsert('mylist', 'BEFORE', 'World', 'There')
// 3
await client.lrange('mylist', 0, -1)
// ["Hello", "There", "World"]

    Parameters

    • key: string | Buffer
    • pos: "BEFORE" | "AFTER"
    • pivot: string | Buffer
    • value: string | Buffer

    Returns Promise<number>

llen

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

  • 返回指定 list 的长度。

    • 如果 key 不存在被认为是个空 list，长度为 0。
    • 如果 key 对应的值类型不是 list，抛出 WRONGTYPE 异常。

    例子：

    await client.lpush('mylist', 'World')
// 1
await client.lpush('mylist', 'Hello')
// 2
await client.llen('mylist')
// 2

    Parameters

    • key: string | Buffer

    Returns Promise<number>

lmove

  • lmove(src: string | Buffer, dest: string | Buffer, src_direct: "LEFT" | "RIGHT", dest_direct: "LEFT" | "RIGHT"): Promise<null | string>
  • lmove(src: string | Buffer, dest: string | Buffer, src_direct: "LEFT" | "RIGHT", dest_direct: "LEFT" | "RIGHT", return_buffer: true): Promise<null | Buffer>

  • 原子性的从 src 列表弹出一个元素并推入 dest 列表，并返回该元素。

    • 如果 src 不存在，返回 null。
    • 当 src 和 dest 相同时，可以认为这是一个列表循环移动的操作。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lmove('mylist', 'myotherlist', 'RIGHT', 'LEFT')
// "one"
await client.lmove('mylist', 'myotherlist', 'LEFT', 'RIGHT', true)
// <Buffer 6f 6e 65>，即 "two"
await client.lrange('mylist', 0, -1)
// ["two"]
await client.lrange('myotherlist', 0, -1)
// ["three", "one"]

    Parameters

    • src: string | Buffer

      源列表

    • dest: string | Buffer

      存储列表

    • src_direct: "LEFT" | "RIGHT"

      源列表弹出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。

    • dest_direct: "LEFT" | "RIGHT"

      源列表弹出方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。

    Returns Promise<null | string>

  • 原子性的从 src 列表弹出一个元素并推入 dest 列表，并返回该元素。

    • 如果 src 不存在，返回 null。
    • 当 src 和 dest 相同时，可以认为这是一个列表循环移动的操作。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lmove('mylist', 'myotherlist', 'RIGHT', 'LEFT')
// "one"
await client.lmove('mylist', 'myotherlist', 'LEFT', 'RIGHT', true)
// <Buffer 6f 6e 65>，即 "two"
await client.lrange('mylist', 0, -1)
// ["two"]
await client.lrange('myotherlist', 0, -1)
// ["three", "one"]

    Parameters

    • src: string | Buffer

      源列表

    • dest: string | Buffer

      存储列表

    • src_direct: "LEFT" | "RIGHT"

      源列表弹出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。

    • dest_direct: "LEFT" | "RIGHT"

      源列表弹出方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。

    • return_buffer: true

      以 Buffer 形式返回结果。

    Returns Promise<null | Buffer>

lpop

  • lpop(key: string | Buffer): Promise<string>
  • lpop(key: string | Buffer, return_buffer: true): Promise<Buffer>
  • lpop(key: string | Buffer, count: number): Promise<string[]>
  • lpop(key: string | Buffer, count: number, return_buffer: true): Promise<Buffer[]>

  • 从 list 左侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lpop('mylist')
// "one"
await client.lrange('mylist', 0, -1)
// ["two", "three"]

    Parameters

    • key: string | Buffer

    Returns Promise<string>

  • 从 list 左侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lpop('mylist')
// "one"
await client.lrange('mylist', 0, -1)
// ["two", "three"]

    Parameters

    • key: string | Buffer
    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<Buffer>

  • 从 list 左侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lpop('mylist')
// "one"
await client.lrange('mylist', 0, -1)
// ["two", "three"]

    Parameters

    • key: string | Buffer
    • count: number

      指定弹出元素的数量，6.2.0 及以上版本支持。

    Returns Promise<string[]>

  • 从 list 左侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lpop('mylist')
// "one"
await client.lrange('mylist', 0, -1)
// ["two", "three"]

    Parameters

    • key: string | Buffer
    • count: number

      指定弹出元素的数量，6.2.0 及以上版本支持。

    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<Buffer[]>

lpos

  • lpos(key: string | Buffer, element: string, options?: LposOptions): Promise<null | number>
  • lpos(key: string | Buffer, element: string, count: number, options?: LposOptions): Promise<number[]>
    • Redis官方文档：https://redis.io/commands/lpos
    • 起始版本：6.0.6
    • 时间复杂度：平均复杂度为 O(N) N 为列表的元素个数。当搜索结果临近列表头尾两端或者提供了 MAXLEN 参数时，运行时间可能是常量级的。

    返回匹配目标 element 的元素索引。默认会从头向尾遍历，当找不到 element 时，返回 null。

    关于 RANK 参数和 MAXLEN 参数说明见 LposOptions。

    例子：

    await client.rpush('mylist', 'a', 'b', 'c', 'd', '1', '2', '3', '4', '3', '3', '3')
// 11
await client.lpos('mylist', '3')
// 6
await client.lpos('mylist', '3', 0, { rank: 2 })
// [8, 9, 10]

    Parameters

    • key: string | Buffer
    • element: string
    • Optional options: LposOptions

    Returns Promise<null | number>

    • Redis官方文档：https://redis.io/commands/lpos
    • 起始版本：6.0.6
    • 时间复杂度：平均复杂度为 O(N) N 为列表的元素个数。当搜索结果临近列表头尾两端或者提供了 MAXLEN 参数时，运行时间可能是常量级的。

    返回匹配目标 element 的元素索引。默认会从头向尾遍历，当找不到 element 时，返回 null。

    关于 RANK 参数和 MAXLEN 参数说明见 LposOptions。

    例子：

    await client.rpush('mylist', 'a', 'b', 'c', 'd', '1', '2', '3', '4', '3', '3', '3')
// 11
await client.lpos('mylist', '3')
// 6
await client.lpos('mylist', '3', 0, { rank: 2 })
// [8, 9, 10]

    Parameters

    • key: string | Buffer
    • element: string
    • count: number

      需要返回的匹配元素数量。设置 count 参数会使返回值变为数组形式。

    • Optional options: LposOptions

    Returns Promise<number[]>

lpush

  • lpush(key: string | Buffer, ...values: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
    • Redis官方文档：https://redis.io/commands/lpush
    • 起始版本：1.0.0
    • 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。

    向指定 list 头部添加所有指定的 value。返回添加后的 list 长度。

    • 如果 key 不存在，会先创建一个空的 list。
    • 如果 key 存在但是类型不是 list，会抛出异常。

    注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。

    例子：

    await client.lpush('mylist', 'world')
// 1
await client.lpush('mylist', 'hello')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]

    Parameters

    • key: string | Buffer
    • Rest ...values: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

lpushx

  • lpushx(key: string | Buffer, ...values: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
    • Redis官方文档：https://redis.io/commands/lpushx
    • 起始版本：2.2.0
    • 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。

    仅当指定的 key 存在并且值为 list 时，向 list 头部添加所有指定的 value。返回添加后的 list 长度。

    • 如果 key 不存在或者 key 存在但是类型不是 list，不会执行任何操作。

    注意：早期版本只能推入一个值，4.0 及以上版本可以支持多个值的推入。

    例子：

    await client.lpush('mylist', 'World')
// 1
await client.lpushx('mylist', 'Hello')
// 2
await client.lpushx('myotherlist', "Hello")
// 0
await client.lrange('mylist', 0, -1)
// ["Hello", "World"]
await client.lrange('myotherlist', 0, -1)
// []

    Parameters

    • key: string | Buffer
    • Rest ...values: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

lrange

  • lrange(key: string | Buffer, start: number, stop: number): Promise<string[]>
  • lrange(key: string | Buffer, start: number, stop: number, return_buffer: true): Promise<Buffer[]>
    • Redis官方文档：https://redis.io/commands/lrange
    • 起始版本：1.0.0
    • 时间复杂度：O(S + N) S 是从列表头到 start 位置的距离，对于大列表是到最近的端的距离。N 是 start 到 end 的区间范围。

    返回指定 list 中指定范围的元素。

    • start 和 stop 是从 0 开始计数的索引值。
    • start 和 stop 也可以是负数，表示从末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素。
    • 超出 list 范围的索引不会引起异常。如果 start 大于 list 的最大索引，会返回一个空列表，stop 如果超出了 list 最大索引，Redis 会假装他是 list 的最后一个元素。

    注意：选取范围是 [start, stop] 的闭区间，即 start 和 stop 都是被包含在内的。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lrange('mylist', 0, 0)
// ["one"]
await client.lrange('mylist', -3, 2)
// ["one", "two", "three"]
await client.lrange('mylist', -100, 100)
// ["one", "two", "three"]
await client.lrange('mylist', 5, 10)
// []

    Parameters

    • key: string | Buffer
    • start: number

      选取范围左端索引值。

    • stop: number

      选取范围右端索引值。

    Returns Promise<string[]>

    • Redis官方文档：https://redis.io/commands/lrange
    • 起始版本：1.0.0
    • 时间复杂度：O(S + N) S 是从列表头到 start 位置的距离，对于大列表是到最近的端的距离。N 是 start 到 end 的区间范围。

    返回指定 list 中指定范围的元素。

    • start 和 stop 是从 0 开始计数的索引值。
    • start 和 stop 也可以是负数，表示从末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素。
    • 超出 list 范围的索引不会引起异常。如果 start 大于 list 的最大索引，会返回一个空列表，stop 如果超出了 list 最大索引，Redis 会假装他是 list 的最后一个元素。

    注意：选取范围是 [start, stop] 的闭区间，即 start 和 stop 都是被包含在内的。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lrange('mylist', 0, 0)
// ["one"]
await client.lrange('mylist', -3, 2)
// ["one", "two", "three"]
await client.lrange('mylist', -100, 100)
// ["one", "two", "three"]
await client.lrange('mylist', 5, 10)
// []

    Parameters

    • key: string | Buffer
    • start: number

      选取范围左端索引值。

    • stop: number

      选取范围右端索引值。

    • return_buffer: true

      是否以 Buffer 形式返回结果。

    Returns Promise<Buffer[]>

lrem

  • lrem(key: string | Buffer, count: number, element: string | Buffer): Promise<number>
    • Redis官方文档：https://redis.io/commands/lrem
    • 起始版本：1.0.0
    • 时间复杂度：O(N+M) N 是列表长度，M 是需要移除的元素个数。

    对指定 list 移除前 count 个匹配 element 的元素。返回移除元素的个数。

    • count 大于 0 时，从左侧开始匹配 element 进行移除操作。
    • count 小于 0 时，从右侧开始匹配 element 进行移除操作。
    • count 等于 0 时，移除全部匹配 element 的元素。

    注意：不存在的 key 会被认为是空的 list，所以移除元素的个数为 0。

    例子：

    await client.rpush('mylist', 'hello')
// 1
await client.rpush('mylist', 'hello')
// 2
await client.rpush('mylist', 'foo')
// 3
await client.rpush('mylist', 'hello')
// 4
await client.lrem('mylist', -2, 'hello')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "foo"]

    Parameters

    • key: string | Buffer
    • count: number
    • element: string | Buffer

    Returns Promise<number>

lset

  • lset(key: string | Buffer, index: number, value: string | Buffer): Promise<"OK">
    • Redis官方文档：https://redis.io/commands/lset
    • 起始版本：1.0.0
    • 时间复杂度：O(N) N 是 list 的长度。设置第一个或最后一个元素的时间为 O(1)。

    设置 list 指定索引的元素。对于 list 索引的更多信息见 LINDEX。

    • 对于超出 list 范围的索引会抛出异常。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.lset('mylist', 0,'four')
// "OK"
await client.lset('mylist', -2, 'five')
// "OK"
await client.lrange('mylist', 0, -1)
// ["four", "five", "three"]

    Parameters

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

    Returns Promise<"OK">

ltrim

  • ltrim(key: string | Buffer, start: number, stop: number): Promise<"OK">

  • 裁剪指定 list，返回 OK。裁剪后 list 只包含参数指定范围的元素。

    • start 和 stop 都是从 0 计数的索引。
    • start 和 stop 都可以使用负数索引。详见 LINDEX 命令说明。
    • 超出范围的索引不会引起异常，start 超过 list 范围会生成空列表，stop 超过 list 范围会被认为 stop 就是 list 最后一个元素。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.ltrim('mylist', 1, -1)
// "OK"
await client.lrange('mylist', 0, -1)
// ["two", "three"]

    Parameters

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

    Returns Promise<"OK">

rpop

  • rpop(key: string | Buffer): Promise<string>
  • rpop(key: string | Buffer, return_buffer: true): Promise<Buffer>
  • rpop(key: string | Buffer, count: number): Promise<string[]>
  • rpop(key: string | Buffer, count: number, return_buffer: true): Promise<Buffer[]>

  • 从 list 右侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.rpop('mylist')
// "three"
await client.lrange('mylist', 0, -1)
// ["one", "two"]

    Parameters

    • key: string | Buffer

    Returns Promise<string>

  • 从 list 右侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.rpop('mylist')
// "three"
await client.lrange('mylist', 0, -1)
// ["one", "two"]

    Parameters

    • key: string | Buffer
    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<Buffer>

  • 从 list 右侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.rpop('mylist')
// "three"
await client.lrange('mylist', 0, -1)
// ["one", "two"]

    Parameters

    • key: string | Buffer
    • count: number

      指定弹出元素的数量，6.2.0 及以上版本支持。

    Returns Promise<string[]>

  • 从 list 右侧移除并返回一个或多个值。

    • 使用 count 参数时会返回一个列表，key 不存在则返回 null。
    • 不用 count 的时候返回单个值。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.rpop('mylist')
// "three"
await client.lrange('mylist', 0, -1)
// ["one", "two"]

    Parameters

    • key: string | Buffer
    • count: number

      指定弹出元素的数量，6.2.0 及以上版本支持。

    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<Buffer[]>

rpoplpush

  • rpoplpush(source: string | Buffer, destination: string | Buffer): Promise<null | string>
  • rpoplpush(source: string | Buffer, destination: string | Buffer, return_buffer: true): Promise<null | Buffer>

  • 原子性的从源列表末尾弹出一个值，并推入存储列表头部。返回这个值。

    • 如果源列表不存在，返回 null 并且不会执行任何操作。
    • 源列表和存储列表可以相同。

    注意：在 6.2 版本此命令可能会被废弃，使用 LMOVE 命令替代。

    例子：

    await client.rpush('mylist', 'one')
// 1
await client.rpush('mylist', 'two')
// 2
await client.rpush('mylist', 'three')
// 3
await client.rpoplpush('mylist', 'myotherlist')
// "three"
await client.lrange('mylist', 0, -1)
// ["one", "two"]
await client.lrange('myotherlist', 0, -1)
// ["three"]

    Parameters

    • source: string | Buffer
    • destination: string | Buffer

    Returns Promise<null | string>

    • Redis官方文档：https://redis.io/commands/rpush
    • 起始版本：1.0.0
    • 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。

    向指定 list 末尾添加所有指定的 value。返回添加后的 list 长度。

    • 如果 key 不存在，会先创建一个空的 list。
    • 如果 key 存在但是类型不是 list，会抛出异常。

    注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。

    例子：

    await client.rpush('mylist', 'hello')
// 1
await client.rpush('mylist', 'world')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]
    category

    List

    Parameters

    • source: string | Buffer
    • destination: string | Buffer
    • return_buffer: true

      是否以 Buffer 形式返回。

    Returns Promise<null | Buffer>

rpush

  • rpush(key: string | Buffer, ...values: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
    • Redis官方文档：https://redis.io/commands/rpush
    • 起始版本：1.0.0
    • 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。

    向指定 list 末尾添加所有指定的 value。返回添加后的 list 长度。

    • 如果 key 不存在，会先创建一个空的 list。
    • 如果 key 存在但是类型不是 list，会抛出异常。

    注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。

    例子：

    await client.rpush('mylist', 'hello')
// 1
await client.rpush('mylist', 'world')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]

    Parameters

    • key: string | Buffer
    • Rest ...values: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

rpushx

  • rpushx(key: string | Buffer, ...values: [string | Buffer, ...(string | Buffer)[]]): Promise<number>
    • Redis官方文档：https://redis.io/commands/lpushx
    • 起始版本：2.2.0
    • 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。

    仅当指定的 key 存在并且值为 list 时，向 list 末尾添加所有指定的 value。返回添加后的 list 长度。

    • 如果 key 不存在或者 key 存在但是类型不是 list，不会执行任何操作。

    注意：早期版本只能推入一个值，4.0 及以上版本可以支持多个值的推入。

    例子：

    await client.rpush('mylist', 'Hello')
// 1
await client.rpushx('mylist', 'World')
// 2
await client.rpushx('myotherlist', "World")
// 0
await client.lrange('mylist', 0, -1)
// ["Hello", "World"]
await client.lrange('myotherlist', 0, -1)
// []

    Parameters

    • key: string | Buffer
    • Rest ...values: [string | Buffer, ...(string | Buffer)[]]

    Returns Promise<number>

Other Methods

on

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

  • Parameters

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

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns RedisListClient

once

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

  • Parameters

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

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns RedisListClient

Server Methods

info

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

Generated using TypeDoc