Redis—List数据类型及其常用命令详解

一、Redis概述

Redis概述

List类型

Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

特征也与LinkedList类似：

• 有序
• 元素可以重复
• 插入和删除快
• 查询速度一般

常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。

1 LPUSH:将一个或多个值插入到列表头部

LPUSH 是 Redis 中用于将一个或多个值插入到列表头部的命令。

该命令会将指定的值按顺序推入列表的左侧，即列表的头部。

如果列表不存在，会创建一个新的列表。

LPUSH key value [value ...]

• key: 列表的键名。
• value: 要插入到列表头部的一个或多个值。

假设有一个空列表 mylist。

1. 将单个值插入列表：

LPUSH mylist "world"

执行后，mylist 的内容是：

["world"]

2. 将多个值插入列表（按从左到右的顺序依次插入）：

LPUSH mylist "hello"

执行后，mylist 的内容是：

["hello", "world"]

3. 再次插入多个值：

LPUSH mylist "a" "b" "c"

执行后，mylist 的内容变为：

["c", "b", "a", "hello", "world"]

返回值

redis> LPUSH mylist "world"
(integer) 1
redis> LPUSH mylist "hello"
(integer) 2

LPUSH 命令返回插入后列表的长度。

使用场景

• 消息队列：可以使用 LPUSH 和 RPOP 组合实现一个简单的消息队列，生产者使用 LPUSH 将消息推入队列，消费者使用 RPOP 从队列尾部取出消息。
• 栈操作：与 LPOP 配合，可以实现栈的功能（后进先出）。
• 维持最近访问记录：可以通过 LPUSH 将最新访问的记录插入到列表头部，再结合 LTRIM 限制列表长度，维持一个固定大小的最近访问记录列表。

注意事项

• 列表的最大长度受限于 Redis 配置和可用内存。在大多数应用中，请确保不会无限制地增加列表大小，以避免潜在的性能问题。
• Redis 列表在内部使用双向链表实现，因此在列表头部和尾部进行插入和删除操作的时间复杂度都是 O(1)。

2 RPUSH:将一个或多个值插入到列表尾部

RPUSH 是 Redis 中用于将一个或多个值插入到列表尾部（右侧）的命令。

该命令会将指定的值按顺序推入列表的右侧，如果列表不存在，会创建一个新的列表。

RPUSH key value [value ...]

• key: 列表的键名。
• value: 要插入到列表尾部的一个或多个值。

空列表 mylist。

1. 将单个值插入列表：

RPUSH mylist "hello"

执行后，mylist 的内容是：

["hello"]

2. 将多个值插入列表（按从左到右的顺序依次插入）：

RPUSH mylist "world" "!"

执行后，mylist 的内容是：

["hello", "world", "!"]

3. 再次插入多个值：

RPUSH mylist "a" "b" "c"

执行后，mylist 的内容变为：

["hello", "world", "!", "a", "b", "c"]

返回值

redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "world"
(integer) 2

RPUSH 命令返回插入后列表的长度。

使用场景

• 消息队列：可以使用 RPUSH 和 LPOP 组合实现一个简单的消息队列，生产者使用 RPUSH 将消息推入队列，消费者使用 LPOP 从队列头部取出消息。
• 队列操作：与 LPOP 配合，可以实现先进先出的队列功能。
• 日志记录：可以使用 RPUSH 将日志条目追加到列表末尾，方便按时间顺序记录和查看日志。

注意事项

• 列表的最大长度受限于 Redis 配置和可用内存。在大多数应用中，请确保不会无限制地增加列表大小，以避免潜在的性能问题。
• Redis 列表在内部使用双向链表实现，因此在列表头部和尾部进行插入和删除操作的时间复杂度都是 O(1)。

3 LPOP:从列表头部弹出并移除一个或多个元素

LPOP 是 Redis 中用于从列表头部（左侧）弹出并移除一个或多个元素的命令。

该命令返回被弹出的元素，如果列表为空则返回 nil。

在 Redis 6.2 及其之后的版本中，LPOP 命令得到了扩展，增加了一个可选的 count 参数。

这个扩展使得 LPOP 可以一次从列表头部弹出多个元素，而不仅仅是一个。

