- Redis官方文档：https://redis.io/commands/echo
- 起始版本：1.0.0
直接返回 msg 本身。
例子：
await client.echo('Hello World!')
// "Hello World!"
- Redis官方文档：https://redis.io/commands/ping
- 起始版本：1.0.0
如果没有提供参数返回 PONG。否则返回 msg 本身。
例子：
await client.ping()
// "PONG"
await client.ping('Hello World!')
// "Hello World!"
需要发送的信息，
- Redis官方文档：https://redis.io/commands/quit
- 起始版本：1.0.0
请求 Redis server 关闭连接。
始终返回 OK。
- Redis官方文档：https://redis.io/commands/copy
- 起始版本：6.2.0
- 时间复杂度：对于 string 类型是 O(1), 对于集合类型的值为 O(N), N 为嵌套元素个数。
将 source 的值复制到 destination。
默认情况下，destination 会创建在连接当前所持有的逻辑 database 上。通过 db 选项，可以指定需要创建在哪个逻辑 database。
当 destination 已经存在的情况下，COPY 命令会返回一个错误。可以通过 replace 选项移除原来的 destination。
0 复制失败。1 复制成功。例子：
await client.set('dolly', 'sheep')
// "OK"
await client.copy('dolly', 'clone')
// 1
await client.get('clone')
// "sheep"
- Redis官方文档：https://redis.io/commands/copy
- 起始版本：6.2.0
- 时间复杂度：对于 string 类型是 O(1), 对于集合类型的值为 O(N), N 为嵌套元素个数。
将 source 的值复制到 destination。
默认情况下，destination 会创建在连接当前所持有的逻辑 database 上。通过 db 选项，可以指定需要创建在哪个逻辑 database。
当 destination 已经存在的情况下，COPY 命令会返回一个错误。可以通过 replace 选项移除原来的 destination。
0 复制失败。1 复制成功。例子：
await client.set('dolly', 'sheep')
// "OK"
await client.copy('dolly', 'clone')
// 1
await client.get('clone')
// "sheep"
默认将 destination 创建在当前 db，如果需要更换 db 可以使用此选项。
- Redis官方文档：https://redis.io/commands/copy
- 起始版本：6.2.0
- 时间复杂度：对于 string 类型是 O(1), 对于集合类型的值为 O(N), N 为嵌套元素个数。
将 source 的值复制到 destination。
默认情况下，destination 会创建在连接当前所持有的逻辑 database 上。通过 db 选项，可以指定需要创建在哪个逻辑 database。
当 destination 已经存在的情况下，COPY 命令会返回一个错误。可以通过 replace 选项移除原来的 destination。
0 复制失败。1 复制成功。例子：
await client.set('dolly', 'sheep')
// "OK"
await client.copy('dolly', 'clone')
// 1
await client.get('clone')
// "sheep"
是否添加 REPLACE 标签。
- Redis官方文档：https://redis.io/commands/copy
- 起始版本：6.2.0
- 时间复杂度：对于 string 类型是 O(1), 对于集合类型的值为 O(N), N 为嵌套元素个数。
将 source 的值复制到 destination。
默认情况下，destination 会创建在连接当前所持有的逻辑 database 上。通过 db 选项，可以指定需要创建在哪个逻辑 database。
当 destination 已经存在的情况下，COPY 命令会返回一个错误。可以通过 replace 选项移除原来的 destination。
0 复制失败。1 复制成功。例子：
await client.set('dolly', 'sheep')
// "OK"
await client.copy('dolly', 'clone')
// 1
await client.get('clone')
// "sheep"
默认将 destination 创建在当前 db，如果需要更换 db 可以使用此选项。
是否添加 REPLACE 标签。
- Redis官方文档：https://redis.io/commands/del
- 起始版本：1.0.0
- 时间复杂度：O(N)，N 为需要删除的 key 的个数。
从当前 db 删除 key，不存在的 key 会被忽略。
返回删除的成员数，不包括不存在的 key。
例子：
await client.set('key1', 'Hello')
// "OK"
await client.set('key2', 'World')
// "OK"
await client.del('key1', 'key2', 'nonexists')
// 2
需要删除的 key 列表。
- Redis官方文档：https://redis.io/commands/dump
- 起始版本：2.6.0
- 时间复杂度：访问 key 为 O(1), 之后需要额外的 O(N * M) 进行序列化。N 为 组成该值的 Redis 对象数量，M 为他们的平均大小。对于小的 string 类型的值，时间复杂度为 O(1) + O(1 * M)，而 M 又很小，可以简化为 O(1)。
序列化导出 key 处的值。当 key 不存在返回 null。
可以使用 RESTORE 命令可以进行反序列化并存储。
Redis 采用了一种非标准不透明的序列化方式，它的语义上有一些特点，如下：
序列化的值不包含任何 TTL 信息。
序列化后的结果，可能无法编码为字符串，所以直接返回 Buffer。对于不存在的 key 返回 null。
例子：
await client.set('mykey', '10')
// "OK"
await client.dump('mykey')
// <Buffer 00 c0 0a 09 00 be 6d 06 89 5a 28 00 0a>
- Redis官方文档：https://redis.io/commands/exists
- 起始版本：1.0.0
- 时间复杂度：O(1)
判断 key 是否存在
3.0.3 版本开始可以传递多个 key。此时会返回存在的 key 的个数。 因为对于单个 key 的使用场景，1 表示存在一个 key，所以这个改动是完全向后兼容的。
注意：如果在参数中有重复的 key 并且这个 key 是存在的，那么最终计数会对这个 key 统计多次。
1：当 key 存在。0：当 key 不存在。例子：
await client.set('key1', 'Hello')
// "OK"
await client.exists('key1')
// 1
await client.exists('nosuchkey')
// 0
await client.set('key2', 'World')
// "OK"
await client.exists('key1', 'key2', 'nosuchkey')
// 2
await client.exists('key1', 'key1', 'key1')
// 3
需要检查的 key。3.0.3 版本开始支持传递多个 key。
- Redis官方文档：https://redis.io/commands/expire
- 起始版本：1.0.0
- 时间复杂度：O(1)
对 key 设置一个过期时间。当 key 到期后会被自动删除。
在 Redis 术语中，这种带有过期时间的 key 被称为 volatile 的 key。
在执行重写 key 值的命令的时候，比如 DEL，SET，GETSET 和 *STORE 的命令，会清除过期时间。
这意味着所有在概念上更改存储在 key 上的值而不是用新 key 替换旧 key 的操作都将保持过期时间不变。
例如：INCR，LPUSH，HSET。
可以使用 PERSIST 命令清除过期时间。
如果通过 RENAME 命令进行重命名，则旧 key 的过期时间会被赋给新的 key。
此时如果新的 key 已经存在，则它的过期时间会被旧的 key 覆盖。
注意：使用一个负数参数调用 EXPIRE/PEXPIRE 命令时，实际执行的是删除操作。此时收到的 key event 是删除，而不是过期。
EXPIRE 命令可以作用于一进存在过期时间的 key。此时会用新的过期时间覆盖旧的。
一个常见的例子是【导航会话】模式。
2.1.3 版本之前，修改一个带有过期时间的 key 会导致这个 key 被删除，这是受当时复制层的限制而导致的。而这一限制已经被修复，所以 2.1.3 版本开始可以修改带有过期时间的 key。
1：ttl 设置成功。0：key 不存在，或者不能设置过期时间时。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.expire('mykey', 10)
// 1
await client.ttl('mykey')
// 10
await client.set('mykey', 'Hello World')
// "OK"
await client.ttl('mykey')
// -1
需要设置的超时时间。
- Redis官方文档：https://redis.io/commands/expireat
- 起始版本：1.2.0
- 时间复杂度：O(1)
EXPIREAT 的行为和语义跟 EXPIRE 一样，区别是 EXPIREAT 的超时参数是时间戳形式。
它使用 UNIX Timestamp（1970年1月1日0时开始的秒数）。
传递一个过去的时间戳会导致直接删除这个 key。
关于过期时间的语义详情参考 EXPIRE 命令。
EXPIREAT 的引入是为了在 AOF 持久化模式中，将相对过期时间转换为绝对过期时间。当然，它也可以用来直接指定一个 key 的过期时间点。
1：ttl 设置成功。0：key 不存在，或者不能设置过期时间。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.exists('mykey')
// 1
await client.expireat('mykey', 1293840000)
// 1
await client.exists('mykey')
// 0
需要设置的过期时间戳。
- Redis官方文档：https://redis.io/commands/keys
- 起始版本：1.0.0
- 时间复杂度：O(N)，N 为当前库中 key 的个数。
查找匹配 pattern 的 key。
这个命令的时间复杂度是 O(N)，常量部分很小。举个例子，在一般入门级笔记本上，Redis 可以在 40 毫秒的时间内浏览 100 万个 key。
警告： 这是一个方便调试的命令，当你对一个庞大的库使用这个命令时，会导致性能极其低下。
支持的 glob 风格 patterns:
h?llo 匹配 hello, hallo 和 hxllo。h*llo 匹配 hllo 和 heeeello。h[ae]llo 匹配 hello，hallo，但是 hillo 不行。h[^e]llo 匹配 hallo， hbllo，但是 hello 不行。h[a-b]llo 匹配 hallo 和 hbllo。返回匹配 pattern 的字符串数组。
例子：
await client.mset({ firstname: 'Jack', lastname: 'Stuntman', age: '35' })
// "OK"
await client.keys('*name*')
// ["lastname", "firstname"]
await client.keys('a??')
// ["age"]
await client.keys('*')
// ["lastname", "firstname", "age"]
glob 风格匹配模式。
- Redis官方文档：https://redis.io/commands/keys
- 起始版本：1.0.0
- 时间复杂度：O(N)，N 为当前库中 key 的个数。
查找匹配 pattern 的 key。
这个命令的时间复杂度是 O(N)，常量部分很小。举个例子，在一般入门级笔记本上，Redis 可以在 40 毫秒的时间内浏览 100 万个 key。
警告： 这是一个方便调试的命令，当你对一个庞大的库使用这个命令时，会导致性能极其低下。
支持的 glob 风格 patterns:
h?llo 匹配 hello, hallo 和 hxllo。h*llo 匹配 hllo 和 heeeello。h[ae]llo 匹配 hello，hallo，但是 hillo 不行。h[^e]llo 匹配 hallo， hbllo，但是 hello 不行。h[a-b]llo 匹配 hallo 和 hbllo。返回匹配 pattern 的字符串数组。
例子：
await client.mset({ firstname: 'Jack', lastname: 'Stuntman', age: '35' })
// "OK"
await client.keys('*name*')
// ["lastname", "firstname"]
await client.keys('a??')
// ["age"]
await client.keys('*')
// ["lastname", "firstname", "age"]
glob 风格匹配模式。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/migrate
- 起始版本：2.6.0
- 时间复杂度：该命令实际上在源实例中执行了 DUMP + DEL，之后在目标实例中执行 RESTORE。
这部分的时间复杂度，请参见这些命令的页面。在两个实例之间数据传输的复杂度为O(N)。
将 key 原子性的传输到目标 Redis 实例，成功后删除源 key。
在传输 key 的过程中，MIGRATE 命令会阻塞源实例和目标实例，任意时间 key 会存在源实例和目标实例中的一个。除非发生超时错误。
MIGRATE 内部使用了 DUMP 进行序列化，之后使用 RESTORE 将值同步到目标实例上。
如果收到了目标实例上执行 RESTORE 命令返回的 "OK"，则使用 DEL 删除源值。
timeout 参数指定了与目标实例交互的最长空闲时间，单位毫秒。这意味着这个命令不是必须在 timeout 时间内执行完，但是传输阻塞时间不能超过 timeout。
MIGRATE 命令需要执行带有超时限制的 I/O 操作。当 I/O 超时，或者发生了 I/O 异常，操作会被终止。此时可能出现两种情况。
超时并不会导致 key 丢失，但是需要检查是否已经存在于目标实例，并采取相应的措施。
当返回除此之外的其他异常时，MIGRATE 命令保证任何时刻 key 会且只会存在于源或者目标中的一个实例上（除非目标实例中已经存在相同 key）。
如果指定的一系列 key 在源实例上都不存在，会返回 "NOKEY"。因为正常情况下可能会丢失 key，比如因为到期。所以没有 key 可以传输并不是一个异常。
在 3.0.6 版本开始增加了批量迁移模式，通过管道批量进行迁移，以节省往返通信及其他间接的消耗。RedisGenericClient.migrate 会自动检测传入的 key 个数，判断是否使用批量迁移模式。
当启用了批量迁移模式时，只有当没有任何一个 key 可以被迁移时才会返回 NOKEY 状态，否则只要有至少一个 key 可以迁移，就会执行命令。
>= 3.0.0：添加了 copy 和 replace 选项。
>= 3.0.6：支持批量迁移模式。
>= 4.0.7：增加了 auth 选项，可以通过 password 进行认证。
>= 6.0.0：增加了新的 auth 模式，可以同时提供 username 和 password。
"OK""NOKEY"目标实例地址。
目标实例端口号。
需要传输的 key 列表，在 3.0.6 以上的版本可以支持多个 key 传输。
目标实例的数据库。
超时时间，单位毫秒。
选项
- Redis官方文档：https://redis.io/commands/move
- 起始版本：2.6.0
- 时间复杂度：O(1)
将密钥从当前选定的数据库（请参见[[@link RedisClient.select | SELECT]]）移动到指定的目标数据库。
如果目标数据库中已经存在密钥，或者源数据库中不存在密钥，则它什么都不做。 因此，可以将 MOVE 用作锁定原语。
1 key 移动成功。0 key 没有移动。
- Redis官方文档：https://redis.io/commands/object
- 起始版本：2.2.3
- 时间复杂度：O(1)
OBJECT 命令允许检查 Redis 对象的内部形式。这对于调试或者需要了解 key 是否使用了特殊编码来节省空间时特别有用。 将 Redis 用作缓存时，还可以根据 OBJECT 命令的报告实现应用级的密钥回收策略。
OBJECT 命令支持下列四种子命令：
REFCOUNT 返回值的引用数，主要用于调试。
ENCODING 返回内部存储值使用的编码形式。
IDLETIME 返回指定 key 的空闲（没有读写操作）时间，单位秒。但是此计时器的实际分辨率是 10 秒。未来可能会做改进。 当 maxmemory-policy 设置为 LRU 或者 noeviction 并且设置了
maxmemory 时，此子命令可用。
FREQ 返回 key 对应的对数访问频率计数器。当 maxmemory-policy 设为 LFU 可用。
HELP 返回简单的帮助文本。
raw（常规字符串编码），embstr （专门用于保存短字符串）或 int（以64位有符号间隔表示整数的字符串以这种方式编码，以节省空间）。ziplist 或 linkedlist。ziplist 是一种特殊的表示形式，用于节省小 list 的空间。intset 或 hashtable。intset 是一种特殊的编码，用于仅由整数组成的小 set。ziplist 或 hashtable。ziplist 是用于小 hash 的特殊编码。ziplist 或 skiplist 格式。ziplist 适用于小的 list 和 zset，skiplist 编码则适用于任何大小的 zset。一旦执行了使 Redis 无法保留节省空间编码的操作，所有特殊编码类型会被自动转换为通用编码类型。
不同的子命令有不同的返回值。详见不同子命令的定义。 当要检查的 object 不存在，会返回 null。
例子：
await client.lpush('mylist', 'Hello World')
// 1
await client.object('REFCOUNT', 'mylist')
// 1
await client.object('ENCODING', 'mylist')
// "quicklist"
await client.object('IDLETIME', 'mylist')
// 0
下面的例子展示了编码是如何变化的：
await client.set('foo', '1000')
// "OK"
await client.object('ENCODING', 'foo')
// "int"
await client.append('foo', 'bar')
// 7
await client.get('foo')
// "1000bar"
await client.object('ENCODING', 'foo')
// "raw"
调试命令：返回与指定 key 关联的值的引用计数。
- Redis官方文档：https://redis.io/commands/object
- 起始版本：2.2.3
- 时间复杂度：O(1)
OBJECT 命令允许检查 Redis 对象的内部形式。这对于调试或者需要了解 key 是否使用了特殊编码来节省空间时特别有用。 将 Redis 用作缓存时，还可以根据 OBJECT 命令的报告实现应用级的密钥回收策略。
OBJECT 命令支持下列四种子命令：
REFCOUNT 返回值的引用数，主要用于调试。
ENCODING 返回内部存储值使用的编码形式。
IDLETIME 返回指定 key 的空闲（没有读写操作）时间，单位秒。但是此计时器的实际分辨率是 10 秒。未来可能会做改进。 当 maxmemory-policy 设置为 LRU 或者 noeviction 并且设置了
maxmemory 时，此子命令可用。
FREQ 返回 key 对应的对数访问频率计数器。当 maxmemory-policy 设为 LFU 可用。
HELP 返回简单的帮助文本。
raw（常规字符串编码），embstr （专门用于保存短字符串）或 int（以64位有符号间隔表示整数的字符串以这种方式编码，以节省空间）。ziplist 或 linkedlist。ziplist 是一种特殊的表示形式，用于节省小 list 的空间。intset 或 hashtable。intset 是一种特殊的编码，用于仅由整数组成的小 set。ziplist 或 hashtable。ziplist 是用于小 hash 的特殊编码。ziplist 或 skiplist 格式。ziplist 适用于小的 list 和 zset，skiplist 编码则适用于任何大小的 zset。一旦执行了使 Redis 无法保留节省空间编码的操作，所有特殊编码类型会被自动转换为通用编码类型。
不同的子命令有不同的返回值。详见不同子命令的定义。 当要检查的 object 不存在，会返回 null。
例子：
await client.lpush('mylist', 'Hello World')
// 1
await client.object('REFCOUNT', 'mylist')
// 1
await client.object('ENCODING', 'mylist')
// "quicklist"
await client.object('IDLETIME', 'mylist')
// 0
下面的例子展示了编码是如何变化的：
await client.set('foo', '1000')
// "OK"
await client.object('ENCODING', 'foo')
// "int"
await client.append('foo', 'bar')
// 7
await client.get('foo')
// "1000bar"
await client.object('ENCODING', 'foo')
// "raw"
返回用于存储与键关联的值的内部表示形式的类型。
- Redis官方文档：https://redis.io/commands/object
- 起始版本：2.2.3
- 时间复杂度：O(1)
OBJECT 命令允许检查 Redis 对象的内部形式。这对于调试或者需要了解 key 是否使用了特殊编码来节省空间时特别有用。 将 Redis 用作缓存时，还可以根据 OBJECT 命令的报告实现应用级的密钥回收策略。
OBJECT 命令支持下列四种子命令：
REFCOUNT 返回值的引用数，主要用于调试。
ENCODING 返回内部存储值使用的编码形式。
IDLETIME 返回指定 key 的空闲（没有读写操作）时间，单位秒。但是此计时器的实际分辨率是 10 秒。未来可能会做改进。 当 maxmemory-policy 设置为 LRU 或者 noeviction 并且设置了
maxmemory 时，此子命令可用。
FREQ 返回 key 对应的对数访问频率计数器。当 maxmemory-policy 设为 LFU 可用。
HELP 返回简单的帮助文本。
raw（常规字符串编码），embstr （专门用于保存短字符串）或 int（以64位有符号间隔表示整数的字符串以这种方式编码，以节省空间）。ziplist 或 linkedlist。ziplist 是一种特殊的表示形式，用于节省小 list 的空间。intset 或 hashtable。intset 是一种特殊的编码，用于仅由整数组成的小 set。ziplist 或 hashtable。ziplist 是用于小 hash 的特殊编码。ziplist 或 skiplist 格式。ziplist 适用于小的 list 和 zset，skiplist 编码则适用于任何大小的 zset。一旦执行了使 Redis 无法保留节省空间编码的操作，所有特殊编码类型会被自动转换为通用编码类型。
不同的子命令有不同的返回值。详见不同子命令的定义。 当要检查的 object 不存在，会返回 null。
例子：
await client.lpush('mylist', 'Hello World')
// 1
await client.object('REFCOUNT', 'mylist')
// 1
await client.object('ENCODING', 'mylist')
// "quicklist"
await client.object('IDLETIME', 'mylist')
// 0
下面的例子展示了编码是如何变化的：
await client.set('foo', '1000')
// "OK"
await client.object('ENCODING', 'foo')
// "int"
await client.append('foo', 'bar')
// 7
await client.get('foo')
// "1000bar"
await client.object('ENCODING', 'foo')
// "raw"
返回指定 key 处的对象自存储以来处于空闲状态的秒数（读或写操作未请求）。
虽然以秒为单位返回该值，但此计时器的实际分辨率为 10 秒，这在将来的实现中可能会有所不同。
当 maxmemory-policy 设置为 LRU 策略或 noeviction 并且设置了 maxmemory 时，此子命令可用。
- Redis官方文档：https://redis.io/commands/object
- 起始版本：2.2.3
- 时间复杂度：O(1)
OBJECT 命令允许检查 Redis 对象的内部形式。这对于调试或者需要了解 key 是否使用了特殊编码来节省空间时特别有用。 将 Redis 用作缓存时，还可以根据 OBJECT 命令的报告实现应用级的密钥回收策略。
OBJECT 命令支持下列四种子命令：
REFCOUNT 返回值的引用数，主要用于调试。
ENCODING 返回内部存储值使用的编码形式。
IDLETIME 返回指定 key 的空闲（没有读写操作）时间，单位秒。但是此计时器的实际分辨率是 10 秒。未来可能会做改进。 当 maxmemory-policy 设置为 LRU 或者 noeviction 并且设置了
maxmemory 时，此子命令可用。
FREQ 返回 key 对应的对数访问频率计数器。当 maxmemory-policy 设为 LFU 可用。
HELP 返回简单的帮助文本。
raw（常规字符串编码），embstr （专门用于保存短字符串）或 int（以64位有符号间隔表示整数的字符串以这种方式编码，以节省空间）。ziplist 或 linkedlist。ziplist 是一种特殊的表示形式，用于节省小 list 的空间。intset 或 hashtable。intset 是一种特殊的编码，用于仅由整数组成的小 set。ziplist 或 hashtable。ziplist 是用于小 hash 的特殊编码。ziplist 或 skiplist 格式。ziplist 适用于小的 list 和 zset，skiplist 编码则适用于任何大小的 zset。一旦执行了使 Redis 无法保留节省空间编码的操作，所有特殊编码类型会被自动转换为通用编码类型。
不同的子命令有不同的返回值。详见不同子命令的定义。 当要检查的 object 不存在，会返回 null。
例子：
await client.lpush('mylist', 'Hello World')
// 1
await client.object('REFCOUNT', 'mylist')
// 1
await client.object('ENCODING', 'mylist')
// "quicklist"
await client.object('IDLETIME', 'mylist')
// 0
下面的例子展示了编码是如何变化的：
await client.set('foo', '1000')
// "OK"
await client.object('ENCODING', 'foo')
// "int"
await client.append('foo', 'bar')
// 7
await client.get('foo')
// "1000bar"
await client.object('ENCODING', 'foo')
// "raw"
返回存储在指定键处的对象的对数访问频率计数器。
当 maxmemory-policy 设置为 LFU 策略时，此子命令可用。
- Redis官方文档：https://redis.io/commands/object
- 起始版本：2.2.3
- 时间复杂度：O(1)
OBJECT 命令允许检查 Redis 对象的内部形式。这对于调试或者需要了解 key 是否使用了特殊编码来节省空间时特别有用。 将 Redis 用作缓存时，还可以根据 OBJECT 命令的报告实现应用级的密钥回收策略。
OBJECT 命令支持下列四种子命令：
REFCOUNT 返回值的引用数，主要用于调试。
ENCODING 返回内部存储值使用的编码形式。
IDLETIME 返回指定 key 的空闲（没有读写操作）时间，单位秒。但是此计时器的实际分辨率是 10 秒。未来可能会做改进。 当 maxmemory-policy 设置为 LRU 或者 noeviction 并且设置了
maxmemory 时，此子命令可用。
FREQ 返回 key 对应的对数访问频率计数器。当 maxmemory-policy 设为 LFU 可用。
HELP 返回简单的帮助文本。
raw（常规字符串编码），embstr （专门用于保存短字符串）或 int（以64位有符号间隔表示整数的字符串以这种方式编码，以节省空间）。ziplist 或 linkedlist。ziplist 是一种特殊的表示形式，用于节省小 list 的空间。intset 或 hashtable。intset 是一种特殊的编码，用于仅由整数组成的小 set。ziplist 或 hashtable。ziplist 是用于小 hash 的特殊编码。ziplist 或 skiplist 格式。ziplist 适用于小的 list 和 zset，skiplist 编码则适用于任何大小的 zset。一旦执行了使 Redis 无法保留节省空间编码的操作，所有特殊编码类型会被自动转换为通用编码类型。
不同的子命令有不同的返回值。详见不同子命令的定义。 当要检查的 object 不存在，会返回 null。
例子：
await client.lpush('mylist', 'Hello World')
// 1
await client.object('REFCOUNT', 'mylist')
// 1
await client.object('ENCODING', 'mylist')
// "quicklist"
await client.object('IDLETIME', 'mylist')
// 0
下面的例子展示了编码是如何变化的：
await client.set('foo', '1000')
// "OK"
await client.object('ENCODING', 'foo')
// "int"
await client.append('foo', 'bar')
// 7
await client.get('foo')
// "1000bar"
await client.object('ENCODING', 'foo')
// "raw"
返回 OBJECT 命令的一个简洁说明。
- Redis官方文档：https://redis.io/commands/persist
- 起始版本：2.2.0
- 时间复杂度：O(1)
移除存在于 key 上的过期时间，将 key 从 volatile 变成 persistent。
1 成功清除 ttl。0 当 key 不存在或存在但未设置 ttl。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.expire('mykey', 10)
// 1
await client.ttl('mykey')
// 10
await client.persist('mykey')
// 1
await client.ttl('mykey')
// -1
- Redis官方文档：https://redis.io/commands/pexpire
- 起始版本：2.6.0
- 时间复杂度：O(1)
效果和 EXPIRE 一样，区别是 PEXPIRE 的 ttl 是毫秒单位。
返回值含义：
1 ttl 设置成功。0 key 不存在，设置失败。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.pexpire('mykey', 1500)
// 1
await client.ttl('mykey')
// 1
await client.pttl('mykey')
// 1411
需要设置的超时时间，单位毫秒。
- Redis官方文档：https://redis.io/commands/pexpireat
- 起始版本：2.6.0
- 时间复杂度：O(1)
效果和 EXPIREAT 一样，区别是 PEXPIREAT 的到期时间戳是毫秒单位的。
返回值含义：
1 ttl 设置成功。0 key 不存在，设置失败。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.pexpireat('mykey', 1555555555005)
// 1
await client.ttl('mykey')
// -2
await client.pttl('mykey')
// -2
需要设置的过期时间戳，单位毫秒。
- Redis官方文档：https://redis.io/commands/pttl
- 起始版本：2.6.0
- 时间复杂度：O(1)
像 TTL 命令一样，返回剩余有效时间。唯一区别是，PTTL 使用毫秒级时间戳。
2.6 及更早的版本中，key 不存在或者未设置过期时间，都会返回 -1。
从 2.8 版本开始：
例子：
await client.set('mykey', 'Hello')
// "OK"
await client.expire('mykey', 1)
// 1
await client.pttl('mykey')
// 957
- Redis官方文档：https://redis.io/commands/randomkey
- 起始版本：1.0.0
- 时间复杂度：O(1)
随机返回一个当前连接持有的 db 的 key。当 database 为空时返回 null。
- Redis官方文档：https://redis.io/commands/rename
- 起始版本：1.0.0
- 时间复杂度：O(1)
重命名 key 到 newkey。当 key 不存在时抛出异常。
在集群模式中，key 和 newkey 都必须在同一个 hash slot 中，这意味着在集群中，具有相同的 hash tag 的的 key 才能被可靠的重命名。
<= 3.2.0：如果 key 和 newkey 相同，会抛出异常。
例子：
await client.set('mykey', 'Hello')
// "OK"
await client.rename('mykey', 'myotherkey')
// "OK"
await client.get('myotherkey')
// "Hello"
- Redis官方文档：https://redis.io/commands/renamenx
- 起始版本：1.0.0
- 时间复杂度：O(1)
当 newkey 不存在时重命名 key 到 newkey。当 key 不存在时抛出异常。
在集群模式中，key 和 newkey 都必须在同一个 hash slot 中，这意味着在集群中，具有相同的 hash tag 的的 key 才能被可靠的重命名。
<= 3.2.0：如果 key 和 newkey 相同，会抛出异常。
1 如果重命名成功。0 如果新的 key 已经存在。例子：
await client.set('mykey', 'Hello')
// "OK"
await client.set('myotherkey', 'World')
// "OK"
await client.renamenx('mykey', 'myotherkey')
// 0
await client.get('myotherkey')
// "World"
- Redis官方文档：https://redis.io/commands/restore
- 起始版本：2.6.0
- 时间复杂度：O(1) 创建新 key，O(N * M)进行反序列化，其中 N 是组成该值的 Redis 对象的数量，M 是其平均大小。 对于较小的 string 值，时间复杂度为O(1) + O(1 * M)，其中 M 很小，可以简单地认为复杂度为 O(1)。 对于 zset，复杂度为 O(N * M * log(N))，因为将值插入排序的集合中的复杂度为 O(log(N))。
通过反序列化在 key 上创建新值。一般通过 DUMP 得到序列化的值。
如果 ttl 参数设置为 0，则 key 不会设置过期时间，否则设置为指定的毫秒级过期时间。
如果设置了 absttl 选项，ttl 参数会被解析为一个毫秒级的 UNIX 时间戳。
出于驱逐策略的目的，可以使用 idletime 参数和 freq 参数。相关信息参考 OBJECT 命令（需要 Redis 5.0 及以上）。
可以使用 replace 选项指定是否覆盖已经存在的 key，如果未使用 replace 选项，且 key 已经存在，会返回 Target key name is busy 错误（需要 Redis 3.0 及以上）。
RESTORE 会检查序列化值的校验和。如果不匹配会抛出异常。
例子：
await client.del('mykey')
// 0
await client.restore('mykey', 0, Buffer.from([0x0e, 0x01, 0x11, 0x11, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf4, 0x02, 0xf3, 0x02, 0xf2, 0xff, 0x09, 0x00, 0xcb, 0xe7, 0x54, 0x27, 0x45, 0xe3, 0x3b, 0x2a]))
// "OK"
await client.type('mykey')
// "list"
await client.lrange('mykey', 0, -1)
// ["3", "2", "1"]
- Redis官方文档：https://redis.io/commands/scan
- 起始版本：2.8.0
- 时间复杂度：每次调用复杂度为 O(1)，一次包括足够命令调用使游标回到 0 的完整迭代的复杂度为 O(N)。N 是集合内元素数量。
SCAN 命令和近似的 SSCAN，HSCAN，ZSCAN
命令，是用来迭代集合内元素的。
SCAN 用于迭代当前连接持有的 database 内的 key。SSCAN 用于迭代集合（set）内的成员。HSCAN 用于迭代哈希表（hash）内的成员及其值。ZSCAN 用于迭代排序集（zset）内的成员和分数。由于这些命令允许增量迭代，每次调用只返回一小部分元素，所以在处理大集合类型时， 这些命令没有像 KEYS
，SMEMBERS 那样长时间阻塞服务的缺点，可以用于生产环境。
然而不像 SMEMBERS 这样的命令可以提供指定时间点的全部元素，SSCAN
只对返回的数据提供有限的保证，因为在增量迭代的过程中，集合可能发生改变。
SCAN，SSCAN，HSCAN，ZSCAN
工作的方式十分近似，所以关于这部分文档包含了这四个命令。 另外还有一个显而易见的区别是，SSCAN，HSCAN
，ZSCAN 的第一个参数始终是这些集合类型对应的 key。SCAN 不需要提供任何 key 的参数，所以它迭代的是这个 database 本身。
SCAN 是一种基于游标的迭代。这意味着每次调用都会返回新的游标位置用于下次调用。
当游标设置为 0 时，表示开始一次新的迭代。而当返回的游标也是 0 的时候表示迭代结束。下面是一个 SCAN 的调用例子：
await client.scan('0')
// { "cursor": "14", "keys": [
// "key:14", "key:6", "key:13", "key:5", "key:2",
// "key:18", "key:0", "key:16", "key:10", "key:17"
// ] }
await client.scan('14')
// { "cursor": "0", "keys": [
// "key:7", "key:8", "key:4", "key:3", "key:11",
// "key:9", "key:19", "key:1", "key:12", "key:15"
// ] }
在上面的例子中，第一次调用使用 0 作为游标值，表示开始一次迭代。 第二次调用的游标值，使用前一次调用返回的游标值 '14'。
你可以看到 SCAN 的返回值是一个二元组，第一个值是游标，第二个值是这次迭代的返回内容。
第二次调用时返回的游标是 0，意味着这次迭代已经结束，集合已经被完整遍历过。从使用 0 调用 SCAN 开始，到返回的 cursor 变为 0，这被称为一次完整迭代（full iteration）。
SCAN 家族的命令可以提供一些列的保证：
由于 SCAN 命令仅保存了很少的关联状态（仅限游标），因此具有以下缺点：
SCAN 家族命令不保证每次调用的返回数量是指定值。命令也可能返回 0 个元素，但只要返回的游标不是 0，客户端就不应该认为迭代结束。
SCAN 命令返回数量也有一些规则，从实用角度出发，对于一个大型的集合，每次可能只返回几十条数据，而对于一些足够小的集合，可能一次返回全部数据。
用户可以使用 count 选项调整每次返回元素的数量级。
尽管 SCAN 不保证每次迭代返回的元素数量，但是可以使用 count 选项根据经验调整 SCAN 的行为。
基本上 count 指定的是每次调用时从集合中检索元素的工作量。这只是实现方式的一个比喻，但一般情况下，你可以期望它的行为就是这样。
注意：不需要为每次调用传递相同的 count 参数。只要每次调用的游标值是从上次一调用结果获得的，调用者可以按需调整 count 值。
可以使用 glob 风格的模式对 scan 的返回结果进行过滤。它的行为类似于 KEYS。
使用 match 选项可以启用这种过滤模式，SCAN 家族的命令都支持这个选项。
下面是使用 match 选项的一个例子：
await client.sadd('myset', '1', '2', '3', 'foo', 'foobar', 'feelsgood')
// 6
await client.sscan('myset', '0', { match: 'f*' })
// { "cursor": "0", "keys": [
// "foo", "feelsgood", "foobar"
// ] }
需要注意的是，match 是在已经获取了元素之后，返回之前进行的过滤。这意味着如果 match 只匹配了集合重很小一部分元素，SCAN 命令可能在大多数的迭代中返回空数组。下面是一个例子：
const a: string[] = []
for (let i = 0; i < 1000; i++) {
a.push('key:' + i)
}
await Promise.all(a.map(k => client.set(k, '1')))
let res: { cursor: string, keys: string[] } | undefined
while (true) {
res = await client.scan(res?.cursor ?? 0, { match: '*11*', count: 100 })
console.log(res)
if (res.cursor === '0') {
break
}
}
/**
* { cursor: '792', keys: [ 'key:611' ] }
* { cursor: '780', keys: [ 'key:116', 'key:511' ] }
* { cursor: '914', keys: [ 'key:114', 'key:119', 'key:711' ] }
* { cursor: '358', keys: [ 'key:112', 'key:411', 'key:118', 'key:211' ] }
* { cursor: '62', keys: [] }
* { cursor: '617', keys: [ 'key:110' ] }
* { cursor: '141', keys: [ 'key:311', 'key:11' ] }
* { cursor: '179', keys: [ 'key:911', 'key:113', 'key:115' ] }
* { cursor: '487', keys: [ 'key:111' ] }
* { cursor: '0', keys: [ 'key:117', 'key:811' ] }
*/
如上所示，在一个 1000 个元素的集合中进行迭代，指定每次迭代的数量大致为 100 个，此时只返回几个 key 甚至还有空的结果。
在 Redis 6.0 版本开始，你可以使用 type 选项根据值类型进行返回值过滤。type 选项只在 SCAN 命令中生效，因为 SCAN 家族其他命令迭代的值对应的都是固定类型。
type 参数的可选项跟 TYPE 命令的返回值一样。
但是请注意，一些 Redis 的值类型实际上的存储类型为几个基本类型，比如 GeoHashs，HyperLogLogs，Bitmaps，Bitfields，他们的实现方式就是其他的内置类型，
比如 string 或者 zset，所以它们不能通过 type 选项区分。例如 GeoHash 和 zset:
type 的过滤时机和 match 选项一样，所以 type 选项同样不能减少服务器遍历集合的工作量，而且对于一些比较少的类型，会得到很多空数组的返回结果。
同一时间可以有不限个数的客户端同时进行迭代，因为迭代的状态只有游标值，他只是在每次调用和返回时出现，而服务器不保存任何迭代状态。
鉴于全部迭代信息都保存在游标中，服务端没有保存任何迭代信息，调用者可以随时终止迭代而不需要通知服务端。存在任意数量的未完成迭代不会引起服务端的任何问题。
使用错误的，超出范围的，负的，或者其他非法的游标会导致未定义的行为，但并不会导致崩溃。未定义的只是所有 SCAN 命令对于返回值的保证不再有效。
有效的游标：
'0' 表示迭代开始。只有在迭代集合的大小保持在一定范围内时，才能保证 SCAN 算法的终止，否则，对一直增长的集合进行迭代可能会导致 SCAN 算法永不终止。
这很好理解，随着集合增长，遍历集合需要执行的工作就越来越多，所以能否终止取决于 SCAN 的调用次数和 count 参数跟集合的增长率相比谁大谁小。
在前面 count 相关的文档中提到又是在 set，hash，zset 中使用 SCAN 家族命令时可能在单次调用中返回全部元素，而不管 count 设置为多少。
原因是只有当我们要扫描的聚合数据类型表示为哈希表时，才可以实现基于游标的迭代器。
然而 Redis 在聚合数据类型比较小的时候使用紧凑型的一次性打包编码方式，这样可以节省内存，直到元素的数量达到一定等级，或者单个元素大小超过限制。
在这种情况下，Redis 无法返回有效的游标，又必须迭代完整的数据，此时能做的只有将元素全部返回。
然而一旦数据大小超过限制，改为使用哈希表存储的方式，SCAN 命令就会执行正常的迭代操作。这种特殊的行为仅发生在小型数据类型上，所以它对命令的复杂度没有实际意义的影响。
转换为真实哈希表的限制是用户可配置的，所以单次调用中返回的最大元素数量实际上取决于打包格式的最大限制大小。
还有就是，这种特殊的行为只发生在 SSCAN HSCAN ZSCAN 上，SCAN 本身绝不会发生这种行为，因为 database 的 key 始终是以哈希表形式存储的。
- Redis官方文档：https://redis.io/commands/scan
- 起始版本：2.8.0
- 时间复杂度：每次调用复杂度为 O(1)，一次包括足够命令调用使游标回到 0 的完整迭代的复杂度为 O(N)。N 是集合内元素数量。
SCAN 命令和近似的 SSCAN，HSCAN，ZSCAN
命令，是用来迭代集合内元素的。
SCAN 用于迭代当前连接持有的 database 内的 key。SSCAN 用于迭代集合（set）内的成员。HSCAN 用于迭代哈希表（hash）内的成员及其值。ZSCAN 用于迭代排序集（zset）内的成员和分数。由于这些命令允许增量迭代，每次调用只返回一小部分元素，所以在处理大集合类型时， 这些命令没有像 KEYS
，SMEMBERS 那样长时间阻塞服务的缺点，可以用于生产环境。
然而不像 SMEMBERS 这样的命令可以提供指定时间点的全部元素，SSCAN
只对返回的数据提供有限的保证，因为在增量迭代的过程中，集合可能发生改变。
SCAN，SSCAN，HSCAN，ZSCAN
工作的方式十分近似，所以关于这部分文档包含了这四个命令。 另外还有一个显而易见的区别是，SSCAN，HSCAN
，ZSCAN 的第一个参数始终是这些集合类型对应的 key。SCAN 不需要提供任何 key 的参数，所以它迭代的是这个 database 本身。
SCAN 是一种基于游标的迭代。这意味着每次调用都会返回新的游标位置用于下次调用。
当游标设置为 0 时，表示开始一次新的迭代。而当返回的游标也是 0 的时候表示迭代结束。下面是一个 SCAN 的调用例子：
await client.scan('0')
// { "cursor": "14", "keys": [
// "key:14", "key:6", "key:13", "key:5", "key:2",
// "key:18", "key:0", "key:16", "key:10", "key:17"
// ] }
await client.scan('14')
// { "cursor": "0", "keys": [
// "key:7", "key:8", "key:4", "key:3", "key:11",
// "key:9", "key:19", "key:1", "key:12", "key:15"
// ] }
在上面的例子中，第一次调用使用 0 作为游标值，表示开始一次迭代。 第二次调用的游标值，使用前一次调用返回的游标值 '14'。
你可以看到 SCAN 的返回值是一个二元组，第一个值是游标，第二个值是这次迭代的返回内容。
第二次调用时返回的游标是 0，意味着这次迭代已经结束，集合已经被完整遍历过。从使用 0 调用 SCAN 开始，到返回的 cursor 变为 0，这被称为一次完整迭代（full iteration）。
SCAN 家族的命令可以提供一些列的保证：
由于 SCAN 命令仅保存了很少的关联状态（仅限游标），因此具有以下缺点：
SCAN 家族命令不保证每次调用的返回数量是指定值。命令也可能返回 0 个元素，但只要返回的游标不是 0，客户端就不应该认为迭代结束。
SCAN 命令返回数量也有一些规则，从实用角度出发，对于一个大型的集合，每次可能只返回几十条数据，而对于一些足够小的集合，可能一次返回全部数据。
用户可以使用 count 选项调整每次返回元素的数量级。
尽管 SCAN 不保证每次迭代返回的元素数量，但是可以使用 count 选项根据经验调整 SCAN 的行为。
基本上 count 指定的是每次调用时从集合中检索元素的工作量。这只是实现方式的一个比喻，但一般情况下，你可以期望它的行为就是这样。
注意：不需要为每次调用传递相同的 count 参数。只要每次调用的游标值是从上次一调用结果获得的，调用者可以按需调整 count 值。
可以使用 glob 风格的模式对 scan 的返回结果进行过滤。它的行为类似于 KEYS。
使用 match 选项可以启用这种过滤模式，SCAN 家族的命令都支持这个选项。
下面是使用 match 选项的一个例子：
await client.sadd('myset', '1', '2', '3', 'foo', 'foobar', 'feelsgood')
// 6
await client.sscan('myset', '0', { match: 'f*' })
// { "cursor": "0", "keys": [
// "foo", "feelsgood", "foobar"
// ] }
需要注意的是，match 是在已经获取了元素之后，返回之前进行的过滤。这意味着如果 match 只匹配了集合重很小一部分元素，SCAN 命令可能在大多数的迭代中返回空数组。下面是一个例子：
const a: string[] = []
for (let i = 0; i < 1000; i++) {
a.push('key:' + i)
}
await Promise.all(a.map(k => client.set(k, '1')))
let res: { cursor: string, keys: string[] } | undefined
while (true) {
res = await client.scan(res?.cursor ?? 0, { match: '*11*', count: 100 })
console.log(res)
if (res.cursor === '0') {
break
}
}
/**
* { cursor: '792', keys: [ 'key:611' ] }
* { cursor: '780', keys: [ 'key:116', 'key:511' ] }
* { cursor: '914', keys: [ 'key:114', 'key:119', 'key:711' ] }
* { cursor: '358', keys: [ 'key:112', 'key:411', 'key:118', 'key:211' ] }
* { cursor: '62', keys: [] }
* { cursor: '617', keys: [ 'key:110' ] }
* { cursor: '141', keys: [ 'key:311', 'key:11' ] }
* { cursor: '179', keys: [ 'key:911', 'key:113', 'key:115' ] }
* { cursor: '487', keys: [ 'key:111' ] }
* { cursor: '0', keys: [ 'key:117', 'key:811' ] }
*/
如上所示，在一个 1000 个元素的集合中进行迭代，指定每次迭代的数量大致为 100 个，此时只返回几个 key 甚至还有空的结果。
在 Redis 6.0 版本开始，你可以使用 type 选项根据值类型进行返回值过滤。type 选项只在 SCAN 命令中生效，因为 SCAN 家族其他命令迭代的值对应的都是固定类型。
type 参数的可选项跟 TYPE 命令的返回值一样。
但是请注意，一些 Redis 的值类型实际上的存储类型为几个基本类型，比如 GeoHashs，HyperLogLogs，Bitmaps，Bitfields，他们的实现方式就是其他的内置类型，
比如 string 或者 zset，所以它们不能通过 type 选项区分。例如 GeoHash 和 zset:
type 的过滤时机和 match 选项一样，所以 type 选项同样不能减少服务器遍历集合的工作量，而且对于一些比较少的类型，会得到很多空数组的返回结果。
同一时间可以有不限个数的客户端同时进行迭代，因为迭代的状态只有游标值，他只是在每次调用和返回时出现，而服务器不保存任何迭代状态。
鉴于全部迭代信息都保存在游标中，服务端没有保存任何迭代信息，调用者可以随时终止迭代而不需要通知服务端。存在任意数量的未完成迭代不会引起服务端的任何问题。
使用错误的，超出范围的，负的，或者其他非法的游标会导致未定义的行为，但并不会导致崩溃。未定义的只是所有 SCAN 命令对于返回值的保证不再有效。
有效的游标：
'0' 表示迭代开始。只有在迭代集合的大小保持在一定范围内时，才能保证 SCAN 算法的终止，否则，对一直增长的集合进行迭代可能会导致 SCAN 算法永不终止。
这很好理解，随着集合增长，遍历集合需要执行的工作就越来越多，所以能否终止取决于 SCAN 的调用次数和 count 参数跟集合的增长率相比谁大谁小。
在前面 count 相关的文档中提到又是在 set，hash，zset 中使用 SCAN 家族命令时可能在单次调用中返回全部元素，而不管 count 设置为多少。
原因是只有当我们要扫描的聚合数据类型表示为哈希表时，才可以实现基于游标的迭代器。
然而 Redis 在聚合数据类型比较小的时候使用紧凑型的一次性打包编码方式，这样可以节省内存，直到元素的数量达到一定等级，或者单个元素大小超过限制。
在这种情况下，Redis 无法返回有效的游标，又必须迭代完整的数据，此时能做的只有将元素全部返回。
然而一旦数据大小超过限制，改为使用哈希表存储的方式，SCAN 命令就会执行正常的迭代操作。这种特殊的行为仅发生在小型数据类型上，所以它对命令的复杂度没有实际意义的影响。
转换为真实哈希表的限制是用户可配置的，所以单次调用中返回的最大元素数量实际上取决于打包格式的最大限制大小。
还有就是，这种特殊的行为只发生在 SSCAN HSCAN ZSCAN 上，SCAN 本身绝不会发生这种行为，因为 database 的 key 始终是以哈希表形式存储的。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/sort
- 起始版本：1.0.0
- 时间复杂度：O(N + M * log(M)) 其中 N 是要排序的元素的数量，M 是返回的元素的数量。 如果不对元素进行排序，则当前的复杂度为 O(N)，在下一版本中将避免复制步骤。
返回或者存储集合类型的值的成员排序结果。
集合类型是值 list set zset 这种包含多个成员的类型。
默认情况下排序是数字形式的比较，成员名会被解释为一个双精度浮点数。
假设 mylist 是一个数字列表，此命令将返回与 mylist 相同的列表，从小到大排序。如果需要逆序，可以使用 desc 选项。
await client.sort('mylist', { desc: true })
假设 mylist 是一个字符串列表，你需要让他们按照字典序排列，可以使用 alpha 选项。
await client.sort('mylist', { alpha: true })
如果你正确设置了 !LC_COLLATE 环境变量，Redis 可以识别 UTF-8 编码。
通过使用 limit 选项，可以限制返回的成员数量。格式为 limit: [offset, count]，offset 表示要跳过的元素个数，count 表示需要返回的元素个数。
await client.sort('mylist', { limit: [0, 10] })
上述各个选项可以同时使用，下面的例子表示，按照字典序倒序排列，取前 5 个。
await client.sort('mylist', { limit: [0, 5], desc: true, alpha: true })
又是你希望通过外部的 key 的值替代实际成员的值作为权重进行排序。
比如说列表 mylist 包含了元素 1, 2, 3，代表对象 object_1，object_2，object_3 的唯一 ID。
当这些对象的权重存储在 weight_1，weight_2，weight_3 的时候，SORT 命令可以利用这些权重对 mylist 进行排序。
await client.sort('mylist', { by: 'weight_*' })
by 选项接收一个 pattern 格式（在这个例子中是 weight_*），用来生成需要排序的 key。通过将列表中的实际成员值替换，首次出现的 *，得到需要使用的 key。
by 选项也可以接受一个不存在的 key，这会导致 SORT 命令跳过排序操作。当你只需要提取外部 key（参考下面的 get 选项），而不需要排序时很有用。
await client.sort('mylist', { by: 'nosort' })
上一个例子中只是返回了排好序的 ID 列表。在一些场景中，获取实际的对象比只获取 ID 更有用。
通过使用 get 选项可以修改返回值为外部 key 的值。
await client.sort('mylist', { by: 'weight_*', get: ['object_*'] })
get 选项可以包含多组数据。在使用 get 选项的同时如果也需要返回本身的值，可以使用 #。
await client.sort('mylist', { by: 'weight_*', get: ['object_*', '#'] })
默认情况下，sort 会返回排序结果。使用 store 参数可以将结果存储到指定的 key。
await client.sort('mylist', 'resultkey', { by: 'weight_*' })
一个有趣的使用场景是，将排序结果存储到其他 key 之后，设置过期时间。这样就不用对每个请求执行排序了。当过期之后，通过再次调用排序命令生成新的排序结果。
在 by 和 get 选项可以指定哈希表的字段。语法如下：
await client.sort('mylist', { by: 'weight_*->fieldname', get: ['object_*->fieldname'] })
字符串 -> 用于分割 key 和 hash field。key 的值会如上文所述进行替换，之后获取 hash 中的指定 field。
- Redis官方文档：https://redis.io/commands/sort
- 起始版本：1.0.0
- 时间复杂度：O(N + M * log(M)) 其中 N 是要排序的元素的数量，M 是返回的元素的数量。 如果不对元素进行排序，则当前的复杂度为 O(N)，在下一版本中将避免复制步骤。
返回或者存储集合类型的值的成员排序结果。
集合类型是值 list set zset 这种包含多个成员的类型。
默认情况下排序是数字形式的比较，成员名会被解释为一个双精度浮点数。
假设 mylist 是一个数字列表，此命令将返回与 mylist 相同的列表，从小到大排序。如果需要逆序，可以使用 desc 选项。
await client.sort('mylist', { desc: true })
假设 mylist 是一个字符串列表，你需要让他们按照字典序排列，可以使用 alpha 选项。
await client.sort('mylist', { alpha: true })
如果你正确设置了 !LC_COLLATE 环境变量，Redis 可以识别 UTF-8 编码。
通过使用 limit 选项，可以限制返回的成员数量。格式为 limit: [offset, count]，offset 表示要跳过的元素个数，count 表示需要返回的元素个数。
await client.sort('mylist', { limit: [0, 10] })
上述各个选项可以同时使用，下面的例子表示，按照字典序倒序排列，取前 5 个。
await client.sort('mylist', { limit: [0, 5], desc: true, alpha: true })
又是你希望通过外部的 key 的值替代实际成员的值作为权重进行排序。
比如说列表 mylist 包含了元素 1, 2, 3，代表对象 object_1，object_2，object_3 的唯一 ID。
当这些对象的权重存储在 weight_1，weight_2，weight_3 的时候，SORT 命令可以利用这些权重对 mylist 进行排序。
await client.sort('mylist', { by: 'weight_*' })
by 选项接收一个 pattern 格式（在这个例子中是 weight_*），用来生成需要排序的 key。通过将列表中的实际成员值替换，首次出现的 *，得到需要使用的 key。
by 选项也可以接受一个不存在的 key，这会导致 SORT 命令跳过排序操作。当你只需要提取外部 key（参考下面的 get 选项），而不需要排序时很有用。
await client.sort('mylist', { by: 'nosort' })
上一个例子中只是返回了排好序的 ID 列表。在一些场景中，获取实际的对象比只获取 ID 更有用。
通过使用 get 选项可以修改返回值为外部 key 的值。
await client.sort('mylist', { by: 'weight_*', get: ['object_*'] })
get 选项可以包含多组数据。在使用 get 选项的同时如果也需要返回本身的值，可以使用 #。
await client.sort('mylist', { by: 'weight_*', get: ['object_*', '#'] })
默认情况下，sort 会返回排序结果。使用 store 参数可以将结果存储到指定的 key。
await client.sort('mylist', 'resultkey', { by: 'weight_*' })
一个有趣的使用场景是，将排序结果存储到其他 key 之后，设置过期时间。这样就不用对每个请求执行排序了。当过期之后，通过再次调用排序命令生成新的排序结果。
在 by 和 get 选项可以指定哈希表的字段。语法如下：
await client.sort('mylist', { by: 'weight_*->fieldname', get: ['object_*->fieldname'] })
字符串 -> 用于分割 key 和 hash field。key 的值会如上文所述进行替换，之后获取 hash 中的指定 field。
指定 key 用来存储排序结果。当指定的 key 已经存在时，会被覆盖。
- Redis官方文档：https://redis.io/commands/sort
- 起始版本：1.0.0
- 时间复杂度：O(N + M * log(M)) 其中 N 是要排序的元素的数量，M 是返回的元素的数量。 如果不对元素进行排序，则当前的复杂度为 O(N)，在下一版本中将避免复制步骤。
返回或者存储集合类型的值的成员排序结果。
集合类型是值 list set zset 这种包含多个成员的类型。
默认情况下排序是数字形式的比较，成员名会被解释为一个双精度浮点数。
假设 mylist 是一个数字列表，此命令将返回与 mylist 相同的列表，从小到大排序。如果需要逆序，可以使用 desc 选项。
await client.sort('mylist', { desc: true })
假设 mylist 是一个字符串列表，你需要让他们按照字典序排列，可以使用 alpha 选项。
await client.sort('mylist', { alpha: true })
如果你正确设置了 !LC_COLLATE 环境变量，Redis 可以识别 UTF-8 编码。
通过使用 limit 选项，可以限制返回的成员数量。格式为 limit: [offset, count]，offset 表示要跳过的元素个数，count 表示需要返回的元素个数。
await client.sort('mylist', { limit: [0, 10] })
上述各个选项可以同时使用，下面的例子表示，按照字典序倒序排列，取前 5 个。
await client.sort('mylist', { limit: [0, 5], desc: true, alpha: true })
又是你希望通过外部的 key 的值替代实际成员的值作为权重进行排序。
比如说列表 mylist 包含了元素 1, 2, 3，代表对象 object_1，object_2，object_3 的唯一 ID。
当这些对象的权重存储在 weight_1，weight_2，weight_3 的时候，SORT 命令可以利用这些权重对 mylist 进行排序。
await client.sort('mylist', { by: 'weight_*' })
by 选项接收一个 pattern 格式（在这个例子中是 weight_*），用来生成需要排序的 key。通过将列表中的实际成员值替换，首次出现的 *，得到需要使用的 key。
by 选项也可以接受一个不存在的 key，这会导致 SORT 命令跳过排序操作。当你只需要提取外部 key（参考下面的 get 选项），而不需要排序时很有用。
await client.sort('mylist', { by: 'nosort' })
上一个例子中只是返回了排好序的 ID 列表。在一些场景中，获取实际的对象比只获取 ID 更有用。
通过使用 get 选项可以修改返回值为外部 key 的值。
await client.sort('mylist', { by: 'weight_*', get: ['object_*'] })
get 选项可以包含多组数据。在使用 get 选项的同时如果也需要返回本身的值，可以使用 #。
await client.sort('mylist', { by: 'weight_*', get: ['object_*', '#'] })
默认情况下，sort 会返回排序结果。使用 store 参数可以将结果存储到指定的 key。
await client.sort('mylist', 'resultkey', { by: 'weight_*' })
一个有趣的使用场景是，将排序结果存储到其他 key 之后，设置过期时间。这样就不用对每个请求执行排序了。当过期之后，通过再次调用排序命令生成新的排序结果。
在 by 和 get 选项可以指定哈希表的字段。语法如下：
await client.sort('mylist', { by: 'weight_*->fieldname', get: ['object_*->fieldname'] })
字符串 -> 用于分割 key 和 hash field。key 的值会如上文所述进行替换，之后获取 hash 中的指定 field。
- Redis官方文档：https://redis.io/commands/sort
- 起始版本：1.0.0
- 时间复杂度：O(N + M * log(M)) 其中 N 是要排序的元素的数量，M 是返回的元素的数量。 如果不对元素进行排序，则当前的复杂度为 O(N)，在下一版本中将避免复制步骤。
返回或者存储集合类型的值的成员排序结果。
集合类型是值 list set zset 这种包含多个成员的类型。
默认情况下排序是数字形式的比较，成员名会被解释为一个双精度浮点数。
假设 mylist 是一个数字列表，此命令将返回与 mylist 相同的列表，从小到大排序。如果需要逆序，可以使用 desc 选项。
await client.sort('mylist', { desc: true })
假设 mylist 是一个字符串列表，你需要让他们按照字典序排列，可以使用 alpha 选项。
await client.sort('mylist', { alpha: true })
如果你正确设置了 !LC_COLLATE 环境变量，Redis 可以识别 UTF-8 编码。
通过使用 limit 选项，可以限制返回的成员数量。格式为 limit: [offset, count]，offset 表示要跳过的元素个数，count 表示需要返回的元素个数。
await client.sort('mylist', { limit: [0, 10] })
上述各个选项可以同时使用，下面的例子表示，按照字典序倒序排列，取前 5 个。
await client.sort('mylist', { limit: [0, 5], desc: true, alpha: true })
又是你希望通过外部的 key 的值替代实际成员的值作为权重进行排序。
比如说列表 mylist 包含了元素 1, 2, 3，代表对象 object_1，object_2，object_3 的唯一 ID。
当这些对象的权重存储在 weight_1，weight_2，weight_3 的时候，SORT 命令可以利用这些权重对 mylist 进行排序。
await client.sort('mylist', { by: 'weight_*' })
by 选项接收一个 pattern 格式（在这个例子中是 weight_*），用来生成需要排序的 key。通过将列表中的实际成员值替换，首次出现的 *，得到需要使用的 key。
by 选项也可以接受一个不存在的 key，这会导致 SORT 命令跳过排序操作。当你只需要提取外部 key（参考下面的 get 选项），而不需要排序时很有用。
await client.sort('mylist', { by: 'nosort' })
上一个例子中只是返回了排好序的 ID 列表。在一些场景中，获取实际的对象比只获取 ID 更有用。
通过使用 get 选项可以修改返回值为外部 key 的值。
await client.sort('mylist', { by: 'weight_*', get: ['object_*'] })
get 选项可以包含多组数据。在使用 get 选项的同时如果也需要返回本身的值，可以使用 #。
await client.sort('mylist', { by: 'weight_*', get: ['object_*', '#'] })
默认情况下，sort 会返回排序结果。使用 store 参数可以将结果存储到指定的 key。
await client.sort('mylist', 'resultkey', { by: 'weight_*' })
一个有趣的使用场景是，将排序结果存储到其他 key 之后，设置过期时间。这样就不用对每个请求执行排序了。当过期之后，通过再次调用排序命令生成新的排序结果。
在 by 和 get 选项可以指定哈希表的字段。语法如下：
await client.sort('mylist', { by: 'weight_*->fieldname', get: ['object_*->fieldname'] })
字符串 -> 用于分割 key 和 hash field。key 的值会如上文所述进行替换，之后获取 hash 中的指定 field。
指定 key 用来存储排序结果。当指定的 key 已经存在时，会被覆盖。
- Redis官方文档：https://redis.io/commands/touch
- 起始版本：3.2.1
- 时间复杂度：O(N) 其中 N 是将 key 的数量。
此命令会修改 key 的最后访问时间。返回存在的 key 的个数。
返回触碰到（touched）的 key 的数量。
例子：
await client.set('key1', 'Hello')
// "OK"
await client.set('key2', 'World')
// "OK"
await client.touch('key1', 'key2')
// 2
- Redis官方文档：https://redis.io/commands/ttl
- 起始版本：1.0.0
- 时间复杂度：O(1)
返回 key 的过期时间剩余秒数。这项自我检查的功能可以让 Redis 的客户端检查 key 作为数据库的一部分还有多长时间。
2.6 及更早的版本中，key 不存在或者未设置过期时间，都会返回 -1。 从 2.8 版本开始：
另请参阅 PTTL 命令，他会返回毫秒级的相同信息。
以整数形式返回过期时间。 以及负数表示不同的过期时间状态。
例子：
await client.set('mykey', 'Hello')
// "OK"
await client.expire('mykey', 10)
// 1
await client.ttl('mykey')
// 10
- Redis官方文档：https://redis.io/commands/type
- 起始版本：1.0.0
- 时间复杂度：O(1)
查询值得存储类型。
字符串形式返回 key 处的值类型，如 string，list，set，zset，hash，stream。
当 key 不存在时 返回字符串 none。
例子：
await client.set('key1', 'value')
// "OK"
await client.lpush('key2', 'value')
// 1
await client.sadd('key3', 'value')
// 1
await client.type('key1')
// "string"
await client.type('key2')
// "list"
await client.type('key3')
// "set"
- Redis官方文档：https://redis.io/commands/unlink
- 起始版本：4.0.0
- 时间复杂度：删除每个键的复杂度为 O(1) 和值大小无关。在之后的回收内存操作的复杂度为 O(N)，N 为组成待回收对象的分配空间大小。
此命令和 DEL 作用相似，删除指定的 key(s)，不存在则被跳过。
区别是 UNLINK 只会同步的从 keyspace 中删除 key，回收内存的工作是在另外的线程中异步执行的。所以性能会比 DEL 好一些。
例子：
await client.set('key1', 'Hello')
// "OK"
await client.set('key2', 'World')
// "OK"
await client.unlink('key1', 'key2', 'key3')
// 2
- 起始版本：3.0.0
- 时间复杂度：O(1)
TODO: 补命令说明。
单位毫秒
- Redis官方文档：https://redis.io/commands/hdel
- 起始版本：2.0.0
- 时间复杂度：O(N) N 为待删除的 field 个数。
移除指定 key（hash 类型）的指定 field，并返回移除的 field 的个数。
注意：2.4 版本开始支持多个 field 参数，更早的版本一次命令只能移除一个 field。如果在更早的版本中希望一次移除多个 field，请使用 MULTI/EXEC 事务块。
例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hdel('myhash', 'field1')
// 1
await client.hdel('myhash', 'field1')
// 0
需要移除的 field 列表。
- Redis官方文档：https://redis.io/commands/hexists
- 起始版本：2.0.0
- 时间复杂度：O(1)
返回 hash 中是否存在指定 field。
返回值：
1 表示 hash 包含指定的 field。0 表示 hash 不包含指定的 field，或者 hash 不存在。例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hexists('myhash', 'field1')
// 1
await client.hexists('myhash', 'field2')
// 0
- Redis官方文档：https://redis.io/commands/hget
- 起始版本：2.0.0
- 时间复杂度：O(1)
返回 hash 中指定 field 的值，如果 key 不存在或者 field 不存在返回 null。
例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hget('myhash', 'field1')
// "foo"
await client.hget('myhash', 'field2')
// null
await client.hget('nonexists', 'field2')
// null
- Redis官方文档：https://redis.io/commands/hget
- 起始版本：2.0.0
- 时间复杂度：O(1)
返回 hash 中指定 field 的值，如果 key 不存在或者 field 不存在返回 null。
例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hget('myhash', 'field1')
// "foo"
await client.hget('myhash', 'field2')
// null
await client.hget('nonexists', 'field2')
// null
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/hgetall
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是 hash 的大小。
以 object 形式返回 hash 中的全部 field 和值。
例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hget('myhash', 'field1')
// "foo"
await client.hget('myhash', 'field2')
// null
await client.hget('nonexists', 'field2')
// null
- Redis官方文档：https://redis.io/commands/hgetall
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是 hash 的大小。
以 object 形式返回 hash 中的全部 field 和值。
例子：
await client.hset('myhash', { field1: 'foo' })
// 1
await client.hget('myhash', 'field1')
// "foo"
await client.hget('myhash', 'field2')
// null
await client.hget('nonexists', 'field2')
// null
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/hincrby
- 起始版本：2.0.0
- 时间复杂度：O(1)
对指定的 hash 中的 field 对应的值进行整型自增操作，返回自增之后的值。
例子：
await client.hset('myhash', { field1: '5' })
// 1
await client.hincrby('myhash', 'field1', 1)
// 6
await client.hincrby('myhash', 'field1', -1)
// 5
await client.hincrby('myhash', 'field1', -10)
// -5
- Redis官方文档：https://redis.io/commands/hincrby
- 起始版本：2.6.0
- 时间复杂度：O(1)
对指定的 hash 中的 field 对应的值进行浮点数自增操作，返回自增之后的值。
例子：
await client.hset('mykey', { field: '10.50' })
// 1
await client.hincrbyfloat('mykey', 'field', '0.1')
// "10.6"
await client.hincrbyfloat('mykey', 'field', '-5')
// "5.6"
await client.hset('mykey', { field: '5.0e3' })
// 0
await client.hincrbyfloat('mykey', 'field', '2.0e2')
// "5200"
- Redis官方文档：https://redis.io/commands/hkeys
- 起始版本：2.0.0
- 时间复杂度：O(N) N 为 hash 的大小。
返回指定 hash 的所有 field 名字。
例子：
await client.hset('mykey', { field1: 'Hello' })
// 1
await client.hset('mykey', { field2: 'World' })
// 1
await client.hkeys('mykey')
// ["field1", "field2"]
- Redis官方文档：https://redis.io/commands/hlen
- 起始版本：2.0.0
- 时间复杂度：O(1)
返回指定 hash 的 field 个数。
例子：
await client.hset('mykey', { field1: 'Hello' })
// 1
await client.hset('mykey', { field2: 'World' })
// 1
await client.hlen('mykey')
// 2
await client.hlen('nonexist')
// 0
- Redis官方文档：https://redis.io/commands/hmget
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是请求的 field 个数。
返回指定 hash 的指定 field 值。
例子：
await client.hset('mykey', { field1: 'Hello' })
// 1
await client.hset('mykey', { field2: 'World' })
// 1
await client.hmget('mykey', ['field1', 'field2', 'nofield'])
// ["Hello", "World", null]
await client.hmget('nokey', ['field1', 'field2', 'nofield'])
// [null, null, null]
需要请求的 field 列表。
- Redis官方文档：https://redis.io/commands/hmget
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是请求的 field 个数。
返回指定 hash 的指定 field 值。
例子：
await client.hset('mykey', { field1: 'Hello' })
// 1
await client.hset('mykey', { field2: 'World' })
// 1
await client.hmget('mykey', ['field1', 'field2', 'nofield'])
// ["Hello", "World", null]
await client.hmget('nokey', ['field1', 'field2', 'nofield'])
// [null, null, null]
需要请求的 field 列表。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/hmset
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是需要设置的 field 个数。
对指定 hash 设置 field/value 对，返回 OK。
注意：4.0.0 版本之后，HSET 已经实现了多组 field/value 的写入功能。
所以此命令在之后的版本中可能被废弃，在新的代码中请使用 HSET。
例子：
await client.hmset('mykey', { field1: 'Hello', field2: 'World' })
// 2
await client.hget('mykey', 'field1')
// "Hello"
await client.hget('mykey', 'field2')
// "World"
- Redis官方文档：https://redis.io/commands/hscan
- 起始版本：2.8.0
- 时间复杂度：**每次调用的消耗为O(1)，完整迭代一次为 O(N)，包括足以使光标返回到 0 的命令调用。N 是集合内元素的数量。
详情参见 SCAN 命令。
- Redis官方文档：https://redis.io/commands/hscan
- 起始版本：2.8.0
- 时间复杂度：**每次调用的消耗为O(1)，完整迭代一次为 O(N)，包括足以使光标返回到 0 的命令调用。N 是集合内元素的数量。
详情参见 SCAN 命令。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/hset
- 起始版本：2.0.0
- 时间复杂度：O(1) 对于每一对 field/value。所以 N 对 field/value 的复杂度为 O(N)。
将指定 hash 中的 field 设置为 value。如果 key 不存在，会创建一个新的 hash。如果 field 已经存在，它的值会被重写。
返回添加的 field 的个数。
被修改的 field 不被计算在内。
注意：在 4.0.0 版本开始，HSET 可以接受多组 field/value。更早的版本中，只能传递一对 field/value。
例子：
await client.hset('myhash', { field1: 'Hello' })
// 1
await client.hget('myhash', 'field1')
// "Hello"
- Redis官方文档：https://redis.io/commands/hsetnx
- 起始版本：2.0.0
- 时间复杂度：O(1)
将指定 hash 中的 field 不存在时，将其设置为 value。
如果 field 存在操作没有任何影响。
如果 key 的类型不是 hash，会抛出异常。
1 当 field 不存在并且设置了新的 field。0 当 field 已经存在，未执行任何操作。例子：
await client.hsetnx('myhash', 'field', 'Hello' )
// 1
await client.hsetnx('myhash', 'field', 'World' )
// 0
await client.hget('myhash', 'field' )
// "Hello"
- Redis官方文档：https://redis.io/commands/hstrlen
- 起始版本：3.2.0
- 时间复杂度：O(1)
返回 hash 中指定 field 的值的长度。如果 key 不存在或者 field 不存在，返回 0。
例子：
await client.hset('myhash', { f1: 'HelloWorld', f2: '99', f3: '-256' })
// 3
await client.hstrlen('myhash', 'f1')
// 10
await client.hstrlen('myhash', 'f2')
// 2
await client.hstrlen('myhash', 'f3')
// 4
- Redis官方文档：https://redis.io/commands/hvals
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是 hash 的大小。
以数组形式返回指定 hash 中全部的值。当 key 不存在时返回空数组。
例子：
await client.hset('myhash', { f1: 'Hello' })
// 1
await client.hset('myhash', { f2: 'World' })
// 1
await client.hvals('myhash')
// ["Hello", "World"]
- Redis官方文档：https://redis.io/commands/hvals
- 起始版本：2.0.0
- 时间复杂度：O(N) N 是 hash 的大小。
以数组形式返回指定 hash 中全部的值。当 key 不存在时返回空数组。
例子：
await client.hset('myhash', { f1: 'Hello' })
// 1
await client.hset('myhash', { f2: 'World' })
// 1
await client.hvals('myhash')
// ["Hello", "World"]
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/blmove
- 起始版本：6.2.0
- 时间复杂度：O(1)
BLMOVE 是阻塞版本的 ｜ LMOVE 命令。
返回从 src pop 出来的元素。如果超时则会返回 null。
需要 pop 元素的 list。
需要 push 元素的 list。
取出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。
推入方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。
以秒为单位的过期时间，双精度浮点数。
- Redis官方文档：https://redis.io/commands/blmove
- 起始版本：6.2.0
- 时间复杂度：O(1)
BLMOVE 是阻塞版本的 ｜ LMOVE 命令。
返回从 src pop 出来的元素。如果超时则会返回 null。
需要 pop 元素的 list。
需要 push 元素的 list。
取出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。
推入方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。
以秒为单位的过期时间，双精度浮点数。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/blpop
- 起始版本：2.0.0
- 时间复杂度：O(1)
BLPOP 是阻塞版本的 ｜ LPOP 命令。
当 BLPOP 被调用时，如果指定的 key 中至少有一个包含了非空列表，则会从其头部弹出一个元素并返回。
考虑命令：
await client.blpop(['list1', 'list2', 'list3'], 0)
因为 list2 时这一系列 key 中第一个非空 list 是 list2，BLPOP 会保证返回 list2 的第一个元素。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
如果传递了多个 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 才会开始下一个命令/脚本/事务的处理。
BLPOP 可以在 pipeline 中运行（发送多个命令，并且批量读取结果），然而这个命令仅在作为 pipeline 的最后一个命令时才有意义。
在（MULTI/EXEC）事务中使用 BLPOP 一般没什么意义，因为他需要阻塞整个服务器来保证事务原子性的执行，此时其他的客户端也无法执行一个 push 操作。
鉴于这个原因，在（MULTI/EXEC）事务中，当 BLPOP 等待的列表为空时，会直接返回 null。这跟等待超时的效果是一样的。
如果你喜欢科幻小说，可以想象一下在（MULTI/EXEC）事务块中，时间以无限的长度流动……
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
以秒为单位的过期时间，双精度浮点数。
- Redis官方文档：https://redis.io/commands/blpop
- 起始版本：2.0.0
- 时间复杂度：O(1)
BLPOP 是阻塞版本的 ｜ LPOP 命令。
当 BLPOP 被调用时，如果指定的 key 中至少有一个包含了非空列表，则会从其头部弹出一个元素并返回。
考虑命令：
await client.blpop(['list1', 'list2', 'list3'], 0)
因为 list2 时这一系列 key 中第一个非空 list 是 list2，BLPOP 会保证返回 list2 的第一个元素。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
如果传递了多个 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 才会开始下一个命令/脚本/事务的处理。
BLPOP 可以在 pipeline 中运行（发送多个命令，并且批量读取结果），然而这个命令仅在作为 pipeline 的最后一个命令时才有意义。
在（MULTI/EXEC）事务中使用 BLPOP 一般没什么意义，因为他需要阻塞整个服务器来保证事务原子性的执行，此时其他的客户端也无法执行一个 push 操作。
鉴于这个原因，在（MULTI/EXEC）事务中，当 BLPOP 等待的列表为空时，会直接返回 null。这跟等待超时的效果是一样的。
如果你喜欢科幻小说，可以想象一下在（MULTI/EXEC）事务块中，时间以无限的长度流动……
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
以秒为单位的过期时间，双精度浮点数。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/brpop
- 起始版本：2.0.0
- 时间复杂度：O(1)
BRPOP 是阻塞版本的 ｜ RPOP 命令。
BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
以秒为单位的过期时间，双精度浮点数。
- Redis官方文档：https://redis.io/commands/brpop
- 起始版本：2.0.0
- 时间复杂度：O(1)
BRPOP 是阻塞版本的 ｜ RPOP 命令。
BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
以秒为单位的过期时间，双精度浮点数。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/brpoplpush
- 起始版本：2.2.0
- 时间复杂度：O(1)
BRPOPLPUSH 是阻塞版本的 ｜ RPOPLPUSH 命令。
BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
注意：6.2.0 增加了 BLMOVE 命令，BRPOPLPUSH 有可能被弃用。考虑使用 BLMOVE 替代 BRPOPLPUSH。
以秒为单位的过期时间，双精度浮点数。
- Redis官方文档：https://redis.io/commands/brpoplpush
- 起始版本：2.2.0
- 时间复杂度：O(1)
BRPOPLPUSH 是阻塞版本的 ｜ RPOPLPUSH 命令。
BRPOP 和 BLPOP 的区别只是弹出元素的位置是尾部。其他的语义详情见 BLPOP 命令文档。
注意：timeout 参数在早期的 redis 版本会被解释为整型，6.0.0 及以上版本会被解释为双精度浮点数。
注意：6.2.0 增加了 BLMOVE 命令，BRPOPLPUSH 有可能被弃用。考虑使用 BLMOVE 替代 BRPOPLPUSH。
以秒为单位的过期时间，双精度浮点数。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/lindex
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为到达 index 指定位置需要遍历的元素个数。所以访问 index 为 1 或 -1 的情况下，复杂度为 O(1)。
返回指定列表的 index 处的元素。
例子：
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
- Redis官方文档：https://redis.io/commands/lindex
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为到达 index 指定位置需要遍历的元素个数。所以访问 index 为 1 或 -1 的情况下，复杂度为 O(1)。
返回指定列表的 index 处的元素。
例子：
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
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/linsert
- 起始版本：2.2.0
- 时间复杂度：O(N) N 为到达指定位置 pivot 需要遍历的元素个数。这意味着从列表左侧插入元素为 O(1)，从右侧插入元素为 O(N)。
在 list 指定位置 pivot 的前面或者后面插入 element。
返回插入后的 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"]
- Redis官方文档：https://redis.io/commands/llen
- 起始版本：1.0.0
- 时间复杂度：O(1)
返回指定 list 的长度。
例子：
await client.lpush('mylist', 'World')
// 1
await client.lpush('mylist', 'Hello')
// 2
await client.llen('mylist')
// 2
- Redis官方文档：https://redis.io/commands/lmove
- 起始版本：6.2.0
- 时间复杂度：O(1)
原子性的从 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"]
源列表
存储列表
源列表弹出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。
源列表弹出方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。
- Redis官方文档：https://redis.io/commands/lmove
- 起始版本：6.2.0
- 时间复杂度：O(1)
原子性的从 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"]
源列表
存储列表
源列表弹出方向，LEFT 相当于 lpop，RIGHT 相当于 rpop。
源列表弹出方向，LEFT 相当于 lpush，RIGHT 相当于 rpush。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/lpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 左侧移除并返回一个或多个值。
例子：
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"]
- Redis官方文档：https://redis.io/commands/lpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 左侧移除并返回一个或多个值。
例子：
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"]
是否以 Buffer 形式返回。
- Redis官方文档：https://redis.io/commands/lpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 左侧移除并返回一个或多个值。
例子：
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"]
指定弹出元素的数量，6.2.0 及以上版本支持。
- Redis官方文档：https://redis.io/commands/lpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 左侧移除并返回一个或多个值。
例子：
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"]
指定弹出元素的数量，6.2.0 及以上版本支持。
是否以 Buffer 形式返回。
- 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]
- 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]
需要返回的匹配元素数量。设置 count 参数会使返回值变为数组形式。
- Redis官方文档：https://redis.io/commands/lpush
- 起始版本：1.0.0
- 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。
向指定 list 头部添加所有指定的 value。返回添加后的 list 长度。
注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。
例子：
await client.lpush('mylist', 'world')
// 1
await client.lpush('mylist', 'hello')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]
- Redis官方文档：https://redis.io/commands/lpushx
- 起始版本：2.2.0
- 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。
仅当指定的 key 存在并且值为 list 时，向 list 头部添加所有指定的 value。返回添加后的 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)
// []
- Redis官方文档：https://redis.io/commands/lrange
- 起始版本：1.0.0
- 时间复杂度：O(S + N) S 是从列表头到 start 位置的距离，对于大列表是到最近的端的距离。N 是 start 到 end 的区间范围。
返回指定 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)
// []
选取范围左端索引值。
选取范围右端索引值。
- Redis官方文档：https://redis.io/commands/lrange
- 起始版本：1.0.0
- 时间复杂度：O(S + N) S 是从列表头到 start 位置的距离，对于大列表是到最近的端的距离。N 是 start 到 end 的区间范围。
返回指定 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)
// []
选取范围左端索引值。
选取范围右端索引值。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/lrem
- 起始版本：1.0.0
- 时间复杂度：O(N+M) N 是列表长度，M 是需要移除的元素个数。
对指定 list 移除前 count 个匹配 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"]
- Redis官方文档：https://redis.io/commands/lset
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是 list 的长度。设置第一个或最后一个元素的时间为 O(1)。
设置 list 指定索引的元素。对于 list 索引的更多信息见 LINDEX。
例子：
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"]
- Redis官方文档：https://redis.io/commands/ltrim
- 起始版本：1.0.0
- 时间复杂度：O(N) N 需要移除的元素个数。
裁剪指定 list，返回 OK。裁剪后 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"]
- Redis官方文档：https://redis.io/commands/rpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 右侧移除并返回一个或多个值。
例子：
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"]
- Redis官方文档：https://redis.io/commands/rpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 右侧移除并返回一个或多个值。
例子：
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"]
是否以 Buffer 形式返回。
- Redis官方文档：https://redis.io/commands/rpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 右侧移除并返回一个或多个值。
例子：
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"]
指定弹出元素的数量，6.2.0 及以上版本支持。
- Redis官方文档：https://redis.io/commands/rpop
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为返回的元素个数。
从 list 右侧移除并返回一个或多个值。
例子：
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"]
指定弹出元素的数量，6.2.0 及以上版本支持。
是否以 Buffer 形式返回。
- Redis官方文档：https://redis.io/commands/rpoplpush
- 起始版本：1.2.0
- 时间复杂度：O(1)
原子性的从源列表末尾弹出一个值，并推入存储列表头部。返回这个值。
注意：在 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"]
- Redis官方文档：https://redis.io/commands/rpush
- 起始版本：1.0.0
- 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。
向指定 list 末尾添加所有指定的 value。返回添加后的 list 长度。
注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。
例子：
await client.rpush('mylist', 'hello')
// 1
await client.rpush('mylist', 'world')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]
是否以 Buffer 形式返回。
- Redis官方文档：https://redis.io/commands/rpush
- 起始版本：1.0.0
- 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。
向指定 list 末尾添加所有指定的 value。返回添加后的 list 长度。
注意：早期版本只能推入一个值，2.4 及以上版本可以支持多个值的推入。
例子：
await client.rpush('mylist', 'hello')
// 1
await client.rpush('mylist', 'world')
// 2
await client.lrange('mylist', 0, -1)
// ["hello", "world"]
- Redis官方文档：https://redis.io/commands/lpushx
- 起始版本：2.2.0
- 时间复杂度：单个元素的添加复杂度为 O(1)，所以添加 N 个元素的复杂度为 O(N)。
仅当指定的 key 存在并且值为 list 时，向 list 末尾添加所有指定的 value。返回添加后的 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)
// []
起始版本：1.0.0
时间复杂度：O(N)，N 为当前库中 key 的个数。
清空当前数据库的全部 key。
是否异步执行， 4.0.0 开始支持。
- Redis官方文档：https://redis.io/commands/info
- 起始版本：1.0.0
只返回指定 section 的内容。
- Redis官方文档：https://redis.io/commands/sadd
- 起始版本：1.0.0
- 时间复杂度：每一个 member 添加的复杂度为 O(1)，所以添加 N 个 member 的复杂度是 O(N)。
向指定 set 添加 member，返回添加进 set 的 member 个数。
注意：2.4 版本开始接受多个 member 参数。更早的版本一次命令只能添加一个 member。
例子：
await client.sadd('myset', 'Hello')
// 1
await client.sadd('myset', 'World')
// 1
await client.sadd('myset', 'World')
// 0
await client.smembers('myset')
// ["World", "Hello"]
- Redis官方文档：https://redis.io/commands/scard
- 起始版本：1.0.0
- 时间复杂度：O(1)
返回集合基数（元素数）。
例子：
await client.sadd('myset', 'Hello')
// 1
await client.sadd('myset', 'World')
// 1
await client.scard('myset')
// 2
- Redis官方文档：https://redis.io/commands/sdiff
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是所有指定 set 包含的总元素数。
返回第一个 set 和后面连续的 set 做差集，一系列 member。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sdiff('key1', 'key2')
// ["a", "b"]
- Redis官方文档：https://redis.io/commands/sdiffstore
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是所有指定 set 包含的总元素数。
命令行为和 SDIFF 一致，区别是 SDIFFSTORE 并不返回结果，而是将结果存入 destination，并返回结果集的元素个数。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sdiffstore('key', ['key1', 'key2'])
// 2
await client.smembers('key')
// ["a", "b"]
- Redis官方文档：https://redis.io/commands/sinter
- 起始版本：1.0.0
- 时间复杂度：最坏情况复杂度 O(N*M)，N 是最小集合元素个数，M 是集合个数。
返回所有给定 set 的交集。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sinter('key1', 'key2')
// ["c"]
- Redis官方文档：https://redis.io/commands/sinterstore
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是所有指定 set 包含的总元素数。
命令行为和 SINTER 一致，区别是 SINTERSTORE 并不返回结果，而是将结果存入 destination，并返回结果集的元素个数。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sinterstore('key', ['key1', 'key2'])
// 1
await client.smembers('key')
// ["c"]
- Redis官方文档：https://redis.io/commands/sismember
- 起始版本：1.0.0
- 时间复杂度：O(1)
判断 member 是否是给定 set 的元素。
返回值含义：
1 member 是给定集合的元素。0 member 不是给定集合的元素，或者 key 不存在。key 存在但是类型不是 set 的时候会抛出 WRONGTYPE Error。
例子：
await client.sadd('myset', 'one')
// 1
await client.sismember('myset', 'one')
// 1
await client.sismember('myset', 'two')
// 0
- Redis官方文档：https://redis.io/commands/smembers
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是集合基数。
列出全部给定集合的元素。对于只传递一个 key 的 SINTER 操作效果一样。
例子：
await client.sadd('myset', 'Hello', 'World')
// 2
await client.smembers('myset')
// ["World", "Hello"]
- Redis官方文档：https://redis.io/commands/smembers
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是集合基数。
列出全部给定集合的元素。对于只传递一个 key 的 SINTER 操作效果一样。
例子：
await client.sadd('myset', 'Hello', 'World')
// 2
await client.smembers('myset')
// ["World", "Hello"]
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/smismember
- 起始版本：6.2.0
- 时间复杂度：O(N) N 是需要检查的 member 数量。
返回指定 set 中一系列 member 的成员状态。对于每一个 member，1 表示是成员，0 表示不是成员。
例子：
await client.sadd('myset', 'one')
// 1
await client.sadd('myset', 'one')
// 1
await client.smismember('myset', 'one', 'notamember')
// [1, 0]
- Redis官方文档：https://redis.io/commands/smove
- 起始版本：1.0.0
- 时间复杂度：O(1)
从 source set 移动一个成员到 destination set。
返回值含义：
1 从 source set 中移除了 member。0 source set 不存在，或者 source set 中不包含 member。例子：
await client.sadd('myset', 'one', 'two')
// 2
await client.sadd('myotherset', 'three')
// 1
await client.smove('myset', 'myotherset', 'two')
// 1
await client.smembers('myset')
// ["one"]
await client.smembers('myotherset')
// ["two", "three"]
- Redis官方文档：https://redis.io/commands/spop
- 起始版本：1.0.0
- 时间复杂度：O(1)
随机的从指定 set 移除并返回指定个数的 member。默认返回一个。
这个命令和 SRANDMEMBER 有些类似，区别是此命令会同时移除返回的元素。
注意：3.2 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.spop('myset')
// "one"
await client.smembers('myset')
// ["three", "two"]
await client.sadd('myset', 'four', 'five')
// 2
await client.spop('myset', 3)
// ["five", "three", "two"]
await client.smembers('myset')
// ["four"]
- Redis官方文档：https://redis.io/commands/spop
- 起始版本：1.0.0
- 时间复杂度：O(1)
随机的从指定 set 移除并返回指定个数的 member。默认返回一个。
这个命令和 SRANDMEMBER 有些类似，区别是此命令会同时移除返回的元素。
注意：3.2 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.spop('myset')
// "one"
await client.smembers('myset')
// ["three", "two"]
await client.sadd('myset', 'four', 'five')
// 2
await client.spop('myset', 3)
// ["five", "three", "two"]
await client.smembers('myset')
// ["four"]
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/spop
- 起始版本：1.0.0
- 时间复杂度：O(1)
随机的从指定 set 移除并返回指定个数的 member。默认返回一个。
这个命令和 SRANDMEMBER 有些类似，区别是此命令会同时移除返回的元素。
注意：3.2 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.spop('myset')
// "one"
await client.smembers('myset')
// ["three", "two"]
await client.sadd('myset', 'four', 'five')
// 2
await client.spop('myset', 3)
// ["five", "three", "two"]
await client.smembers('myset')
// ["four"]
指定需要 pop 的元素个数。
- Redis官方文档：https://redis.io/commands/spop
- 起始版本：1.0.0
- 时间复杂度：O(1)
随机的从指定 set 移除并返回指定个数的 member。默认返回一个。
这个命令和 SRANDMEMBER 有些类似，区别是此命令会同时移除返回的元素。
注意：3.2 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.spop('myset')
// "one"
await client.smembers('myset')
// ["three", "two"]
await client.sadd('myset', 'four', 'five')
// 2
await client.spop('myset', 3)
// ["five", "three", "two"]
await client.smembers('myset')
// ["four"]
指定需要 pop 的元素个数。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/srandmember
- 起始版本：1.0.0
- 时间复杂度：不指定 count 参数时，复杂度为 O(1)，否则为 O(N) N 为 count。
随机的从 set 返回指定个数的 member。默认返回一个。
这个命令和 SPOP 有些类似，区别是此命令只返回的元素，而不修改 set。
不同参数设定方式对应的行为：
注意：2.6 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.srandmember('myset')
// "three"
await client.srandmember('myset', 5)
// ["two", "three", "one"]
await client.srandmember('myset', -5)
// ["three", "two", "two", "two", "three"]
await client.srandmember('myset', 0)
// []
- Redis官方文档：https://redis.io/commands/srandmember
- 起始版本：1.0.0
- 时间复杂度：不指定 count 参数时，复杂度为 O(1)，否则为 O(N) N 为 count。
随机的从 set 返回指定个数的 member。默认返回一个。
这个命令和 SPOP 有些类似，区别是此命令只返回的元素，而不修改 set。
不同参数设定方式对应的行为：
注意：2.6 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.srandmember('myset')
// "three"
await client.srandmember('myset', 5)
// ["two", "three", "one"]
await client.srandmember('myset', -5)
// ["three", "two", "two", "two", "three"]
await client.srandmember('myset', 0)
// []
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/srandmember
- 起始版本：1.0.0
- 时间复杂度：不指定 count 参数时，复杂度为 O(1)，否则为 O(N) N 为 count。
随机的从 set 返回指定个数的 member。默认返回一个。
这个命令和 SPOP 有些类似，区别是此命令只返回的元素，而不修改 set。
不同参数设定方式对应的行为：
注意：2.6 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.srandmember('myset')
// "three"
await client.srandmember('myset', 5)
// ["two", "three", "one"]
await client.srandmember('myset', -5)
// ["three", "two", "two", "two", "three"]
await client.srandmember('myset', 0)
// []
- Redis官方文档：https://redis.io/commands/srandmember
- 起始版本：1.0.0
- 时间复杂度：不指定 count 参数时，复杂度为 O(1)，否则为 O(N) N 为 count。
随机的从 set 返回指定个数的 member。默认返回一个。
这个命令和 SPOP 有些类似，区别是此命令只返回的元素，而不修改 set。
不同参数设定方式对应的行为：
注意：2.6 版本开始支持 count 参数。更早的版本只会默认返回一个元素。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.srandmember('myset')
// "three"
await client.srandmember('myset', 5)
// ["two", "three", "one"]
await client.srandmember('myset', -5)
// ["three", "two", "two", "two", "three"]
await client.srandmember('myset', 0)
// []
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/srem
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是要移除的 member 数量。
从 set 移除指定的一系列 member。如果指定的 member 不在 set 中，则被忽略。
如果 key 不存在被认为是个空的 set。如果 key 对应的值不是 set 类型会抛出异常。
注意：2.4 版本开始支持传递多个 member。更早的版本中一次命令调用只能移除一个 member。
例子：
await client.sadd('myset', 'one', 'two', 'three')
// 3
await client.srem('myset', 'one', 'four')
// 1
await client.smembers('myset')
// ["three", "two"]
- Redis官方文档：https://redis.io/commands/sscan
- 起始版本：2.8.0
- 时间复杂度：**每次调用的消耗为O(1)，完整迭代一次为 O(N)，包括足以使光标返回到 0 的命令调用。N 是集合内元素的数量。
详情参见 SCAN 命令。
- Redis官方文档：https://redis.io/commands/sscan
- 起始版本：2.8.0
- 时间复杂度：**每次调用的消耗为O(1)，完整迭代一次为 O(N)，包括足以使光标返回到 0 的命令调用。N 是集合内元素的数量。
详情参见 SCAN 命令。
以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/sunion
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为全部集合的元素总数。
返回所有给定的一系列 set 的并集。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sunion('key1', 'key2')
// ["e", "b", "c", "a", "d"]
- Redis官方文档：https://redis.io/commands/sunionstore
- 起始版本：1.0.0
- 时间复杂度：O(N) N 是所有指定 set 包含的总元素数。
命令行为和 SUNION 一致，区别是 SUNIONSTORE 并不返回结果，而是将结果存入 destination，并返回结果集的元素个数。
例子：
await client.sadd('key1', 'a', 'b', 'c')
// 3
await client.sadd('key2', 'c', 'd', 'e')
// 3
await client.sunionstore('key', ['key1', 'key2'])
// 5
await client.smembers('key')
// ["e", "b", "c", "a", "d"]
- Redis官方文档：https://redis.io/commands/bzpopmax
- 起始版本：5.0.0
- 时间复杂度：O(log(N)) N 是排序集的元素个数
BZPOPMAX 是阻塞版本的 ZPOPMAX 命令。
当指定的排序集中没有可弹出元素时会阻塞连接，直到有其他客户端向排序集中插入元素，或者超时。
更准确的语义请参考 BLPOP 命令。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.bzpopmax(['zset', 'zset1'], 0)
// ["zset", "four", "4"]
超时时间，单位秒。6.0 版本开始支持双精度浮点数表示，更早的版本只支持整数。
- Redis官方文档：https://redis.io/commands/bzpopmin
- 起始版本：5.0.0
- 时间复杂度：O(log(N)) N 是排序集的元素个数
BZPOPMAX 是阻塞版本的 ZPOPMIN 命令。
当指定的排序集中没有可弹出元素时会阻塞连接，直到有其他客户端向排序集中插入元素，或者超时。
更准确的语义请参考 BLPOP 命令。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.bzpopmin(['zset', 'zset1'], 0)
// ["zset", "one", "1"]
超时时间，单位秒。6.0 版本开始支持双精度浮点数表示，更早的版本只支持整数。
- Redis官方文档：https://redis.io/commands/zadd
- 起始版本：1.2.0
- 时间复杂度：每添加一个 item 的复杂度是 O(log(N))，N 是 zset 包含的元素
将指定的 score/member 对添加到 key 对应的 zset 中。可以指定多个 score/member 对。
如果指定的 member 已经存在于 zset 中，则将更新 score 并在正确的位置重新插入 member，以确保顺序正确。
+inf 和 -inf 也是有效值。Redis zset 使用 IEEE 754 64 位双精度浮点数 表示 score。
它能表示的整数范围是 [-(2^53), +(2^53)]。确切的说就是 [-9007199254740992, 9007199254740992]。
较大的整数或小数在内部以指数形式表示，因此只能获得十进制数字的近似值。
Redis zset 以 score 正序进行存储。相同的 member 只能存在一次，不允许出现重复的 member。
score 可以通过 ZADD 命令进行修改，它会更新 score，同时更新对应的 member 在排序集中的位置。
虽然排序集中 member 不可以重复，但是不同的 member 可以对应相同的 score。
当多个 member 对应相同的 score 时，它们会按照 字典序 进行排列。
字典序的意思是将字符串看作一个二进制数组，从头进行比较。
如果用户向一个排序集中以相同的分数（比如 0）插入所有 member，则这个排序集中的所有 member 按照字典序排列。
此时范围查询可以使用 ZRANGEBYLEX 命令。
incr_mode 的时候，返回整数，表示被添加的 member 数量。此时使用 CH 选项，则返回值表示被修改的 member 数量。incr_mode=true 则会将命令行为变为自增模式，此时只能接受一对 score/member，并返回修改后的 score。update_if_member: 'NX' | 'XX' 的时候，如果命令被终止则会返回 null。update_if_score: 'LT' | 'GT' 选项（对应 Redis 命令的 LT｜GT 选项）行为有些特殊。zset { a: '12' }，await client.zadd('zset', {a: '1'}, true, { update_if_score: 'LT' }) 。'13'，即执行了自增之后的结果，但实际上排序集的状态为 zset { a: '12' }，也就是没被修改。例子：
await client.sadd('myset', 'Hello')
// 1
await client.sadd('myset', 'World')
// 1
await client.sadd('myset', 'World')
// 0
await client.smembers('myset')
// ["World", "Hello"]
2.4 版本开始支持多组 member/score，更早的版本只能传递一组 member/score。
- Redis官方文档：https://redis.io/commands/zadd
- 起始版本：1.2.0
- 时间复杂度：每添加一个 item 的复杂度是 O(log(N))，N 是 zset 包含的元素
将指定的 score/member 对添加到 key 对应的 zset 中。可以指定多个 score/member 对。
如果指定的 member 已经存在于 zset 中，则将更新 score 并在正确的位置重新插入 member，以确保顺序正确。
+inf 和 -inf 也是有效值。Redis zset 使用 IEEE 754 64 位双精度浮点数 表示 score。
它能表示的整数范围是 [-(2^53), +(2^53)]。确切的说就是 [-9007199254740992, 9007199254740992]。
较大的整数或小数在内部以指数形式表示，因此只能获得十进制数字的近似值。
Redis zset 以 score 正序进行存储。相同的 member 只能存在一次，不允许出现重复的 member。
score 可以通过 ZADD 命令进行修改，它会更新 score，同时更新对应的 member 在排序集中的位置。
虽然排序集中 member 不可以重复，但是不同的 member 可以对应相同的 score。
当多个 member 对应相同的 score 时，它们会按照 字典序 进行排列。
字典序的意思是将字符串看作一个二进制数组，从头进行比较。
如果用户向一个排序集中以相同的分数（比如 0）插入所有 member，则这个排序集中的所有 member 按照字典序排列。
此时范围查询可以使用 ZRANGEBYLEX 命令。
incr_mode 的时候，返回整数，表示被添加的 member 数量。此时使用 CH 选项，则返回值表示被修改的 member 数量。incr_mode=true 则会将命令行为变为自增模式，此时只能接受一对 score/member，并返回修改后的 score。update_if_member: 'NX' | 'XX' 的时候，如果命令被终止则会返回 null。update_if_score: 'LT' | 'GT' 选项（对应 Redis 命令的 LT｜GT 选项）行为有些特殊。zset { a: '12' }，await client.zadd('zset', {a: '1'}, true, { update_if_score: 'LT' }) 。'13'，即执行了自增之后的结果，但实际上排序集的状态为 zset { a: '12' }，也就是没被修改。例子：
await client.sadd('myset', 'Hello')
// 1
await client.sadd('myset', 'World')
// 1
await client.sadd('myset', 'World')
// 0
await client.smembers('myset')
// ["World", "Hello"]
2.4 版本开始支持多组 member/score，更早的版本只能传递一组 member/score。
自增模式，3.0.2 版本开始可用。
- Redis官方文档：https://redis.io/commands/zcard
- 起始版本：1.2.0
- 时间复杂度：O(1)
返回排序集的成员总数量。当 key 不存在时返回 0。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zcard('zset')
// 4
- Redis官方文档：https://redis.io/commands/zcount
- 起始版本：2.0.0
- 时间复杂度：O(log(N)) N 是排序集中的成员数量。
返回排序集中 score 在 min 和 max 之间的成员数量。
min 和 max 的语义与 ZRANGEBYSCORE 命令一致。
注意：此命令的复杂度仅为 O(log(N)) 是因为他查询的 member 是有序的。因此，查询无需遍历整个排序集。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zcount('zset', '-inf', '+inf')
// 3
await client.zcount('zset', '(1', '3')
// 2
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zdiff
- 起始版本：6.2.0
- 时间复杂度：最坏情况复杂度为 O(L+(N-K)log(N))，L 是全部排序集中的成员数量，N 是第一个排序集的成员数量，K 是结果集的大小。
这个命令类似 ZDIFFSTORE，区别是 ZDIFF 不会存储结果，而是将结果返回到客户端。
例子：
await client.zadd('zset1', { one: 1, two: 2, three: 3 })
// 3
await client.zadd('zset2', { one: 1, two: 2 })
// 2
await client.zdiff(['zset1', 'zset2'])
// ["three"]
await client.zdiff(['zset1', 'zset2'], true)
// ["three", "3"]
- Redis官方文档：https://redis.io/commands/zdiff
- 起始版本：6.2.0
- 时间复杂度：最坏情况复杂度为 O(L+(N-K)log(N))，L 是全部排序集中的成员数量，N 是第一个排序集的成员数量，K 是结果集的大小。
这个命令类似 ZDIFFSTORE，区别是 ZDIFF 不会存储结果，而是将结果返回到客户端。
例子：
await client.zadd('zset1', { one: 1, two: 2, three: 3 })
// 3
await client.zadd('zset2', { one: 1, two: 2 })
// 2
await client.zdiff(['zset1', 'zset2'])
// ["three"]
await client.zdiff(['zset1', 'zset2'], true)
// ["three", "3"]
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zdiffstore
- 起始版本：6.2.0
- 时间复杂度：最坏情况复杂度为 O(L+(N-K)log(N))，L 是全部排序集中的成员数量，N 是第一个排序集的成员数量，K 是结果集的大小。
计算第一个排序集和随后的其他排序集的差集，并将结果存入 destination。
不存在的 key 被认为是个空集。
如果 destination 已经存在则会被重写。
例子：
await client.zadd('zset1', { one: 1, two: 2, three: 3 })
// 3
await client.zadd('zset2', { one: 1, two: 2 })
// 2
await client.zdiffstore('out', ['zset1', 'zset2'])
// 1
await client.zrange('out', { by: 'BYSCORE', min: '-inf', max: '+inf' }, true)
// ["three", "3"]
用来存储结果的目标 key。
- Redis官方文档：https://redis.io/commands/zincrby
- 起始版本：1.2.0
- 时间复杂度：O(log(N)) N 是排序集的成员数量。
将指定 member 的 score 进行自增操作。
如果 member 不存在，就将自增值直接存到 member（就像它之前的值是 0.0）。
如果 key 不存在，则创建一个只含有 member 的排序集。
如果 key 存在但是值不是排序集则会返回错误。
score 需要是字符串形式的数字，可以接受双精度浮点数。可以通过指定一个负数的 score 来进行自减操作。
例子：
await client.zadd('zset', { one: 1, two: 2 })
// 2
await client.zincrby('zset', '2', 'one')
// "3"
await client.zrange('zset', { min: 0, max: -1 }, true)
// ["two", "2", "three", "3"]
- Redis官方文档：https://redis.io/commands/zinter
- 起始版本：6.2.0
- 时间复杂度：最坏情况复杂度为 O(NK)+O(Mlog(M)) N 是最小排序集，K 是排序集数量，M 是结果集大小。
这个命令类似 ZINTERSTORE 命令，区别是 ZINTER 不会存储结果，而是将结果返回到客户端。
具体参数选项的语义请参考 ZINTERSTORE 命令。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zinter(['zset1', 'zset2'])
// ["one", "two"]
await client.zinter(['zset1', 'zset2'], true)
// ["one", "2", "two", "4"]
- Redis官方文档：https://redis.io/commands/zinter
- 起始版本：6.2.0
- 时间复杂度：最坏情况复杂度为 O(NK)+O(Mlog(M)) N 是最小排序集，K 是排序集数量，M 是结果集大小。
这个命令类似 ZINTERSTORE 命令，区别是 ZINTER 不会存储结果，而是将结果返回到客户端。
具体参数选项的语义请参考 ZINTERSTORE 命令。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zinter(['zset1', 'zset2'])
// ["one", "two"]
await client.zinter(['zset1', 'zset2'], true)
// ["one", "2", "two", "4"]
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zinterstore
- 起始版本：2.0.0
- 时间复杂度：最坏情况复杂度为 O(NK)+O(Mlog(M)) N 是最小排序集，K 是排序集数量，M 是结果集大小。
计算给定一系列的排序集的交集，并将结果存储到 destination 中。如果 destination 已经存在则会被重写。
默认结果集中的 score 是该成员在所有集合中对应的 score 的和。
aggregate 和 weights 参数的说明见 ZUNIONSTORE 命令。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zinterstore('out', ['zset1', 'zset2'], { weights: [2, 3] })
// 2
await client.zrange('out', { min: 0, max: -1 }, true)
// ["one", "5", "two", "10"]
- Redis官方文档：https://redis.io/commands/zlexcount
- 起始版本：2.8.9
- 时间复杂度：O(log(N)) N 是排序集中成员数量。
当排序集中的全部元素使用相同的分数存储时，成员按照字典序排列，此时此命令可以用来返回字典序在 min 和 max 之间的成员。
min 和 max 参数的详细语义参考 ZRANGEBYLEX 命令。
例子：
await client.zadd('zset', { a: 0, b: 0, c: 0, d: 0, e: 0 })
// 5
await client.zadd('zset', { f: 0, g: 0 })
// 2
await client.zlexcount('zset', '-', '+')
// 7
await client.zlexcount('zset', '[b', '[f')
// 5
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zmscore
- 起始版本：6.2.0
- 时间复杂度：O(N) N 是请求的成员数量。
以数组形式返回指定的一系列 member 对应的 score。
对于每个不存在的 member 返回 null。
例子：
await client.zadd('myzset', { one: 1 })
// 1
await client.zadd('myzset', { two: 2 })
// 1
await client.zmscore('myzset', ['one', 'two', 'nofield'])
// ["1", "2", null]
- Redis官方文档：https://redis.io/commands/zpopmax
- 起始版本：5.0.0
- 时间复杂度：O(log(N) * M) N 是排序集的元素个数，M 是弹出的元素个数。
移除并返回排序集中 score 排名前 count 个 member/score。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zpopmax('zset', 2)
// ["four", "4", "three", "3"]
await client.zpopmax('zset')
// ["two", "2"]
- Redis官方文档：https://redis.io/commands/zpopmin
- 起始版本：5.0.0
- 时间复杂度：O(log(N) * M) N 是排序集的元素个数，M 是弹出的元素个数。
移除并返回排序集中 score 排名后 count 个 member/score。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zpopmin('zset', 2)
// ["one", "1", "two", "2"]
await client.zpopmin('zset')
// ["three", "3"]
- Redis官方文档：https://redis.io/commands/zrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员个数，M 是结果元素成员。
返回指定范围的成员，通过指定 range 参数中的 by 选项，可以让命令实施不同的行为。默认按照索引排序选取。
6.2.0 版本开始，ZRANGE 可以替代 ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX、ZREVRANGEBYLEX 五个命令。
成员的排列顺序为从低到高。分数相同的成员按照字典序排列。
ZRANGE 默认按照索引排序进行范围选取。min 和 max 参数是从 0 开始的索引计数，0 表示第一个元素，1 表示第二个元素，以此类推。
这些参数指定了一个闭区间，比如：{min: 0, max: 1} 表示的范围就是排序集的第一个和第二个元素。
索引可以是负数，表示到排序集末尾的距离，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
超出实际范围的索引会导致返回错误。
如果 min 比 max 大或者比 end 对应的索引大，会返回一个空列表。
如果 max 比 end 对应的索引大，Redis 会认为这个 max 指定了最后一个元素。
当 range 参数中设置了 BYSCORE，命令行为会和 ZRANGEBYSCORE 命令一致，返回分数介于 min 和 max 之间的成员。
min 和 max 可以使用值，'-inf' 和 '+inf'，分别表示负无穷大和正无穷大。这意味着你不需要知道实际的最大分数或最小分数，也能选取全部的成员。
通过 min 和 max 指定的区间范围默认是闭区间，也就是包含 min 和 max 本身。可以通过在分数前缀 ( 表示排除 min 或者 max。
当 range 参数中设置了 BYLEX，命令行为会和 ZRANGEBYLEX 命令一致，按照字典序返回介于 min 和 max 之间的元素。
注意：字典序范围选取依赖 排序集中的成员分数全部一致，在分数不一致的情况下，选取行为是未定义的。
在字典序模式下，min 和 max 必须以 (（不包含本身） 或 [（包含本身）开头。
min 和 max 可以使用特殊值 - 和 + 分别表示无穷小的字符串和无穷大的字符串。
字典序：member 名称（字符串）被认为是一个 byte array，通过逐位比较大小确定排序。这和字符串的字符集有关。
例子：
await client.zadd('myzset', { one: 1, two: 2, three: 3 })
// 3
await client.zrange('myzset', { min: 0, max: -1 })
// ["one", "two", "three"]
await client.zrange('myzset', { min: 2, max: 3 })
// ["three"]
await client.zrange('myzset', { min: -2, max: -1 })
// ["two", "three"]
await client.zrange('myzset', { min: 0, max: 1 }, true)
// ["one", "1", "two", "2"]
await client.zrange('myzset', { by: 'BYSCORE', min: '(1', max: '+inf' }, { limit: [1, 1] })
// ["three"]
- Redis官方文档：https://redis.io/commands/zrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员个数，M 是结果元素成员。
返回指定范围的成员，通过指定 range 参数中的 by 选项，可以让命令实施不同的行为。默认按照索引排序选取。
6.2.0 版本开始，ZRANGE 可以替代 ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX、ZREVRANGEBYLEX 五个命令。
成员的排列顺序为从低到高。分数相同的成员按照字典序排列。
ZRANGE 默认按照索引排序进行范围选取。min 和 max 参数是从 0 开始的索引计数，0 表示第一个元素，1 表示第二个元素，以此类推。
这些参数指定了一个闭区间，比如：{min: 0, max: 1} 表示的范围就是排序集的第一个和第二个元素。
索引可以是负数，表示到排序集末尾的距离，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
超出实际范围的索引会导致返回错误。
如果 min 比 max 大或者比 end 对应的索引大，会返回一个空列表。
如果 max 比 end 对应的索引大，Redis 会认为这个 max 指定了最后一个元素。
当 range 参数中设置了 BYSCORE，命令行为会和 ZRANGEBYSCORE 命令一致，返回分数介于 min 和 max 之间的成员。
min 和 max 可以使用值，'-inf' 和 '+inf'，分别表示负无穷大和正无穷大。这意味着你不需要知道实际的最大分数或最小分数，也能选取全部的成员。
通过 min 和 max 指定的区间范围默认是闭区间，也就是包含 min 和 max 本身。可以通过在分数前缀 ( 表示排除 min 或者 max。
当 range 参数中设置了 BYLEX，命令行为会和 ZRANGEBYLEX 命令一致，按照字典序返回介于 min 和 max 之间的元素。
注意：字典序范围选取依赖 排序集中的成员分数全部一致，在分数不一致的情况下，选取行为是未定义的。
在字典序模式下，min 和 max 必须以 (（不包含本身） 或 [（包含本身）开头。
min 和 max 可以使用特殊值 - 和 + 分别表示无穷小的字符串和无穷大的字符串。
字典序：member 名称（字符串）被认为是一个 byte array，通过逐位比较大小确定排序。这和字符串的字符集有关。
例子：
await client.zadd('myzset', { one: 1, two: 2, three: 3 })
// 3
await client.zrange('myzset', { min: 0, max: -1 })
// ["one", "two", "three"]
await client.zrange('myzset', { min: 2, max: 3 })
// ["three"]
await client.zrange('myzset', { min: -2, max: -1 })
// ["two", "three"]
await client.zrange('myzset', { min: 0, max: 1 }, true)
// ["one", "1", "two", "2"]
await client.zrange('myzset', { by: 'BYSCORE', min: '(1', max: '+inf' }, { limit: [1, 1] })
// ["three"]
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员个数，M 是结果元素成员。
返回指定范围的成员，通过指定 range 参数中的 by 选项，可以让命令实施不同的行为。默认按照索引排序选取。
6.2.0 版本开始，ZRANGE 可以替代 ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX、ZREVRANGEBYLEX 五个命令。
成员的排列顺序为从低到高。分数相同的成员按照字典序排列。
ZRANGE 默认按照索引排序进行范围选取。min 和 max 参数是从 0 开始的索引计数，0 表示第一个元素，1 表示第二个元素，以此类推。
这些参数指定了一个闭区间，比如：{min: 0, max: 1} 表示的范围就是排序集的第一个和第二个元素。
索引可以是负数，表示到排序集末尾的距离，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
超出实际范围的索引会导致返回错误。
如果 min 比 max 大或者比 end 对应的索引大，会返回一个空列表。
如果 max 比 end 对应的索引大，Redis 会认为这个 max 指定了最后一个元素。
当 range 参数中设置了 BYSCORE，命令行为会和 ZRANGEBYSCORE 命令一致，返回分数介于 min 和 max 之间的成员。
min 和 max 可以使用值，'-inf' 和 '+inf'，分别表示负无穷大和正无穷大。这意味着你不需要知道实际的最大分数或最小分数，也能选取全部的成员。
通过 min 和 max 指定的区间范围默认是闭区间，也就是包含 min 和 max 本身。可以通过在分数前缀 ( 表示排除 min 或者 max。
当 range 参数中设置了 BYLEX，命令行为会和 ZRANGEBYLEX 命令一致，按照字典序返回介于 min 和 max 之间的元素。
注意：字典序范围选取依赖 排序集中的成员分数全部一致，在分数不一致的情况下，选取行为是未定义的。
在字典序模式下，min 和 max 必须以 (（不包含本身） 或 [（包含本身）开头。
min 和 max 可以使用特殊值 - 和 + 分别表示无穷小的字符串和无穷大的字符串。
字典序：member 名称（字符串）被认为是一个 byte array，通过逐位比较大小确定排序。这和字符串的字符集有关。
例子：
await client.zadd('myzset', { one: 1, two: 2, three: 3 })
// 3
await client.zrange('myzset', { min: 0, max: -1 })
// ["one", "two", "three"]
await client.zrange('myzset', { min: 2, max: 3 })
// ["three"]
await client.zrange('myzset', { min: -2, max: -1 })
// ["two", "three"]
await client.zrange('myzset', { min: 0, max: 1 }, true)
// ["one", "1", "two", "2"]
await client.zrange('myzset', { by: 'BYSCORE', min: '(1', max: '+inf' }, { limit: [1, 1] })
// ["three"]
- Redis官方文档：https://redis.io/commands/zrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员个数，M 是结果元素成员。
返回指定范围的成员，通过指定 range 参数中的 by 选项，可以让命令实施不同的行为。默认按照索引排序选取。
6.2.0 版本开始，ZRANGE 可以替代 ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX、ZREVRANGEBYLEX 五个命令。
成员的排列顺序为从低到高。分数相同的成员按照字典序排列。
ZRANGE 默认按照索引排序进行范围选取。min 和 max 参数是从 0 开始的索引计数，0 表示第一个元素，1 表示第二个元素，以此类推。
这些参数指定了一个闭区间，比如：{min: 0, max: 1} 表示的范围就是排序集的第一个和第二个元素。
索引可以是负数，表示到排序集末尾的距离，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
超出实际范围的索引会导致返回错误。
如果 min 比 max 大或者比 end 对应的索引大，会返回一个空列表。
如果 max 比 end 对应的索引大，Redis 会认为这个 max 指定了最后一个元素。
当 range 参数中设置了 BYSCORE，命令行为会和 ZRANGEBYSCORE 命令一致，返回分数介于 min 和 max 之间的成员。
min 和 max 可以使用值，'-inf' 和 '+inf'，分别表示负无穷大和正无穷大。这意味着你不需要知道实际的最大分数或最小分数，也能选取全部的成员。
通过 min 和 max 指定的区间范围默认是闭区间，也就是包含 min 和 max 本身。可以通过在分数前缀 ( 表示排除 min 或者 max。
当 range 参数中设置了 BYLEX，命令行为会和 ZRANGEBYLEX 命令一致，按照字典序返回介于 min 和 max 之间的元素。
注意：字典序范围选取依赖 排序集中的成员分数全部一致，在分数不一致的情况下，选取行为是未定义的。
在字典序模式下，min 和 max 必须以 (（不包含本身） 或 [（包含本身）开头。
min 和 max 可以使用特殊值 - 和 + 分别表示无穷小的字符串和无穷大的字符串。
字典序：member 名称（字符串）被认为是一个 byte array，通过逐位比较大小确定排序。这和字符串的字符集有关。
例子：
await client.zadd('myzset', { one: 1, two: 2, three: 3 })
// 3
await client.zrange('myzset', { min: 0, max: -1 })
// ["one", "two", "three"]
await client.zrange('myzset', { min: 2, max: 3 })
// ["three"]
await client.zrange('myzset', { min: -2, max: -1 })
// ["two", "three"]
await client.zrange('myzset', { min: 0, max: 1 }, true)
// ["one", "1", "two", "2"]
await client.zrange('myzset', { by: 'BYSCORE', min: '(1', max: '+inf' }, { limit: [1, 1] })
// ["three"]
- Redis官方文档：https://redis.io/commands/zrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员个数，M 是结果元素成员。
返回指定范围的成员，通过指定 range 参数中的 by 选项，可以让命令实施不同的行为。默认按照索引排序选取。
6.2.0 版本开始，ZRANGE 可以替代 ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE、ZRANGEBYLEX、ZREVRANGEBYLEX 五个命令。
成员的排列顺序为从低到高。分数相同的成员按照字典序排列。
ZRANGE 默认按照索引排序进行范围选取。min 和 max 参数是从 0 开始的索引计数，0 表示第一个元素，1 表示第二个元素，以此类推。
这些参数指定了一个闭区间，比如：{min: 0, max: 1} 表示的范围就是排序集的第一个和第二个元素。
索引可以是负数，表示到排序集末尾的距离，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。
超出实际范围的索引会导致返回错误。
如果 min 比 max 大或者比 end 对应的索引大，会返回一个空列表。
如果 max 比 end 对应的索引大，Redis 会认为这个 max 指定了最后一个元素。
当 range 参数中设置了 BYSCORE，命令行为会和 ZRANGEBYSCORE 命令一致，返回分数介于 min 和 max 之间的成员。
min 和 max 可以使用值，'-inf' 和 '+inf'，分别表示负无穷大和正无穷大。这意味着你不需要知道实际的最大分数或最小分数，也能选取全部的成员。
通过 min 和 max 指定的区间范围默认是闭区间，也就是包含 min 和 max 本身。可以通过在分数前缀 ( 表示排除 min 或者 max。
当 range 参数中设置了 BYLEX，命令行为会和 ZRANGEBYLEX 命令一致，按照字典序返回介于 min 和 max 之间的元素。
注意：字典序范围选取依赖 排序集中的成员分数全部一致，在分数不一致的情况下，选取行为是未定义的。
在字典序模式下，min 和 max 必须以 (（不包含本身） 或 [（包含本身）开头。
min 和 max 可以使用特殊值 - 和 + 分别表示无穷小的字符串和无穷大的字符串。
字典序：member 名称（字符串）被认为是一个 byte array，通过逐位比较大小确定排序。这和字符串的字符集有关。
例子：
await client.zadd('myzset', { one: 1, two: 2, three: 3 })
// 3
await client.zrange('myzset', { min: 0, max: -1 })
// ["one", "two", "three"]
await client.zrange('myzset', { min: 2, max: 3 })
// ["three"]
await client.zrange('myzset', { min: -2, max: -1 })
// ["two", "three"]
await client.zrange('myzset', { min: 0, max: 1 }, true)
// ["one", "1", "two", "2"]
await client.zrange('myzset', { by: 'BYSCORE', min: '(1', max: '+inf' }, { limit: [1, 1] })
// ["three"]
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zrangebylex
- 起始版本：2.8.9
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是需要返回的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
当排序集中的全部成员含有相同的 score 时，成员按照字典序排列，ZRANGEBYLEX 可以在这种情况下返回字典序介于 min 和 max 之间的所有成员。
成员按照从低到高的顺序排列，比较方式是 c 函数 memcmp()，也就是逐个字节比较字符串。如果公共部分相同，更长的字符串更大。
在 Redis 6.2.0 版本，这个命令可能被废弃。请在新代码中使用带 BYLEX 参数的 ZRANGE 命令。
可选参数 limit 可以用来限制返回成员数量（类似 SQL 中的 SELECT LIMIT offset, count）。负数的 count 表示返回 offset 后的全部元素。
需要注意的是，如果 offset 很大，排序集在找到需要返回的元素前要先遍历 offset 个元素。这可能会增加 O(N) 的复杂度。
合法的 min 和 max 值需要以 [ 或者 ( 开头，分别表示端值被包含和不被包含。特殊值 + 和 - 分表表示无穷大和无穷小的字符串。
所以当全部成员有相同的分数时 await client.zrangebylex('zset', '-', '+') 表示选择全部成员。
字符串作为字节数组进行比较，这在使用纯 ASCII 编码时没有问题，因为 ASCII 编码的字节顺序就是按照字典顺序来的。但是在使用其他字符编码是情况则不一定如此，比如 UTF-8 编码。
另外，用户可以自己做一个转码，保证最前面部分的字符串编码是按照期望进行排列的。
比如，你希望进行一个大小写不敏感的字符串排序，但是又希望保留原始字符串，那你可以如下设置一个排序集：
zset { 'foo:Foo': 0, 'bar:BAR': 0, 'zap:zap': 0 }
将全部字符转为小写，并通过分号和原字符串拼接起来。由于分号的字节比所有字母都要大，所以可以通过这种方式强制按照分号前的部分进行排序。而应用可以根据查询结果进行分割限制后面一部分的实际内容。
利用二进制进行比较的特性，可以让排序集成为通用索引。
例如，元素的第一部分可以是 64 位大端数字：由于大端数字在初始位置具有最高有效字节，因此二进制比较的结果和直接比较数字是一致的。
可以使用它来对 64 位值执行范围查询。
例子：
await client.zadd('zset', { a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, g: 0 })
// 7
await client.zrangebylex('zset', '-', '[c')
// ["a", "b", "c"]
await client.zrangebylex('zset', '-', '(c')
// ["a", "b"]
await client.zrangebylex('zset', '[aaa', '(g')
// ["b", "c", "d", "e", "f"]
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count
- Redis官方文档：https://redis.io/commands/zrangebyscore
- 起始版本：1.0.5
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是需要返回的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中 score 在 min 和 max 之间的一系列 member。当设置了 withscores 参数时，返回一系列 member/score 对。
返回元素默认按照分数从小到大排列。
具有相同分数的成员按照字典序排列（这来自于 Redis 排序集的一个默认行为，不涉及进一步计算）。
在 Redis 6.2.0 版本，这个命令可能被废弃。请在新代码中使用带 BYSCORE 参数的 ZRANGE 命令。
可选参数 limit 可以用来限制返回成员数量（类似 SQL 中的 SELECT LIMIT offset, count）。负数的 count 表示返回 offset 后的全部元素。
需要注意的是，如果 offset 很大，排序集在找到需要返回的元素前要先遍历 offset 个元素。这可能会增加 O(N) 的复杂度。
可选参数 withscores 表示让命令返回 member/score 对，而不是只返回 member 本身。这个选项在 2.0 版本开始可用。
min 和 max 可以使用值 '-inf' 和 +inf 分别表示排序集中的最小值和最大值。
默认指定的 min 和 max 是被包含在选择范围内的（闭区间）。
通过添加前缀 '(' 可以表示排除 min 或者 max 本身（开区间）。
如：(1 5 表示 1 < score <= 5，(5 (10 表示 5 < score < 10。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrangebyscore('zset', '-inf', '+inf')
// ["one", "two", "three"]
await client.zrangebyscore('zset', '1', '2')
// ["one", "two"]
await client.zrangebyscore('zset', '(1', '2')
// ["two"]
await client.zrangebyscore('zset', '(1', '(2')
// []
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zrangebyscore
- 起始版本：1.0.5
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是需要返回的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中 score 在 min 和 max 之间的一系列 member。当设置了 withscores 参数时，返回一系列 member/score 对。
返回元素默认按照分数从小到大排列。
具有相同分数的成员按照字典序排列（这来自于 Redis 排序集的一个默认行为，不涉及进一步计算）。
在 Redis 6.2.0 版本，这个命令可能被废弃。请在新代码中使用带 BYSCORE 参数的 ZRANGE 命令。
可选参数 limit 可以用来限制返回成员数量（类似 SQL 中的 SELECT LIMIT offset, count）。负数的 count 表示返回 offset 后的全部元素。
需要注意的是，如果 offset 很大，排序集在找到需要返回的元素前要先遍历 offset 个元素。这可能会增加 O(N) 的复杂度。
可选参数 withscores 表示让命令返回 member/score 对，而不是只返回 member 本身。这个选项在 2.0 版本开始可用。
min 和 max 可以使用值 '-inf' 和 +inf 分别表示排序集中的最小值和最大值。
默认指定的 min 和 max 是被包含在选择范围内的（闭区间）。
通过添加前缀 '(' 可以表示排除 min 或者 max 本身（开区间）。
如：(1 5 表示 1 < score <= 5，(5 (10 表示 5 < score < 10。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrangebyscore('zset', '-inf', '+inf')
// ["one", "two", "three"]
await client.zrangebyscore('zset', '1', '2')
// ["one", "two"]
await client.zrangebyscore('zset', '(1', '2')
// ["two"]
await client.zrangebyscore('zset', '(1', '(2')
// []
选取范围的最小值。
选取范围的最大值。
以 member/score 对形式返回结果，2.0.0 版本开始可用。
- Redis官方文档：https://redis.io/commands/zrangebyscore
- 起始版本：1.0.5
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是需要返回的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中 score 在 min 和 max 之间的一系列 member。当设置了 withscores 参数时，返回一系列 member/score 对。
返回元素默认按照分数从小到大排列。
具有相同分数的成员按照字典序排列（这来自于 Redis 排序集的一个默认行为，不涉及进一步计算）。
在 Redis 6.2.0 版本，这个命令可能被废弃。请在新代码中使用带 BYSCORE 参数的 ZRANGE 命令。
可选参数 limit 可以用来限制返回成员数量（类似 SQL 中的 SELECT LIMIT offset, count）。负数的 count 表示返回 offset 后的全部元素。
需要注意的是，如果 offset 很大，排序集在找到需要返回的元素前要先遍历 offset 个元素。这可能会增加 O(N) 的复杂度。
可选参数 withscores 表示让命令返回 member/score 对，而不是只返回 member 本身。这个选项在 2.0 版本开始可用。
min 和 max 可以使用值 '-inf' 和 +inf 分别表示排序集中的最小值和最大值。
默认指定的 min 和 max 是被包含在选择范围内的（闭区间）。
通过添加前缀 '(' 可以表示排除 min 或者 max 本身（开区间）。
如：(1 5 表示 1 < score <= 5，(5 (10 表示 5 < score < 10。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrangebyscore('zset', '-inf', '+inf')
// ["one", "two", "three"]
await client.zrangebyscore('zset', '1', '2')
// ["one", "two"]
await client.zrangebyscore('zset', '(1', '2')
// ["two"]
await client.zrangebyscore('zset', '(1', '(2')
// []
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count
- Redis官方文档：https://redis.io/commands/zrangebyscore
- 起始版本：1.0.5
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是需要返回的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中 score 在 min 和 max 之间的一系列 member。当设置了 withscores 参数时，返回一系列 member/score 对。
返回元素默认按照分数从小到大排列。
具有相同分数的成员按照字典序排列（这来自于 Redis 排序集的一个默认行为，不涉及进一步计算）。
在 Redis 6.2.0 版本，这个命令可能被废弃。请在新代码中使用带 BYSCORE 参数的 ZRANGE 命令。
可选参数 limit 可以用来限制返回成员数量（类似 SQL 中的 SELECT LIMIT offset, count）。负数的 count 表示返回 offset 后的全部元素。
需要注意的是，如果 offset 很大，排序集在找到需要返回的元素前要先遍历 offset 个元素。这可能会增加 O(N) 的复杂度。
可选参数 withscores 表示让命令返回 member/score 对，而不是只返回 member 本身。这个选项在 2.0 版本开始可用。
min 和 max 可以使用值 '-inf' 和 +inf 分别表示排序集中的最小值和最大值。
默认指定的 min 和 max 是被包含在选择范围内的（闭区间）。
通过添加前缀 '(' 可以表示排除 min 或者 max 本身（开区间）。
如：(1 5 表示 1 < score <= 5，(5 (10 表示 5 < score < 10。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrangebyscore('zset', '-inf', '+inf')
// ["one", "two", "three"]
await client.zrangebyscore('zset', '1', '2')
// ["one", "two"]
await client.zrangebyscore('zset', '(1', '2')
// ["two"]
await client.zrangebyscore('zset', '(1', '(2')
// []
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count
以 member/score 对形式返回结果，2.0.0 版本开始可用。
- Redis官方文档：https://redis.io/commands/zrangestore
- 起始版本：6.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是结果集成员数量。
这个命令类似 ZRANGE 命令，区别是 ZRANGESTORE 会将结果存入 destination。
返回结果集成员数量。
例子：
await client.zadd('srczset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zrangestore('dstzset', 'srczset', { min: 2, max: -1 })
// 2
await client.zrange('dstzset', { min: 0, max: -1 })
// ["three", "four"]
返回存入 destination 的结果集的成员数量。
- Redis官方文档：https://redis.io/commands/zrangestore
- 起始版本：6.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是结果集成员数量。
这个命令类似 ZRANGE 命令，区别是 ZRANGESTORE 会将结果存入 destination。
返回结果集成员数量。
例子：
await client.zadd('srczset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zrangestore('dstzset', 'srczset', { min: 2, max: -1 })
// 2
await client.zrange('dstzset', { min: 0, max: -1 })
// ["three", "four"]
返回存入 destination 的结果集的成员数量。
- Redis官方文档：https://redis.io/commands/zrangestore
- 起始版本：6.2.0
- 时间复杂度：O(log(N)+M) N 是排序集中的成员数量，M 是结果集成员数量。
这个命令类似 ZRANGE 命令，区别是 ZRANGESTORE 会将结果存入 destination。
返回结果集成员数量。
例子：
await client.zadd('srczset', { one: 1, two: 2, three: 3, four: 4 })
// 4
await client.zrangestore('dstzset', 'srczset', { min: 2, max: -1 })
// 2
await client.zrange('dstzset', { min: 0, max: -1 })
// ["three", "four"]
返回存入 destination 的结果集的成员数量。
- Redis官方文档：https://redis.io/commands/zrank
- 起始版本：2.0.0
- 时间复杂度：O(log(N))
返回 member 在排序集中的顺位，排序规则为按照 score 从低到高。顺位是从 0 开始计数的，也就是说 0 表示第一顺位。
如果需要查询 score 从高到低的顺位可以使用 ZREVRANK 命令。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrank('zset', 'three')
// 2
await client.zrank('zset', 'four')
// null
- Redis官方文档：https://redis.io/commands/zrem
- 起始版本：1.2.0
- 时间复杂度：O(M*log(N)) N 是排序集中的总元素数量，M 是需要移除的元素数量。
从排序集移除指定成员。不存在的成员会被忽略。
如果 key 存在但是对应的值不是排序集会返回错误。
返回从排序集中移除的成员数量，但是不包括不存在的成员。
注意：2.4 版本开始可以指定多个 member，更早的版本中每次命令调用只能移除一个 member。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrem('zset', ['two'])
// 1
await client.zrange('zset', { min: 0, max: -1 }, true)
// ["one", "1", "three", "3"]
- Redis官方文档：https://redis.io/commands/zremrangebylex
- 起始版本：2.8.9
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
当排序集中的全部成员含有相同的 score 时，成员按照字典序排列，ZREMRANGEBYLEX 可以在这种情况下移除 min 和 max 之间的所有成员。
此命令中的 min 和 max 的语义和 ZRANGEBYLEX 命令相同。
例子：
await client.zadd('zset', { aaaa: 0, b: 0, c: 0, d: 0, e: 0 })
// 5
await client.zadd('zset', { foo: 0, zap: 0, zip: 0, ALPHA: 0, alpha: 0 })
// 5
await client.zrange('zset', { min: 0, max: -1 })
// ["ALPHA", "aaaa", "alpha", "b", "c", "d", "e", "foo", "zap", "zip"]
await client.zremrangebylex('zset', '[alpha', '[omega')
// 6
await client.zrange('zset', { min: 0, max: -1 })
// ["ALPHA", "aaaa", "alpha", "b", "c", "d", "e", "foo", "zap", "zip"]
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zremrangebyrank
- 起始版本：2.0.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
从排序集中移除顺位在 start 和 stop 中间的全部成员。
start 和 stop 都是从 0 开始计数的从低到高的顺位。start 和 stop 可以是负数，表示从高到低的顺位。-1 表示倒数第一个元素，-2 表示倒数第二个元素，以此类推。
返回被移除的元素个数。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zremrangebyrank('zset', 0, 1)
// 2
await client.zrange('zset', { min: 0, max: -1 }, true)
// ["three", "3"]
选取范围索引开始位置。
选取范围索引结束位置。
- Redis官方文档：https://redis.io/commands/zremrangebyscore
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
从排序集中移除顺位在 min 和 max 中间，包括 min 和 max 的全部成员。
注意：2.1.6 版本之后 min 和 max 可以被排除在选取范围外。具体语法见 ZRANGEBYSCORE 命令。
返回被移除的元素个数。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zremrangebyscore('zset', '-inf', '(2')
// 1
await client.zrange('zset', { min: 0, max: -1 }, true)
// ["two", "2", "three", "3"]
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zrevrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
返回排序集中指定范围的成员。调用此命令时可以认为成员排序是按照分数从高到低的。
相同分数的成员按照逆字典序排列。
除了顺序是颠倒的以外，ZREVRANGE 和 ZRANGE 命令行为一样。
注意：6.2.0 版本开始，ZRANGE 可以用来实现此命令的行为，可能在之后的版本中被废弃。
数组形式返回指定范围的一系列成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrange('zset', 0, -1)
// ["three", "two", "one"]
await client.zrevrange('zset', 2, 3)
// ["one"]
await client.zrevrange('zset', -2, -1)
// ["two", "one"]
选取范围索引开始位置。
选取范围索引结束位置。
- Redis官方文档：https://redis.io/commands/zrevrange
- 起始版本：1.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
返回排序集中指定范围的成员。调用此命令时可以认为成员排序是按照分数从高到低的。
相同分数的成员按照逆字典序排列。
除了顺序是颠倒的以外，ZREVRANGE 和 ZRANGE 命令行为一样。
注意：6.2.0 版本开始，ZRANGE 可以用来实现此命令的行为，可能在之后的版本中被废弃。
数组形式返回指定范围的一系列成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrange('zset', 0, -1)
// ["three", "two", "one"]
await client.zrevrange('zset', 2, 3)
// ["one"]
await client.zrevrange('zset', -2, -1)
// ["two", "one"]
选取范围索引开始位置。
选取范围索引结束位置。
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zrevrangebylex
- 起始版本：2.8.9
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
有时为了获取一个字典序排序的排序集，会将所有成员以相同的分数存入排序集中，此时可以用 ZREVRANGEBYLEX 返回按照逆字典序排列在 min 和 max 中间的成员。
除了倒序排列，ZREVRANGEBYLEX 和 ZRANGEBYLEX 命令行为一致。
注意：6.2.0 版本开始，ZRANGE 可以通过参数 reverse 和 by:BYLEX 来实现 ZREVRANGEBYLEX。在之后的版本中，ZREVRANGEBYLEX可能会被废弃。
数组形式返回指定范围内的成员。
例子：
await client.zadd('zset', { a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, g: 0 })
// 7
await client.zrevrangebylex('zset', '[c', '-')
// ["c", "b", "a"]
await client.zrevrangebylex('zset', '(c', '-')
// ["b", "a"]
await client.zrevrangebylex('zset', '(g', '[aaa')
// ["f", "e", "d", "c", "b"]
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count。
- Redis官方文档：https://redis.io/commands/zrevrangebyscore
- 起始版本：2.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中介于 min 和 max 间的全部成员。跟 ｜ ZRANGEBYSCORE 命令不同的是，此命令行为默认从高到低排列。
具有相同分数的成员按照逆字典序排列。
注意：6.2.0 版本开始，ZRANGE 可以通过参数 reverse 和 by:BYSCORE 来实现 ZREVRANGEBYLEX。在之后的版本中，ZREVRANGEBYLEX可能会被废弃。
数组形式返回指定范围内的成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrangebyscore('zset', '+inf', '-inf')
// ["three", "two", "one"]
await client.zrevrangebyscore('zset', '2', '1')
// ["two", "one"]
await client.zrevrangebyscore('zset', '2', '(1')
// ["two"]
await client.zrevrangebyscore('zset', '(2', '(1')
// []
选取范围的最小值。
选取范围的最大值。
- Redis官方文档：https://redis.io/commands/zrevrangebyscore
- 起始版本：2.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中介于 min 和 max 间的全部成员。跟 ｜ ZRANGEBYSCORE 命令不同的是，此命令行为默认从高到低排列。
具有相同分数的成员按照逆字典序排列。
注意：6.2.0 版本开始，ZRANGE 可以通过参数 reverse 和 by:BYSCORE 来实现 ZREVRANGEBYLEX。在之后的版本中，ZREVRANGEBYLEX可能会被废弃。
数组形式返回指定范围内的成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrangebyscore('zset', '+inf', '-inf')
// ["three", "two", "one"]
await client.zrevrangebyscore('zset', '2', '1')
// ["two", "one"]
await client.zrevrangebyscore('zset', '2', '(1')
// ["two"]
await client.zrevrangebyscore('zset', '(2', '(1')
// []
选取范围的最小值。
选取范围的最大值。
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zrevrangebyscore
- 起始版本：2.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中介于 min 和 max 间的全部成员。跟 ｜ ZRANGEBYSCORE 命令不同的是，此命令行为默认从高到低排列。
具有相同分数的成员按照逆字典序排列。
注意：6.2.0 版本开始，ZRANGE 可以通过参数 reverse 和 by:BYSCORE 来实现 ZREVRANGEBYLEX。在之后的版本中，ZREVRANGEBYLEX可能会被废弃。
数组形式返回指定范围内的成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrangebyscore('zset', '+inf', '-inf')
// ["three", "two", "one"]
await client.zrevrangebyscore('zset', '2', '1')
// ["two", "one"]
await client.zrevrangebyscore('zset', '2', '(1')
// ["two"]
await client.zrevrangebyscore('zset', '(2', '(1')
// []
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count。
- Redis官方文档：https://redis.io/commands/zrevrangebyscore
- 起始版本：2.2.0
- 时间复杂度：O(log(N)+M) N 为排序集中的成员数量，M 为需要移除的成员数量。
如果 M 始终是个常量（比如使用 limit 限制始终返回前 10 个元素），此时可以认为复杂度为 O(log(N))。
返回排序集中介于 min 和 max 间的全部成员。跟 ｜ ZRANGEBYSCORE 命令不同的是，此命令行为默认从高到低排列。
具有相同分数的成员按照逆字典序排列。
注意：6.2.0 版本开始，ZRANGE 可以通过参数 reverse 和 by:BYSCORE 来实现 ZREVRANGEBYLEX。在之后的版本中，ZREVRANGEBYLEX可能会被废弃。
数组形式返回指定范围内的成员。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrangebyscore('zset', '+inf', '-inf')
// ["three", "two", "one"]
await client.zrevrangebyscore('zset', '2', '1')
// ["two", "one"]
await client.zrevrangebyscore('zset', '2', '(1')
// ["two"]
await client.zrevrangebyscore('zset', '(2', '(1')
// []
选取范围的最小值。
选取范围的最大值。
限制返回成员数量，格式为 offset, count。
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zrevrank
- 起始版本：2.0.0
- 时间复杂度：O(log(N))
返回 member 在排序集中的顺位，排序规则为按照 score 从高到低。顺位是从 0 开始计数的，也就是说 0 表示最高的位。
当需要获取成员分数从低到高的顺位时，使用 ZRANK 命令。
例子：
await client.zadd('zset', { one: 1, two: 2, three: 3 })
// 3
await client.zrevrank('zset', 'one')
// 2
await client.zrevrank('zset', 'four')
// null
- Redis官方文档：https://redis.io/commands/zscan
- 起始版本：2.8.0
- 时间复杂度：**每次调用的消耗为O(1)，完整迭代一次为 O(N)，包括足以使光标返回到 0 的命令调用。N 是集合内元素的数量。
详情参见 SCAN 命令。
- Redis官方文档：https://redis.io/commands/zscore
- 起始版本：1.2.0
- 时间复杂度：O(1)
返回排序集中指定成员的分数。
如果 key 不存在或者 member 不存在，返回 null。
返回字符串形式的双精度浮点数。
例子：
await client.zadd('zset', { one: 1 })
// 1
await client.zscore('zset', 'one')
// "1"
- Redis官方文档：https://redis.io/commands/zunion
- 起始版本：6.2.0
- 时间复杂度：O(N)+O(M*log(M)) N 是全部输入集的大小的和，M 是结果集的大小。
这个命令类似 ZUNIONSTORE 命令，区别是 ZUNION 不会存储结果，而是将结果返回到客户端。
具体参数选项的语义请参考 ZUNIONSTORE 命令。
数组形式返回输入集的并集。
提供 withscores 参数会返回 member/score 对。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zunion(['zset1', 'zset2'])
// ["one", "two", "three"]
await client.zunion(['zset1', 'zset2'], true)
// ["one", "2", "three", "3", "two", "4"]
- Redis官方文档：https://redis.io/commands/zunion
- 起始版本：6.2.0
- 时间复杂度：O(N)+O(M*log(M)) N 是全部输入集的大小的和，M 是结果集的大小。
这个命令类似 ZUNIONSTORE 命令，区别是 ZUNION 不会存储结果，而是将结果返回到客户端。
具体参数选项的语义请参考 ZUNIONSTORE 命令。
数组形式返回输入集的并集。
提供 withscores 参数会返回 member/score 对。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zunion(['zset1', 'zset2'])
// ["one", "two", "three"]
await client.zunion(['zset1', 'zset2'], true)
// ["one", "2", "three", "3", "two", "4"]
以 member/score 对形式返回结果。
- Redis官方文档：https://redis.io/commands/zunionstore
- 起始版本：2.0.0
- 时间复杂度：O(N)+O(M*log(M)) N 是全部输入集的大小的和，M 是结果集的大小。
计算给定的排序集的并集，并将结果存入 destination 中。
结果集中成员的分数，默认是该成员在所有输入排序集中的分数的和。
使用 weights 选项可以设置输入集的权重因子。意思是输入集中的元素传递给聚合函数前会先乘以对应的权重。
使用 aggregate 选项可以指定结果集中的 score 计算方式。默认是 'SUM' 也就是求和，可以更改为 'MIN' 或者 'MAX' 分别表示取最小值和最大值。
如果 destination 已经存在则会被重写。
例子：
await client.zadd('zset1', { one: 1, two: 2 })
// 2
await client.zadd('zset2', { one: 1, two: 2, three: 3 })
// 3
await client.zunionstore('out', ['zset1', 'zset2'], { weights: [2, 3] })
// 3
await client.zrange('out', { min: 0, max: -1 }, true)
// ["one", "5", "three", "9", "two", "10"]
- Redis官方文档：https://redis.io/commands/append
- 起始版本：2.0.0
- 时间复杂度：假设追加值很小，原始值为任意大小, 由于 Redis 使用的动态字符串会在每次重新分配时加倍字符串的存储空间，分摊时间复杂度为 O(1)。
返回追加后的字符串长度。
例子：
await client.exists('mykey')
// 0
await client.append('mykey', 'Hello')
// 5
await client.append('mykey', ' World')
// 11
await client.get('mykey')
// "Hello World"
需要追加的内容。
- Redis官方文档：https://redis.io/commands/bitcount
- 起始版本：2.6.0
- 时间复杂度：O(N)
统计字符串中 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
- Redis官方文档：https://redis.io/commands/bitcount
- 起始版本：2.6.0
- 时间复杂度：O(N)
统计字符串中 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
- Redis官方文档：https://redis.io/commands/bitcount
- 起始版本：2.6.0
- 时间复杂度：O(N)
统计字符串中 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
- Redis官方文档：https://redis.io/commands/bitfield
- 起始版本：3.2.0
- 时间复杂度：每个子命令的复杂度为 O(1)
该命令将 Redis 字符串视为位数组，并且能够处理指定偏移量和位宽（不超过64bit）的整数字段，以及配置特定的溢出策略。
支持四种子命令：
RedisClientParams.BitField.BitFieldGet | GET 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]
- Redis官方文档：https://redis.io/commands/bitop
- 起始版本：2.6.0
- 时间复杂度：O(N)
执行按位运算并将结果存储在 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。
- Redis官方文档：https://redis.io/commands/bitop
- 起始版本：2.6.0
- 时间复杂度：O(N)
执行按位运算并将结果存储在 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。
- Redis官方文档：https://redis.io/commands/bitop
- 起始版本：2.6.0
- 时间复杂度：O(N)
执行按位运算并将结果存储在 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。
- Redis官方文档：https://redis.io/commands/bitop
- 起始版本：2.6.0
- 时间复杂度：O(N)
执行按位运算并将结果存储在 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。
- Redis官方文档：https://redis.io/commands/bitpos
- 起始版本：2.8.7
- 时间复杂度：O(N)
将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。
如果给定范围没有找到目标 bit，则返回 -1。
注意：
例子：
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
目标 bit，1 或 0。
- Redis官方文档：https://redis.io/commands/bitpos
- 起始版本：2.8.7
- 时间复杂度：O(N)
将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。
如果给定范围没有找到目标 bit，则返回 -1。
注意：
例子：
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
目标 bit，1 或 0。
开始的字节位置。
- Redis官方文档：https://redis.io/commands/bitpos
- 起始版本：2.8.7
- 时间复杂度：O(N)
将字符串视为一个 bit 数组，寻找其中第一个被设置为目标 bit 的位置，返回下标。
如果给定范围没有找到目标 bit，则返回 -1。
注意：
例子：
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
目标 bit，1 或 0。
开始的字节位置。
结束的字节位置。
- Redis官方文档：https://redis.io/commands/decr
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 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
- Redis官方文档：https://redis.io/commands/decr
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 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
是否以字符串形式返回结果。
- Redis官方文档：https://redis.io/commands/decrby
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字减少 delta，并返回处理之后的结果。
详情参考 INCR。
例子：
await client.set('mykey', '10')
// "OK"
await client.decrby('mykey', 3)
// 7
偏移量
- Redis官方文档：https://redis.io/commands/decrby
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字减少 delta，并返回处理之后的结果。
详情参考 INCR。
例子：
await client.set('mykey', '10')
// "OK"
await client.decrby('mykey', 3)
// 7
是否以字符串形式返回结果。
- Redis官方文档：https://redis.io/commands/get
- 起始版本：1.0.0
- 时间复杂度：O(1)
获取 key 对应的值。
注意：由于 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>
- Redis官方文档：https://redis.io/commands/get
- 起始版本：1.0.0
- 时间复杂度：O(1)
获取 key 对应的值。
注意：由于 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>
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/getbit
- 起始版本：2.2.0
- 时间复杂度：O(1)
返回指定 key 的 offset 处的 bit 值。
例子：
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
- Redis官方文档：https://redis.io/commands/getrange
- 起始版本：2.4.0
- 时间复杂度：O(N)，N 是返回字符串的长度。
复杂度最终取决于返回的长度，但是鉴于从现有字符串创建子串性能很好，所以对于小字符串可以认为复杂度为 O(1)。
返回指定 key 的字符串的子串。key 的类型如果不是 string 则抛出异常。
注意：在 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>
开始的字节数。
结束的字节数。
- Redis官方文档：https://redis.io/commands/getrange
- 起始版本：2.4.0
- 时间复杂度：O(N)，N 是返回字符串的长度。
复杂度最终取决于返回的长度，但是鉴于从现有字符串创建子串性能很好，所以对于小字符串可以认为复杂度为 O(1)。
返回指定 key 的字符串的子串。key 的类型如果不是 string 则抛出异常。
注意：在 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>
开始的字节数。
结束的字节数。
是否以 Buffer 形式返回。
- Redis官方文档：https://redis.io/commands/getset
- 起始版本：1.0.0
- 时间复杂度：O(1)
原子性的设置 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"
- Redis官方文档：https://redis.io/commands/getset
- 起始版本：1.0.0
- 时间复杂度：O(1)
原子性的设置 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"
- Redis官方文档：https://redis.io/commands/incr
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字加 1，并返回处理之后的结果。
INCRBY DECR DECRBY 三个命令的行为和 INCR
很基本一致。都具有如下特点：
注意：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"
- Redis官方文档：https://redis.io/commands/incr
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字加 1，并返回处理之后的结果。
INCRBY DECR DECRBY 三个命令的行为和 INCR
很基本一致。都具有如下特点：
注意：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"
是否以字符串形式返回结果。
- Redis官方文档：https://redis.io/commands/incrby
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字减少 delta，并返回处理之后的结果。
详情参考 INCR。
例子：
await client.set('mykey', '10')
// "OK"
await client.incrby('mykey', 5)
// 15
await client.incrby('mykey', '50', true)
// "65"
- Redis官方文档：https://redis.io/commands/incrby
- 起始版本：1.0.0
- 时间复杂度：O(1)
将 key 处存储的数字减少 delta，并返回处理之后的结果。
详情参考 INCR。
例子：
await client.set('mykey', '10')
// "OK"
await client.incrby('mykey', 5)
// 15
await client.incrby('mykey', '50', true)
// "65"
是否以字符串形式返回结果。
- Redis官方文档：https://redis.io/commands/incrbyfloat
- 起始版本：2.6.0
- 时间复杂度：O(1)
将 key 处存储的浮点数增加 increment。
当命令执行成功，则将递增后的新值存储到 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"
- Redis官方文档：https://redis.io/commands/mget
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为 key 的数量
返回所有指定的 key 对应的值的列表。
例子：
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 ]
- Redis官方文档：https://redis.io/commands/mget
- 起始版本：1.0.0
- 时间复杂度：O(N) N 为 key 的数量
返回所有指定的 key 对应的值的列表。
例子：
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 ]
是否按 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/mset
- 起始版本：1.0.1
- 时间复杂度：O(N) N 为 key 的数量
按照给定的 key value 批量进行 set 操作。
MSET 始终返回 OK。
例子：
await client.mset({ key1: 'Hello', key2: 'World' })
// "OK"
await client.get('key1')
// "Hello"
await client.get('key2')
// "World"
键值对，值可以是 Buffer 或 string
- Redis官方文档：https://redis.io/commands/mset
- 起始版本：1.0.1
- 时间复杂度：O(N) N 为 key 的数量
按照给定参数设置 key value。只要有任何一个 key 是已经存在的，MSETNX 都不会执行。
返回值含义：
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]
键值对，值可以是 Buffer 或 string
- Redis官方文档：https://redis.io/commands/psetex
- 起始版本：2.6.0
- 时间复杂度：O(1)
PSETEX 的行为和 SETEX 一致。 唯一区别是到期时间是毫秒单位。
例子：
await client.psetex('mykey', 'Hello', 1000)
// "OK"
await client.pttl('mykey')
// 961，不是固定值，取决于 执行 PTTL 和 PSETEX 的时间间隔。
await client.get('mykey')
// "Hello"
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
是否需要返回原值。6.2.0 及以上版本可用。
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
是否需要返回原值。6.2.0 及以上版本可用。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
是否需要返回原值。6.2.0 及以上版本可用。
- Redis官方文档：https://redis.io/commands/set
- 起始版本：1.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string。
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"
是否需要返回原值。6.2.0 及以上版本可用。
是否以 Buffer 形式返回结果。
- Redis官方文档：https://redis.io/commands/setbit
- 起始版本：2.2.0
- 时间复杂度：O(1)
将 string 类型的 key 是做一个 bit 数组。将下标为 offset 的 bit 设为 1 或 0，并返回旧的 bit 的值。
client.setbit('mykey', 7, 1) 会将 mykey 设置为 00000001。注意：当设置了最大有效位（offset 2^32 - 1 512M），但是 key 不存在或者存在但是是个小字符串， 此时 Redis 需要分配完整大小的内存，这可能会阻塞服务一段可观的时间。
在 2010 款的 MacBook Pro上：
例子：
await client.setbit('mykey', 7, 1)
// 0
await client.setbit('mykey', 7, 0)
// 1
await client.get('mykey')
// "\u0000"
- Redis官方文档：https://redis.io/commands/setbit
- 起始版本：2.0.0
- 时间复杂度：O(1)
设置 key 的值为一个 string，同时设置过期时间。
例子：
await client.setex('mykey', 'Hello', 10)
// "OK"
await client.ttl('mykey')
// 10
await client.get('mykey')
// "Hello"
- Redis官方文档：https://redis.io/commands/setbit
- 起始版本：2.0.0
- 时间复杂度：O(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"
- Redis官方文档：https://redis.io/commands/setrange
- 起始版本：2.2.0
- 时间复杂度：不考虑复制新字符串花费的时间的话复杂度是 O(1)。
通常这个字符串很小，所以基本上可以认为复杂度就是 O(1)。否则的话，复杂度是 O(M) M 是参数字符串的长度。
部分重写 key 对应的值。从指定的 offset 开始，写入新的值。返回修改后的字符串长度。
\0，之后填充新的 value。注意：当 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"
偏移量，字节为单位。
需要写入的值。
- Redis官方文档：https://redis.io/commands/stralgo
- 起始版本：6.0.0
- 时间复杂度：对于 LCS 算法来说 O(strlen(s1) * strlen(s2))
STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
目前唯一实现的算法是 LCS 算法（最长公共子序列）。
注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。
输入模式：
返回模式：
默认的返回模式为返回匹配到的子序列。
输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。
第一个输入值。
第二个输入值。
- Redis官方文档：https://redis.io/commands/stralgo
- 起始版本：6.0.0
- 时间复杂度：对于 LCS 算法来说 O(strlen(s1) * strlen(s2))
STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
目前唯一实现的算法是 LCS 算法（最长公共子序列）。
注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。
输入模式：
返回模式：
输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。
第一个输入值。
第二个输入值。
返回结果模式 LEN 表示值返回匹配结果长度。
- Redis官方文档：https://redis.io/commands/stralgo
- 起始版本：6.0.0
- 时间复杂度：对于 LCS 算法来说 O(strlen(s1) * strlen(s2))
STRALGO 命令的目的是向 Redis 用户提供需要快速实现而大多数编程语言的标准库通常没有提供的一些算法。
目前唯一实现的算法是 LCS 算法（最长公共子序列）。
注意：LCS 算法与最长的公共字符串算法不同，此算法中的字符匹配不需要是连续的。
输入模式：
返回模式：
输入模式 keys 表示按照给定的 key 寻找值进行运算，strings 表示 直接给出进行运算的值。
第一个输入值。
第二个输入值。
返回结果模式 IDX 表示值返回匹配结果的详细信息。
最小匹配长度，这个参数只是在返回时用来过滤结果中 results 的内容，不会影响整个算法的匹配过程。
- Redis官方文档：https://redis.io/commands/setrange
- 起始版本：2.2.0
- 时间复杂度：O(1)
返回指定 key 的 string 长度，如果 key 存储的值不是 string 类型，则会抛出异常。
例子：
await client.set('mykey', 'Hello World')
// "OK"
await client.strlen('mykey')
// 11
await client.strlen('nonexisting')
// 0
Generated using TypeDoc
RedisClient 继承了其他一系列的 Client，相当于是一个合集。