目录

1 . 前置内容

1.1 基本全局命令

KEYS

 EXISTS 

DEL

 EXPIRE

 TTL

TYPE

1.2 数据结构和内部编码

2. String类型

SET

GET

MGET

MSET

INCR

INCRBY 

DECR

DECRBY

INCRBYFLOAT

命令小结​编辑

内部编码

3 . Hash 哈希类型 

HSET

HGET

HEXISTS

HDEL

HKEYS

HVALS

HGETALL

HMGET

HLEN

HINCRBY

HINCRBYFLOAT

命令小结 ​编辑

内部编码

4 . List列表

LPUSH

LPUSHX

LRANGE

LPOP

LINDEX

LLEN

命令小结​编辑

内部编码

5 . Set 集合

SADD

SMEMBERS

SISMEMBER

SCARD

SPOP

SMOVE

SREM

SINTER

SINTERSTORE

SUNION

SUNIONSTORE

SDIFF

SDIFFSTORE

命令小结 ​编辑

内部编码

6 . Zset 有序集合

ZADD

ZCARD

ZCOUNT

ZRANGE

ZREVRANGE

ZPOPMAX

ZPOPMIN

ZRANK

ZREVRANK

ZSCORE

ZREM

ZINCRBY

ZINTERSTORE

ZUNIONSTORE

命令小结​编辑

内部编码

7. 渐进式遍历

8. 数据库命令 

---

1 . 前置内容

1.1 基本全局命令

KEYS

语法

KEYS pattern

用于匹配所有符合模版条件的key

---

 EXISTS 

EXISTS key [key ...] 

判断某个 key 是否存在。

上面我们添加了三个key 分别是 k1 k2 k3 我们用存在的key和不存在的key来进行测试,看看结果如何 

---

DEL

DEL  key [key ...] 

删除指定的key

返回值: 删除掉key的个数

---

 EXPIRE

EXPIRE key seconds

为指定的 key 添加秒级的过期时间（Time To Live TTL）

---

 TTL

TTL key

获取指定 key 的过期时间，秒级。

返回值：剩余过期时间。-1 表示没有关联过期时间，-2 表示 key 不存在。

TYPE

TYPE key

返回 key 对应的数据类型。

---

1.2 数据结构和内部编码

type 命令实际返回的就是当前键的数据结构类型，它们分别是：string（字符串）、list（列 表）、hash（哈希）、set（集合）、zset（有序集合），但这些只是 Redis 对外的数据结构,实际上 Redis 针对每种数据结构都有自己的底层内部编码实现，而且是多种实现，这样 Redis 会 在合适的场景选择合适的内部编码。

字符串（String）：Redis 使用简单动态字符串（SDS）来存储字符串数据。SDS 是一种结构化的字符串表示，可以动态调整大小，并且可以在 O(1) 时间内获取字符串长度。

列表（List）：Redis 使用压缩列表（ziplist）或双向循环链表（linkedlist）来存储列表数据。压缩列表是一种紧凑的数据结构，可以在一定程度上节省内存空间。双向循环链表则提供了更好的性能，但会消耗更多的内存。

哈希表（Hash）：Redis 使用压缩列表或哈希表（hashtable）来存储哈希数据。压缩列表适用于小规模的哈希数据，而哈希表则适用于大规模的哈希数据。

集合（Set）：Redis 使用整数集合（intset）或哈希表来存储集合数据。整数集合适用于存储整数类型的数据，而哈希表适用于存储任意类型的数据。

有序集合（Sorted Set）：Redis 使用跳跃表（skiplist）和哈希表来存储有序集合数据。跳跃表提供了快速的查找和插入操作，而哈希表则提供了快速的范围查询操作。

---

2. String类型

SET

将 string 类型的 value 设置到 key 中。如果 key 之前存在，则覆盖，无论原来的数据类型是什么。之前关于此 key 的 TTL 也全部失效。

<code>SET key value [expiration EX seconds|PX milliseconds] [NX|XX]