LPOP key [count]

• key: 列表的键名。
• count: （可选）要弹出的元素数量，如果不指定，则默认为 1。

列表 mylist，其内容：

["a", "b", "c", "d", "e"]

1. 从列表头部弹出一个元素：

LPOP mylist

执行后，返回值是 "a"，列表的内容变为：

["b", "c", "d", "e"]

2. 一次弹出多个元素（如弹出 3 个元素）：

LPOP mylist 3

执行后，返回值是 ["b", "c", "d"]，列表的内容变为：

["e"]

3. 如果弹出的数量超过列表的长度，例如列表只剩下一个元素：

LPOP mylist 2

执行后，返回值是 ["e"]，列表变为空：

[]

4. 如果列表已经为空，再次尝试弹出：

LPOP mylist

执行后，返回值是 nil，因为列表为空。

返回值

redis> RPUSH mylist "one" "two" "three" "four" "five"
(integer) 5
redis> LPOP mylist
"one"
redis> LPOP mylist 2
1) "two"
2) "three"
redis> LRANGE mylist 0 -1
1) "four"
2) "five"
redis> 

• 当 count 未指定时，LPOP 返回被弹出的单个元素（字符串）。
• 当 count 指定时，LPOP 返回一个包含被弹出元素的列表。
• 如果列表不存在或为空，LPOP 返回 nil。

使用场景

• 批量处理：可以使用带 count 的 LPOP 实现批量数据处理，从列表中一次性获取多个元素，提高处理效率。
• 队列操作：结合 RPUSH 和 LPUSH，可以实现复杂的队列和栈操作。
• 流式数据处理：可以用来逐批获取数据进行流式处理，适用于需要高吞吐量的应用。

注意事项

• 在使用带 count 的 LPOP 时，请注意列表的长度，以避免请求弹出超过列表长度的元素。如果 count 超过列表长度，LPOP 只返回当前列表中所有的元素。
• 如果频繁进行批量弹出操作，可能会对性能产生影响，需要根据具体使用场景进行性能测试和优化。

4 RPOP：从列表尾部弹出一个或多个元素

在 Redis 6.2 及其之后的版本中，RPOP 命令得到了扩展，增加了一个可选的 count 参数。

这个扩展使得 RPOP 可以一次从列表尾部弹出多个元素，而不仅仅是一个。

RPOP key [count]

• key: 列表的键名。
• count: （可选）要弹出的元素数量，如果不指定，则默认为 1。

列表 mylist，其内容是：

["a", "b", "c", "d", "e"]

1. 从列表尾部弹出一个元素：

RPOP mylist

执行后，返回值是 "e"，列表的内容变为：

["a", "b", "c", "d"]

2. 一次弹出多个元素（如弹出 3 个元素）：

RPOP mylist 3

执行后，返回值是 ["d", "c", "b"]，列表的内容变为：

["a"]

3. 如果弹出的数量超过列表的长度，例如列表只剩下一个元素：

RPOP mylist 2

执行后，返回值是 ["a"]，列表变为空：

[]

4. 如果列表已经为空，再次尝试弹出：

RPOP mylist

执行后，返回值是 nil，因为列表为空。

返回值

• 当 count 未指定时，RPOP 返回被弹出的单个元素（字符串）。
• 当 count 指定时，RPOP 返回一个包含被弹出元素的列表。
• 如果列表不存在或为空，RPOP 返回 nil。

使用场景

• 批量处理：可以使用带 count 的 RPOP 实现批量数据处理，从列表中一次性获取多个元素，提高处理效率。
• 队列操作：结合 RPUSH 和 LPUSH，可以实现复杂的队列和栈操作。
• 流式数据处理：可以用来逐批获取数据进行流式处理，适用于需要高吞吐量的应用。

注意事项

• 在使用带 count 的 RPOP 时，请注意列表的长度，以避免请求弹出超过列表长度的元素。如果 count 超过列表长度，RPOP 只返回当前列表中所有的元素。
• 如果频繁进行批量弹出操作，可能会对性能产生影响，需要根据具体使用场景进行性能测试和优化。

5 LLEN:获取 Redis 列表的长度

LLEN 命令用于获取 Redis 列表的长度。

