ToB企服应用市场:ToB评测及商务社交产业平台

标题: Redis:常用命令总结 [打印本页]

作者: tsx81428 时间: 2024-10-30 11:55
标题: Redis:常用命令总结
目录
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 也全部失效。

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）。

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 中

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 中

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 作为正负极限也是合法的。

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）是一种在数据结构中逐步访问元素的方法，通常用于处理大型数据集或流式数据，以避免一次性加载所有数据而导致的内存消耗。
关键概念:

分批处理：数据被分成多个小批次进行处理，而不是一次性加载所有数据。这种方法可以淘汰内存使用并提高响应速度。
懒加载：仅在需要时加载数据，而不是预先加载所有数据。这种方式可以提高性能，尤其是在处理大数据集时。
迭代器模式：使用迭代器来逐步访问数据结构中的元素。迭代器可以提供一种同一的方式来遍历差异类型的数据结构。

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 会清楚所有数
据库。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)