EX seconds⸺使用秒作为单位设置 key 的过期时间。PX milliseconds⸺使用毫秒作为单位设置 key 的过期时间。NX ⸺只在 key 不存在时才进行设置，即如果 key 之前已经存在，设置不执行。XX ⸺只在 key 存在时才进行设置，即如果 key 之前不存在，设置不执行。 

GET

获取 key 对应的 value。如果 key 不存在，返回 nil。如果 value 的数据类型不是 string，会报错。

GET key

MGET

⼀次性获取多个 key 的值。如果对应的 key 不存在或者对应的数据类型不是 string，返回 nil。

MGET key [key ...]

MSET

⼀次性设置多个 key 的值。

MSET key value [key value ...]

INCR

将 key 对应的 string 表示的数字加1。如果 key 不存在，则视为 key 对应的 value 是 0。如果 key 对应的 string 不是⼀个整型或者范围超过了 64 位有符号整型，则报错。

INCR key

返回值：加1之后， key 的值。  

INCRBY 

将 key 中储存的数字加上指定的增量值。,如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。

INCRBY key incr_amount

返回值：加上指定的增量值之后， key 的值。 

DECR

将 key 对应的 string 表示的数字减⼀。如果 key 不存在，则视为 key 对应的 value 是 0。

DECR key

DECRBY

将 key 对应的 string 表示的数字减去对应的值。如果 key 不存在，则视为 key 对应的 value 是 0。

DECRBY key decr_amount

INCRBYFLOAT

将 key 对应的 string 表示的浮点数加上对应的值。如果对应的值是负数，则视为减去对应的值。如果 key 不存在，则视为 key 对应的 value 是 0。如果 key 对应的不是 string，或者不是⼀个浮点数，则报 错。允许采用科学计数法表示浮点数。

INCRBYFLOAT KEY_NAME INCR_AMOUNT

---

命令小结

内部编码

字符串类型的内部编码有 3 种：

int: 8 个字节的长整型。embstr: 小于等于39个字节的字符串raw: 大于等于39个字节的字符串

---

3 . Hash 哈希类型 

 

哈希类型中的映射关系通常称为 field-value，用于区分 Redis 整体的键值对（key-value),注意这里的 value 是指 field 对应的值，不是键（key）对应的值，请注意 value 在不同上下文的作用。

HSET

 设置 hash 中指定的字段（field）的值（value）。

<code>redis> HSET myhash field1 "Hello"

(integer) 1

redis> HGET myhash field1

"Hello

HGET

获取 hash 中指定字段的值。

redis> HSET myhash field1 "foo"

(integer) 1

redis> HGET myhash field1

"foo"

redis> HGET myhash field2

(nil)

HEXISTS

判断 hash 中是否有指定的字段。

redis> HSET myhash field1 "foo"

(integer) 1

redis> HEXISTS myhash field1

(integer) 1

redis> HEXISTS myhash field2

(integer) 0

HDEL

删除 hash 中指定的字段。

redis> HSET myhash field1 "foo"

(integer) 1

redis> HDEL myhash field1

(integer) 1

redis> HDEL myhash field2

(integer) 0

HKEYS

获取 hash 中的所有字段。

redis> HSET myhash field1 "Hello"

(integer) 1

redis> HSET myhash field2 "World"

(integer) 1

redis> HKEYS myhash

1) "field1"

2) "field2"

HVALS

获取 hash 中的所有的值。

redis> HSET myhash field1 "Hello"

(integer) 1

redis> HSET myhash field2 "World"

(integer) 1

redis> HVALS myhash

1) "Hello"

2) "World"

HGETALL

获取 hash 中的所有字段以及对应的值。

redis> HSET myhash field1 "Hello"

(integer) 1

redis> HSET myhash field2 "World"

(integer) 1

redis> HGETALL myhash

1) "field1"

2) "Hello"

3) "field2"

4) "World"

HMGET

⼀次获取 hash 中多个字段的值

redis> HSET myhash field1 "Hello"

(integer) 1

redis> HSET myhash field2 "World"

(integer) 1