它返回指定键所对应的列表中元素的数量。如果键不存在，则返回 0。

LLEN key

• key: 列表的键名。

示例

["a", "b", "c", "d", "e"]

1. 获取列表的长度：

LLEN mylist

执行后，返回值是 5，因为列表中有 5 个元素。

2. 如果列表为空：

清空 mylist：

DEL mylist
LLEN mylist

执行后，返回值是 0，因为列表不存在。

3. 如果键不存在：

LLEN nonexistentlist

执行后，返回值也是 0，因为该键不存在。

返回值

redis> LPUSH mylist "World"
(integer) 1
redis> LPUSH mylist "Hello"
(integer) 2
redis> LLEN mylist
(integer) 2

LLEN 返回指定列表的长度（整数）。

6 LRANGE:获取 Redis 列表中指定范围内的元素

LRANGE 命令用于获取 Redis 列表中指定范围内的元素。

该命令可以从列表的任意位置开始，返回一段子序列。

LRANGE key start stop

• key: 列表的键名。
• start: 起始索引，可以是正数或负数。如果为负数，则表示从列表末尾开始计数，例如 -1 表示最后一个元素，-2 表示倒数第二个元素。
• stop: 结束索引，可以是正数或负数。如果为负数，则表示从列表末尾开始计数，例如 -1 表示最后一个元素，-2 表示倒数第二个元素。

返回值

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)
redis> 

返回一个包含指定范围内的元素的列表。如果 start 大于 stop，则返回空列表；如果键不存在，则返回空列表。

示例

["a", "b", "c", "d", "e"]

1. 获取列表中从索引 1 到 3 的元素：

LRANGE mylist 1 3

执行后，返回值是：["b", "c", "d"]

2. 获取列表中从第一个元素到第三个元素：

LRANGE mylist 0 2

执行后，返回值是：["a", "b", "c"]

3. 获取列表的最后两个元素：

LRANGE mylist -2 -1

执行后，返回值是：["d", "e"]

4. 获取整个列表：

LRANGE mylist 0 -1

执行后，返回值是：["a", "b", "c", "d", "e"]

5. 如果 start 大于 stop，返回空列表：

LRANGE mylist 3 1

执行后，返回值是：[]

6. 如果列表为空或键不存在，返回空列表：

LRANGE emptylist 0 -1
LRANGE nonexistentlist 0 -1

执行后，返回值都是：[]

使用场景

• 分页：可以使用 LRANGE 实现简单的分页功能，从列表中取出特定范围内的元素进行展示。
• 流式数据处理：适用于需要从列表中按块读取和处理数据的场景。
• 子序列获取：在数据分析中，LRANGE 可以方便地获取列表中的子序列进行进一步处理。

注意事项

• 索引从 0 开始计数，负数索引从列表末尾开始计数。
• start 和 stop 参数超出实际列表长度时，Redis 会自动调整为有效范围内的最大索引。
• 操作时间复杂度为 O(S+N)，其中 S 是要跳过的元素数量，N 是要返回的元素数量，因此对于非常大的列表应注意性能问题。

7 LPUSHX:将一个或多个元素插入到已存在的列表头部

LPUSHX 是 Redis 中用于将一个或多个元素插入到已存在的列表头部的命令。

如果指定的列表不存在，则该操作无任何效果。

通过 LPUSHX，可以在 Redis 中对已存在的列表高效地进行头部插入操作，而无需担心意外创建新的列表。

LPUSHX key element [element ...]

• key: 列表的键名。
• element: 要插入列表头部的一个或多个元素。

返回值

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)
redis> 

返回插入操作后列表的长度。

示例

假设我们有一个列表 mylist，其内容是：

["c", "d"]

1. 将元素 "a" 和 "b" 插入到列表头部：

LPUSHX mylist a b

执行后，列表变为：["b", "a", "c", "d"]

返回值是：4，表示列表现在包含 4 个元素。

2. 尝试向不存在的列表 nonexistentlist 插入元素：

LPUSHX nonexistentlist x

因为列表 nonexistentlist 不存在，所以此操作不起作用，返回值是：0。

使用场景