redis> HMGET myhash field1 field2 nofield

1) "Hello"

2) "World"

3) (nil)

HLEN

获取 hash 中的所有字段的个数。

redis> HSET myhash field1 "Hello"

(integer) 1

redis> HSET myhash field2 "World"

(integer) 1

redis> HLEN myhash

(integer) 2

HINCRBY

 将 hash 中字段对应的数值添加指定的值。返回添加后hash的值

redis> HSET myhash field 5

(integer) 1

redis> HINCRBY myhash field 1

(integer) 6

redis> HINCRBY myhash field -1

(integer) 5

redis> HINCRBY myhash field -10

(integer) -5

HINCRBYFLOAT

HINCRBY 的浮点数版本。

redis> HSET mykey field 10.50

(integer) 1

redis> HINCRBYFLOAT mykey field 0.1

"10.6"

redis> HINCRBYFLOAT mykey field -5

"5.6"

redis> HSET mykey field 5.0e3

(integer) 0

redis> HINCRBYFLOAT mykey field 2.0e2

"5200"

命令小结 

内部编码

ziplist（压缩列表）：当哈希类型元素个数小于 hash-max-ziplist-entries 配置（默认 512 个）、 同时所有值都小于 hash-max-ziplist-value 配置（默认 64 字节）时，Redis 会使用 ziplist 作为哈 希的内部实现，ziplist 使用更加紧凑的结构实现多个元素的连续存储，所以在节省内存方面比 hashtable 更加优秀。

hashtable（哈希表）：当哈希类型无法满足 ziplist 的条件时，Redis 会使用hashtable 作为哈希 的内部实现，因为此时 ziplist 的读写效率会下降，而hashtable 的读写时间复杂度为 O(1)。

---

4 . List列表

列表（List）是一种简单的、可变长度的字符串序列，支持在两端进行插入和删除操作。

LPUSH

将一个或者多个元素从左侧放入（头插）到 list 中

<code>redis> LPUSH mylist "world"

(integer) 1

redis> LPUSH mylist "hello"

(integer) 2

redis> LRANGE mylist 0 -1

1) "hello"

2) "world"

LPUSHX

在 key 存在时，将一个或者多个元素从左侧放入（头插）到 list 中。不存在，直接返回

redis> LPUSH mylist "World"

(integer) 1

redis> LPUSHX mylist "Hello"

(integer) 2

redis> LPUSHX myotherlist "Hello"

(integer) 0

redis> LRANGE mylist 0 -1

1) "Hello"

2) "World"

redis> LRANGE myotherlist 0 -1

(empty array)

LRANGE

获取从 start 到 end 区间的所有元素，左闭右闭

redis> RPUSH mylist "one"

(integer) 1

redis> RPUSH mylist "two"

(integer) 2

redis> RPUSH mylist "three"

(integer) 3

redis> LRANGE mylist 0 0

1) "one"

redis> LRANGE mylist -3 2

1) "one"

2) "two"

3) "three"

redis> LRANGE mylist -100 100

1) "one"

2) "two"

3) "three"

redis> LRANGE mylist 5 10

(empty array)

LPOP

从 list 左侧取出元素（即头删）。

redis> RPUSH mylist "one" "two" "three" "four" "five"

(integer) 5

redis> LPOP mylist

"one"

redis> LPOP mylist

"two"

redis> LPOP mylist

"three"

redis> LRANGE mylist 0 -1

1) "four"

2) "five"

LINDEX

获取从左数第 index 位置的元素

redis> LPUSH mylist "World"

(integer) 1

redis> LPUSH mylist "Hello"

(integer) 2

redis> LINDEX mylist 0

"Hello"

redis> LINDEX mylist -1

"World"

redis> LINDEX mylist 3

(nil)

LLEN

获取 list ⻓度。

redis> LPUSH mylist "World"

(integer) 1

redis> LPUSH mylist "Hello"

(integer) 2

redis> LLEN mylist

(integer) 2

命令小结

内部编码

Ziplist:

当列表的元素数量较少且每个元素的长度较短时，Redis会使用Ziplist编码。Ziplist是一种紧凑的内存表示方式，可以有效地存储小型列表。优点：节省内存，适合小型列表。缺点：在进行插入和删除操作时，性能较低。

Linked List:

当列表的元素数量增加到一定阈值时，Redis会将其转换为双向链表。链表允许在两端快速插入和删除操作。优点：支持快速的插入和删除操作。缺点：相对于Ziplist，内存占用更高。

Quicklist:

Redis 3.2引入了Quicklist作为列表的默认实现。Quicklist结合了Ziplist和链表的优点，使用多个Ziplist块来存储元素，并通过链表连接这些块。优点：在内存使用和性能之间取得了良好的平衡，适合大多数使用场景。

---

5 . Set 集合

集合类型也是保存多个字符串类型的元素的，但和列表类型不同的是，集合中

1)  元素之间是无序的

2）元素不允许重复

一个集合中最多可以存储 

个元素。Redis 除了支持集合内的增删查改操作，同时还支持多个集合取交集、并集、差集，合理地使用好集合类型，能在实际开发中解决很多问题。

SADD

将⼀个或者多个元素添加到 set 中。注意，重复的元素无法添加到 set 中

<code>redis> SADD myset "Hello"

(integer) 1

redis> SADD myset "World"

(integer) 1

redis> SADD myset "World"

(integer) 0

redis> SMEMBERS myset

1) "Hello"

2) "World"

SMEMBERS

获取⼀个 set 中的所有元素，注意，元素间的顺序是无序的。

redis> SADD myset "Hello"

(integer) 1

redis> SADD myset "World"

(integer) 1

redis> SMEMBERS myset

1) "Hello"

2) "World"

SISMEMBER

判断⼀个元素在不在 set 中。

redis> SADD myset "one"

(integer) 1

redis> SISMEMBER myset "one"

(integer) 1

redis> SISMEMBER myset "two"

(integer) 0

SCARD

获取⼀个 set 的基数（cardinality），即 set 中的元素个数。

redis> SADD myset "Hello"

(integer) 1

redis> SADD myset "World"

(integer) 1

redis> SCARD myset

(integer) 2

SPOP

Spop 命令用于移除集合中的指定 key 的一个或多个随机元素，移除后会返回移除的元素.

SMOVE

将一个元素从源 set 取出并放入目标 set 中。

redis> SADD myset "one"

(integer) 1

redis> SADD myset "two"

(integer) 1

redis> SADD myotherset "three"

(integer) 1

redis> SMOVE myset myotherset "two"

(integer) 1

redis> SMEMBERS myset

1) "one"

redis> SMEMBERS myotherset

1) "three"

2) "two"

SREM

将指定的元素从 set 中删除。

redis> SADD myset "one"

(integer) 1

redis> SADD myset "two"

(integer) 1

redis> SADD myset "three"

(integer) 1

redis> SREM myset "one"

(integer) 1

redis> SREM myset "four"

(integer) 0

redis> SMEMBERS myset

1) "three"

2) "two"

SINTER

获取给定 set 的交集中的元素。

redis> SADD key1 "a"

(integer) 1

redis> SADD key1 "b"

(integer) 1

redis> SADD key1 "c"

(integer) 1

redis> SADD key2 "c"

(integer) 1

redis> SADD key2 "d"

(integer) 1

redis> SADD key2 "e"

(integer) 1

redis> SINTER key1 key2

1) "c"

SINTERSTORE

获取给定 set 的交集中的元素并保存到目标 set 中。

SINTERSTORE destination key [key ...]

redis> SADD key1 "a"

(integer) 1

redis> SADD key1 "b"

(integer) 1

redis> SADD key1 "c"

(integer) 1

redis> SADD key2 "c"

(integer) 1

redis> SADD key2 "d"

(integer) 1

redis> SADD key2 "e"

(integer) 1

redis> SINTERSTORE key key1 key2

(integer) 1

redis> SMEMBERS key

1) "c"

SUNION