• 条件性插入：适用于只有在列表已存在时才需要插入新元素的场景。例如，在提供某种特定服务时，只在服务已经启动并存在相关记录的情况下添加新的请求。
• 数据更新：可以用于在列表已经初始化的情况下，更新列表前端的数据。

注意事项

• 与 LPUSH 不同，LPUSHX 不会创建新的列表，因此使用这个命令之前要确保列表已经存在。
• 如果需要确保在不存在列表时创建列表，可以使用 LPUSH 命令。

8 RPUSHX:将一个或多个元素插入到已存在的列表尾部

• RPUSHX：与 LPUSHX 类似，这里就不再赘述。

redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSHX mylist "World"
(integer) 2
redis> RPUSHX myotherlist "World"
(integer) 0
redis> LRANGE mylist 0 -1
1) "Hello"
2) "World"
redis> LRANGE myotherlist 0 -1
(empty array)
redis> 

9 LSET：设置列表中指定索引位置的元素值

LSET 是 Redis 中用于设置列表中指定索引位置的元素值的命令。

LSET key index element

• key: 列表的键名。
• index: 要设置的元素位置的索引。正数索引从 0 开始，负数索引从 -1 开始表示最后一个元素，以此类推。
• element: 要设置的新值。

返回值

redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LSET mylist 0 "four"
"OK"
redis> LSET mylist -2 "five"
"OK"
redis> LRANGE mylist 0 -1
1) "four"
2) "five"
3) "three"
redis> 

• 成功时返回 OK。如果索引超出范围或列表不存在，会返回错误。

• 如果指定的索引超出了列表的范围（即索引在列表长度范围之外），会报错。

• 如果列表不存在，也会报错。

示例

假设我们有一个列表 mylist，其内容是：

["a", "b", "c", "d"]

1. 将索引为 1 的元素设置为 "x"：

LSET mylist 1 x

执行后，列表变为：["a", "x", "c", "d"]

返回值是：OK

2. 使用负数索引将最后一个元素设置为 "z"：

LSET mylist -1 z

执行后，列表变为：["a", "x", "c", "z"]

返回值是：OK

3. 尝试设置超出索引范围的元素：

LSET mylist 10 y

因为索引 10 超出范围，所以会报错：

(error) ERR index out of range

4. 尝试对不存在的列表进行操作：

LSET nonexistentlist 0 y

因为列表 nonexistentlist 不存在，所以会报错：

(error) ERR no such key

使用场景

• 更新特定元素：适用于需要更新列表中某个特定位置的元素值的场景，例如修改某个用户在等待队列中的优先级。
• 修正数据：可以用于修正列表中已经存在的数据，而无需重新创建整个列表。

注意事项

• 索引超出范围会报错，因此在进行 LSET 操作前最好检查列表的长度。
• 如果列表不存在，不会自动创建列表而是直接报错，所以确保列表已存在再进行 LSET 操作。

10 LINDEX:获取列表中指定索引元素

LINDEX 获取列表中指定索引元素的命令。

从一个存储在 Redis 中的列表里根据索引值检索特定的元素。

LINDEX key index

• key: 列表的键。
• index: 列表中元素的索引，从 0 开始。负数索引表示从列表的末尾开始计数，比如 -1 表示列表的最后一个元素。

返回值

• 成功时，返回列表中指定索引处的元素。
• 如果索引超出范围，返回 nil。

示例

列表 mylist：

RPUSH mylist "one" "two" "three" "four"

这个命令会将 "one", "two", "three", 和 "four" 按顺序插入到列表 mylist 中。

使用 LINDEX 来获取特定索引处的元素：

LINDEX mylist 0

返回值是：

"one"

获取索引 2 处的元素：

LINDEX mylist 2

返回值是：

"three"

使用负数索引来获取最后一个元素：

LINDEX mylist -1

返回值是：

"four"

如果索引超出列表的范围，比如尝试获取索引 10 处的元素：

LINDEX mylist 10

返回值是：

(nil)

注意事项

1. 索引从 0 开始: 索引值从 0 开始计数，负数索引从列表末尾开始计数。
2. 时间复杂度: LINDEX 的时间复杂度为 O(N)，其中 N 是到达指定索引的平均步骤数。这意味着对于小列表来说，这个操作非常快，但对于非常大的列表，性能可能会受到影响。
3. 列表存在性: 如果指定的键不存在或不是一个列表，LINDEX 返回 nil。

应用

• 从队列中获取特定位置的任务。
• 检查缓存中某个列表的特定元素。
• 从历史记录中获取特定时间点的数据。

11 LREM：从列表中移除指定数量的与给定值相等的元素

LREM 从列表中移除指定数量的与给定值相等的元素。

该命令可以根据方向（从头到尾或从尾到头）进行删除。

LREM key count value

• key: 列表的键。
• count:
  • count > 0: 从头到尾移除最多 count 个与 value 相等的元素。
  • count < 0: 从尾到头移除最多 count 个与 value 相等的元素。
  • count = 0: 移除列表中所有与 value 相等的元素。
• value: 要移除的元素值。

返回值

返回被移除元素的数量。

示例

列表 mylist，其内容如下：

RPUSH mylist "one" "two" "three" "two" "four" "two"

这个命令将 "one", "two", "three", "two", "four", 和 "two" 按顺序插入到列表 mylist 中。

从头到尾移除最多 1 个 "two" 元素

LREM mylist 1 "two"

操作后，列表变为：

["one", "three", "two", "four", "two"]

返回值是 1，表示移除了一个 "two"。

从尾到头移除最多 2 个 "two" 元素

LREM mylist -2 "two"

操作后，列表变为：

["one", "three", "four"]

返回值是 2，表示移除了两个 "two"。

移除所有的 "four" 元素

LREM mylist 0 "four"

操作后，列表变为：

["one", "three"]

返回值是 1，表示移除了一个 "four"。

注意事项

1. 时间复杂度: LREM 的时间复杂度为 O(N)，其中 N 是列表的长度。这意味着对于非常长的列表，LREM 操作可能会消耗更多的时间。
2. 不存在的元素: 如果列表中没有找到指定的元素，返回值为 0。
3. 列表不存在: 如果指定的键不存在，LREM 返回 0。
4. 负数计数: 负数计数允许从尾到头删除元素。

应用

• 清理队列中的特定元素，例如当某个任务不再需要处理时。
• 从列表中删除重复项或特定条件下的元素。
• 数据清理和维护，在需要动态更新和删除列表内容时使用。

12 LTRIM：保留列表中指定范围内的元素，并删除其他元素

LTRIM 是 Redis 用于修剪列表的命令，保留列表中指定范围内的元素，并删除其他元素。

可以用来限制列表的长度，从而控制内存使用。

LTRIM key start stop

• key: 列表的键。
• start: 范围的起始索引（从 0 开始计数）。
• stop: 范围的结束索引（包含在内）。

返回值

该命令总是返回 OK，即使指定的范围不合理也是如此。

示例

列表 mylist，其内容如下：

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

这个命令将 "one", "two", "three", "four", 和 "five" 按顺序插入到列表 mylist 中。

保留索引 1 到 3 的元素

LTRIM mylist 1 3

操作后，列表变为：

["two", "three", "four"]

保留索引 0 到 1 的元素

LTRIM mylist 0 1

操作后，列表变为：

["two", "three"]

索引超出范围的情况

假设我们再次执行 LTRIM mylist 0 10:

LTRIM mylist 0 10

因为列表中只有 2 个元素，所以整个列表保持不变：

["two", "three"]

空列表的情况

假设我们执行 LTRIM mylist 2 1：

LTRIM mylist 2 1

由于 start 大于 stop，结果是一个空列表：

[]

注意事项

1. 零基索引: Redis 列表的索引是从 0 开始的。
2. 负数索引: 可以使用负数索引来表示从列表末尾开始的偏移量。例如，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。
3. 边界条件: 如果指定的范围超出了列表的实际长度，Redis 会自动调整范围以匹配现有元素。
4. 原地操作: LTRIM 是原地操作，即它会修改原列表，而不是返回一个新的子列表。

应用