获取给定 set 的并集中的元素

redis> SADD key1 "a"

(integer) 1

redis> SADD key1 "b"

(integer) 1

redis> SADD key1 "c"

(integer) 1

redis> SADD key2 "c"

(integer) 1

redis> SADD key2 "d"

(integer) 1

redis> SADD key2 "e"

(integer) 1

redis> SUNION key1 key2

1) "a"

2) "c"

3) "e"

4) "b"

5) "d"

SUNIONSTORE

获取给定 set 的并集中的元素并保存到目标 set 中。

SUNIONSTORE destination key [key ...]

redis> SADD key1 "a"

(integer) 1

redis> SADD key1 "b"

(integer) 1

redis> SADD key1 "c"

(integer) 1

redis> SADD key2 "c"

(integer) 1

redis> SADD key2 "d"

(integer) 1

redis> SADD key2 "e"

(integer) 1

redis> SUNIONSTORE key key1 key2

(integer) 5

redis> SMEMBERS key

1) "a"

2) "c"

3) "e"

4) "b"

5) "d"

SDIFF

获取给定 set 的差集中的元素

SDIFF key [key ...]

SDIFFSTORE

获取给定 set 的差集中的元素并保存到目标 set 中

SDIFFSTORE destination key [key ...]

命令小结 

内部编码

集合类型的内部编码有两种:

intset（整数集合）：当集合中的元素都是整数并且元素的个数小于 set-max-intset-entries 配置 （默认 512 个）时，Redis 会选用intset 来作为集合的内部实现，从而减少内存的使用。• hashtable（哈希表）：当集合类型无法满足 intset 的条件时，Redis 会使用 hashtable 作为集合 的内部实现。

---

6 . Zset 有序集合

有序集合相对于字符串、列表、哈希、集合来说会有⼀些陌生。它保留了集合不能有重复成员的 特点，但与集合不同的是，有序集合中的每个元素都有⼀个唯⼀的浮点类型的分数（score）与之关联，着使得有序集合中的元素是可以维护有序性的，但这个有序不是用下标作为排序依据而是用这个分数。

ZADD

添加或者更新指定的元素以及关联的分数到 zset 中，分数应该符合 double 类型，+inf/-inf 作为正负极限也是合法的。

<code>ZADD key score1 value1[score2 value2...]

ZCARD

获取⼀个 zset 的基数（cardinality），即 zset 中的元素个数。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZCARD myzset

(integer) 2

ZCOUNT

返回分数在 min 和 max 之间的元素个数，默认情况下，min 和 max 都是闭区间的

ZCOUNT key min max

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZCOUNT myzset -inf +inf

(integer) 3

redis> ZCOUNT myzset 1 3

(integer) 3

redis> ZCOUNT myzset (1 3

(integer) 2

redis> ZCOUNT myzset (1 (3

(integer) 1

ZRANGE

返回指定区间⾥的元素，分数按照升序。带上 WITHSCORES 可以把分数也返回。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZRANGE myzset 0 -1 WITHSCORES

1) "one"

2) "1"

3) "two"

4) "2"

5) "three"

6) "3"

redis> ZRANGE myzset 0 -1

1) "one"

2) "two"

3) "three"

redis> ZRANGE myzset 2 3

1) "three"

redis> ZRANGE myzset -2 -1

1) "two"

2) "three"

ZREVRANGE

返回指定区间里的元素，分数按照降序。带上 WITHSCORES 可以把分数也返回。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZREVRANGE myzset 0 -1 WITHSCORES

1) "three"

2) "3"

3) "two"

4) "2"

5) "one"

6) "1"

redis> ZREVRANGE myzset 0 -1

1) "three"

2) "two"

3) "one"

redis> ZREVRANGE myzset 2 3

1) "one"

redis> ZREVRANGE myzset -2 -1

1) "two"

2) "one"

ZPOPMAX

删除并返回分数最高的 count 个元素

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZPOPMAX myzset

1) "three"

2) "3"

ZPOPMIN

删除并返回分数最低的 count 个元素

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZPOPMIN myzset

1) "one"

2) "1"

ZRANK

返回指定元素的排名，升序。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZRANK myzset "three"

(integer) 2

redis> ZRANK myzset "four"

(nil)

ZREVRANK

返回指定元素的排名，降序。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZREVRANK myzset "one"

(integer) 2

redis> ZREVRANK myzset "four"

(nil)

ZSCORE

返回指定元素的分数。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZSCORE myzset "one"

"1"

ZREM

删除指定的元素。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZADD myzset 3 "three"

(integer) 1

redis> ZREM myzset "two"

(integer) 1

redis> ZRANGE myzset 0 -1 WITHSCORES

1) "one"

2) "1"

3) "three"

4) "3"

ZINCRBY

为指定的元素的关联分数添加指定的分数值，返回值为新分数值，以字符串形式表示。

redis> ZADD myzset 1 "one"

(integer) 1

redis> ZADD myzset 2 "two"

(integer) 1

redis> ZINCRBY myzset 2 "one"

"3"

redis> ZRANGE myzset 0 -1 WITHSCORES

1) "two"

2) "2"

3) "one"

4) "3"

ZINTERSTORE

求出给定有序集合中元素的交集并保存进目标有序集合中，在合并过程中以元素为单位进行合并，元 素对应的分数按照不同的聚合方式和权重得到新的分数。

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight

[weight ...]] [AGGREGATE <SUM | MIN | MAX>]

redis> ZADD zset1 1 "one"

(integer) 1

redis> ZADD zset1 2 "two"

(integer) 1

redis> ZADD zset2 1 "one"

(integer) 1

redis> ZADD zset2 2 "two"

(integer) 1

redis> ZADD zset2 3 "three"

(integer) 1

redis> ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3

(integer) 2

redis> ZRANGE out 0 -1 WITHSCORES

1) "one"

2) "5"

3) "two"

4) "10"

ZUNIONSTORE

求出给定有序集合中元素的并集并保存进目标有序集合中，在合并过程中以元素为单位进行合并，元 素对应的分数按照不同的聚合方式和权重得到新的分数。

命令小结

内部编码

ziplist（压缩列表）：当有序集合的元素个数小于 zset-max-ziplist-entries 配置（默认 128 个），同时每个元素的值都小于 zset-max-ziplist-value 配置（默认 64 字节）时，Redis 会用 ziplist 来作 为有序集合的内部实现，ziplist 可以有效减少内存的使用。

skiplist（跳表）：当 ziplist 条件不满足时，有序集合会使⽤ skiplist 作为内部实现，因为此时 ziplist 的操作效率会下降

7. 渐进式遍历

渐进式遍历（Incremental Traversal）是一种在数据结构中逐步访问元素的方法，通常用于处理大型数据集或流式数据，以避免一次性加载所有数据而导致的内存消耗。

关键概念:

分批处理：数据被分成多个小批次进行处理，而不是一次性加载所有数据。这种方法可以减少内存使用并提高响应速度。

懒加载：仅在需要时加载数据，而不是预先加载所有数据。这种方式可以提高性能，尤其是在处理大数据集时。

迭代器模式：使用迭代器来逐步访问数据结构中的元素。迭代器可以提供一种统一的方式来遍历不同类型的数据结构。

<code>redis 127.0.0.1:6379> scan 0

1) "17"

2) 1) "key:12"

2) "key:8"

3) "key:4"

4) "key:14"

5) "key:16"

6) "key:17"

7) "key:15"

8) "key:10"

9) "key:3"

10) "key:7"

11) "key:1"

redis 127.0.0.1:6379> scan 17

1) "0"

2) 1) "key:5"

2) "key:18"

3) "key:0"

4) "key:2"

5) "key:19"

6) "key:13"

7) "key:6"

8) "key:9"

9) "key:11"

8. 数据库命令 

//切换数据库

select dbIndex

//清除数据库

flushdb / flushall # flushdb 只清除当前数据库，flushall 会清楚所有数

据库。