• 限制队列长度: 在实现循环队列或固定大小的队列时，LTRIM 可以用来限制列表的最大长度，防止列表无限增长。
• 滑动窗口: 在时间序列数据处理中，可以使用 LTRIM 保持一个滑动窗口，确保只处理最新的数据。
• 缓存管理: 在使用 Redis 作为缓存时，可以定期修剪列表，使其只保留最近访问的几个条目，从而有效利用内存资源。

13 BLPOP:与LPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil

BLPOP 是 Redis 中用于从一个或多个列表的头部弹出元素的命令，它是一个阻塞命令，即如果列表为空，它会等待直到有元素可弹出或超时。

BLPOP key [key ...] timeout

• key [key ...]: 一个或多个列表的键名。如果指定多个列表，BLPOP 会按顺序检查并弹出第一个非空列表的头部元素。
• timeout: 超时时间，单位为秒。如果在超时时间内没有元素可弹出，则命令返回 nil。

返回值

如果有可弹出的元素，则返回一个包含两个元素的数组 [key, element]，其中 key 是被弹出元素的列表的键名，element 是被弹出的元素值。如果超时时间到达仍无元素可弹出，则返回 nil。

行为说明

• BLPOP 会按照列表参数的顺序检查每个列表，并弹出第一个非空列表的头部元素。
• 如果列表不存在或为空，BLPOP 会阻塞等待直到超时或有元素可弹出。
• 超时时间设为 0 表示阻塞时间无限长。

示例

列表 list1 和 list2，分别包含以下元素：

list1: ["a", "b"]
list2: ["c"]

1. 弹出 list1 的头部元素：

BLPOP list1 0

执行后，返回值是：["list1", "a"]，并且 list1 变为 ["b"]。

2. 尝试弹出 list2 和 list1，以 list2 优先：

BLPOP list2 list1 0

执行后，返回值是：["list2", "c"]，并且 list2 变为空列表。

3. 当所有列表都为空时，设置超时等待：

BLPOP list1 list2 10

如果在 10 秒内任何列表有元素可弹出，返回相应的键名和元素；否则，超过 10 秒后返回 nil。

使用场景

• 队列处理：适用于实现简单的消息队列，例如任务分发和异步处理。
• 阻塞等待：当需要从多个列表中获取数据，并且希望在列表为空时进行阻塞等待时，使用 BLPOP 可以有效地实现此功能。

注意事项

• BLPOP 是阻塞命令，会一直等待直到超时或有元素可弹出，因此需要谨慎

14 BRPOP:同BLPOP

同BLPOP，这里就不再赘述。

15 LINSERT:在列表中插入新元素的命令，它允许在指定元素之前或之后插入新值

LINSERT 是 Redis 用于在列表中插入新元素的命令，它允许在指定元素之前或之后插入新值。

LINSERT key BEFORE|AFTER pivot value

• key: 列表的键。
• BEFORE|AFTER: 指定在哪个元素之前或之后插入新值。
• pivot: 要作为插入位置参考的元素。
• value: 要插入的新值。

返回值

返回插入操作完成后，列表的长度。

示例

列表 mylist，其内容如下：

RPUSH mylist "one" "two" "three"

这个命令将 "one", "two", "three" 按顺序插入到列表 mylist 中。

在指定元素之前插入新值

LINSERT mylist BEFORE "two" "new_value"

操作后，列表变为：

["one", "new_value", "two", "three"]

在指定元素之后插入新值

LINSERT mylist AFTER "two" "another_value"

操作后，列表变为：

["one", "new_value", "two", "another_value", "three"]

注意事项

1. 如果 pivot 不存在于列表中，那么不会进行任何插入操作。
2. 如果列表中存在多个相同的值，LINSERT 只会在第一个匹配的值前后进行插入操作。
3. LINSERT 是原地操作，即它会修改原列表，而不是返回一个新的列表。

应用

• 优先级队列: 在优先级队列中，可以使用 LINSERT 插入新任务，并根据任务的优先级在合适的位置进行插入。
• 时间序列数据处理: 在处理时间序列数据时，可能需要在指定时间点插入新数据，LINSERT 可以很好地支持这一需求。
• 有序列表的维护: 如果需要在有序列表中插入新元素，可以使用 LINSERT 维护列表的有序性。

更多的List命令可以去官网https://redis.io/docs/latest/commands/?group=list查看哦~