BLMOVE

从 6.2.0 开始可用。

时间复杂度： O(1)

BLMOVE是 LMOVE 的阻塞变体。当source包含元素时，此命令的行为与LMOVE完全相同。在MULTI / EXEC块内使用时，此命令的行为与LMOVE完全相同。当source为空时，Redis 将阻塞连接，直到另一个客户端推送到它或直到timeout（指定阻塞的最大秒数的双精度值）达到。Atimeout为零可用于无限期阻塞。

此命令代替现在已弃用的BRPOPLPUSH。做 BLMOVE RIGHT LEFT是等价的。

有关详细信息，请参阅LMOVE。

返回值

批量字符串回复：从中弹出source和推送到的元素destination。如果timeout达到，则返回Null 回复。

模式：可靠队列

请参阅LMOVE文档中的模式描述。

模式：循环列表

请参阅LMOVE文档中的模式描述。

BLMPOP

自 7.0.0 起可用。

时间复杂度： O(N+M)，其中 N 是提供的键数，M 是返回的元素数。

BLMPOP是 LMPOP 的阻塞变体。

当任何列表包含元素时，此命令的行为与LMPOP完全相同。在MULTI / EXEC块内使用时，此命令的行为与LMPOP完全相同。当所有列表都为空时，Redis 将阻止连接，直到另一个客户端推送到它或直到timeout（指定要阻止的最大秒数的双精度值）过去。Atimeout为零可用于无限期阻塞。

有关详细信息，请参阅LMPOP。

返回值

数组回复：具体来说：

• Anil当没有元素可以被弹出，并且达到超时。
• 一个双元素数组，第一个元素是从中弹出元素的键的名称，第二个元素是元素数组。

BLPOP

从 2.0.0 开始可用。

时间复杂度： O(N)，其中 N 是提供的密钥的数量。

BLPOP是一个阻塞列表弹出原语。它是LPOP的阻塞版本，因为当没有任何元素可以从任何给定列表中弹出时，它会阻塞连接。从第一个非空列表的头部弹出一个元素，并按照给定的顺序检查给定的键。

非阻塞行为
当调用 BLPOP时，如果指定的键中至少有一个包含非空列表，则从列表的头部弹出一个元素，并与弹出的元素一起返回给调用者key。

密钥按照给出的顺序进行检查。假设密钥list1不存在list2并且list3持有非空列表。考虑以下命令：

BLPOP list1 list2 list3 0

BLPOP保证从存储在的列表中返回一个元素list2（因为它是检查时的第一个非空列表list1，list2并且list3按该顺序）。

阻止行为

如果指定的键都不存在，BLPOP 会阻止连接，直到另一个客户端对其中一个键执行LPUSH或RPUSH操作。

一旦新数据出现在其中一个列表上，客户端就会返回解除阻塞的键名和弹出的值。

当BLPOP导致客户端阻塞并且指定了非零超时时，客户端将nil在指定的超时到期且没有针对至少一个指定键的推送操作的情况下解除阻塞，返回一个多批量值。

**timeout 参数被解释为指定要阻塞的最大秒数的双精度值。**零超时可用于无限期阻塞。

首先提供什么密钥？什么客户？什么元素？优先订购详情。

• 如果客户端尝试阻止多个键，但至少一个键包含元素，则返回的键/元素对是从左到右的第一个具有一个或多个元素的键。在这种情况下，客户端不会被阻止。因此，例如BLPOP key1 key2 key3 key4 0，假设key2和key4都是非空的，将始终从 中返回一个元素key2。
• 如果多个客户端因同一个密钥而被阻止，则要服务的第一个客户端是等待更多时间的客户端（第一个为密钥而阻塞的客户端）。一旦客户端被解除阻塞，它就不会保留任何优先级，当它在下一次调用BLPOP时再次阻塞时，它将根据已为同一键阻塞的客户端数量提供服务，所有客户端都将在它之前提供服务（从第一个到最后一个被阻止的）。
• 当客户端同时阻塞多个键，并且元素同时在多个键中可用（由于事务或 Lua 脚本将元素添加到多个列表中），客户端将使用第一个键解除阻塞收到一个推送操作（假设它有足够的元素来服务我们的客户端，因为可能还有其他客户端也在等待这个键）。基本上，在执行每个命令后，Redis 将运行所有接收数据并且至少有一个客户端被阻止的键的列表。该列表按新元素到达时间排序，从接收数据的第一个键到最后一个键。对于每个处理的键，只要该键中有元素，Redis 将以 FIFO 方式为所有等待该键的客户端提供服务。当密钥为空或不再有客户端等待此密钥时，

BLPOP将多个元素推入列表时的行为。

有时列表可以在同一概念命令的上下文中接收多个元素：

• 可变推操作，例如LPUSH mylist a b c.
• 在对同一个列表执行多个推送操作的 MULTI块之后。
• 使用 Redis 2.6 或更高版本执行 Lua 脚本。

当多个元素被推送到有客户端阻塞的列表中时，Redis 2.4 和 Redis 2.6 或更高版本的行为是不同的。

对于 Redis 2.6，发生的是执行多次推送的命令被执行，并且只有在执行该命令之后才为被阻塞的客户端提供服务。考虑这个命令序列。

Client A:   BLPOP foo 0
Client B:   LPUSH foo a b c

如果使用 Redis 2.6 或更高版本的服务器发生上述情况，则将为客户端Ac提供该元素，因为在LPUSH命令之后列表包含c,b,a，因此从左侧获取元素意味着返回c。

相反，Redis 2.4 以不同的方式工作：客户端在推送操作的上下文中提供服务，因此只要LPUSH foo a b c开始将第一个元素推送到列表中，它将被传递给客户端A，客户端 A 将接收a（推送的第一个元素）。

Redis 2.4 的行为在将数据复制或持久化到 AOF 文件时会产生很多问题，因此在 Redis 2.6 中引入了更通用且语义更简单的行为以防止出现问题。

请注意，出于同样的原因，Lua 脚本或MULTI/EXEC块可能会将元素推送到列表中，然后删除列表。在这种情况下，被阻塞的客户端根本不会被服务，只要在执行单个命令、事务或脚本后列表中没有数据，就会继续被阻塞。

BLPOP在MULTI/EXEC交易里面

BLPOP可以与流水线一起使用（发送多个命令并批量读取回复），但是这种设置几乎仅在它是流水线的最后一个命令时才有意义。

在MULTI / EXEC块中使用BLPOP没有多大意义，因为它需要阻塞整个服务器才能自动执行该块，这反过来又不允许其他客户端执行推送操作。出于这个原因，当列表为空时，MULTI / EXEC 中的 BLPOP 的行为是返回一个多批量回复，这与达到超时时发生的事情相同。nil

如果你喜欢科幻小说，想想在MULTI / EXEC块内以无限速度流动的时间 ......

返回值

数组回复：具体来说：

• nil当没有元素可以弹出并且超时过期时的多批量。
• 一个双元素多块，第一个元素是弹出元素的键的名称，第二个元素是弹出元素的值。

例子

redis> DEL list1 list2
(integer) 0
redis> RPUSH list1 a b c
(integer) 3
redis> BLPOP list1 list2 0
1) "list1"
2) "a"

可靠的队列

当BLPOP向客户端返回一个元素时，它也会从列表中删除该元素。这意味着元素只存在于客户端的上下文中：如果客户端在处理返回的元素时崩溃，它将永远丢失。

对于某些需要更可靠消息传递系统的应用程序，这可能是个问题。在这种情况下，请检查BRPOPLPUSH命令，这是BLPOP的一种变体，它将返回的元素添加到目标列表中，然后再返回给客户端。

模式：事件通知

使用阻塞列表操作可以挂载不同的阻塞原语。例如，对于某些应用程序，您可能需要阻止等待元素进入 Redis Set，这样只要将新元素添加到 Set 中，就可以在不诉诸轮询的情况下检索它。这将需要一个不可用的阻塞版本的SPOP，但使用阻塞列表操作我们可以轻松完成此任务。

消费者会做：

LOOP forever
    WHILE SPOP(key) returns elements
        ... process elements ...
    END
    BRPOP helper_key
END

在生产者方面，我们将简单地使用：

MULTI
SADD key element
LPUSH helper_key x
EXEC

历史

Redis 版本 >= 6.0.0：timeout 被解释为双精度而不是整数。

BRPOP

从 2.0.0 开始可用。

时间复杂度： O(N)，其中 N 是提供的密钥的数量。

BRPOP是一个阻塞列表弹出原语。它是RPOP的阻塞版本，因为当没有任何元素可以从任何给定列表中弹出时，它会阻塞连接。从第一个非空列表的尾部弹出一个元素，并按照给定的顺序检查给定的键。

有关确切的语义，请参阅BLPOP 文档，因为BRPOP与BLPOP相同，唯一的区别是它从列表的尾部弹出元素而不是从头部弹出。

返回值

数组回复：具体来说：

• nil当没有元素可以弹出并且超时过期时的多批量。
• 一个双元素多块，第一个元素是弹出元素的键的名称，第二个元素是弹出元素的值。

例子

redis> DEL list1 list2
(integer) 0
redis> RPUSH list1 a b c
(integer) 3
redis> BRPOP list1 list2 0
1) "list1"
2) "c"

历史

Redis 版本 >= 6.0.0：timeout 被解释为双精度而不是整数。

BRPOPLPUSH

从 2.2.0 开始可用。

时间复杂度： O(1)

弃用通知： 从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但更喜欢使用带有 RIGHT 和 LEFT 参数的 BLMOVE 来代替。

BRPOPLPUSH是 RPOPLPUSH 的阻塞变体。当source包含元素时，此命令的行为与RPOPLPUSH完全相同。在MULTI / EXEC块内使用时，此命令的行为与RPOPLPUSH完全相同。当source为空时，Redis 将阻塞连接，直到另一个客户端向它推送或timeout到达。Atimeout为零可用于无限期阻塞。

有关详细信息，请参阅RPOPLPUSH。

返回值

批量字符串回复：从中弹出source和推送到的元素destination。如果timeout达到，则返回Null 回复。

模式：可靠队列

请参阅RPOPLPUSH文档中的模式描述。

模式：循环列表

请参阅RPOPLPUSH文档中的模式描述。

历史

Redis 版本 >= 6.0.0：timeout 被解释为双精度而不是整数。

LINDEX

从 1.0.0 开始可用。

时间复杂度： O(N)，其中 N 是要遍历到索引处的元素的元素数。这使得请求列表 O(1) 的第一个或最后一个元素。

index返回存储在的列表中 index 处的元素key。索引是从零开始的，因此0意味着第一个元素，1第二个元素等等。负索引可用于指定从列表尾部开始的元素。在这里，-1表示最后一个元素，-2表示倒数第二个等等。

当 at 的值key不是列表时，返回错误。

返回值

批量字符串回复：请求的元素，或者nil何时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)
redis> 

LINSERT

从 2.2.0 开始可用。

时间复杂度： O(N)，其中 N 是在看到值枢轴之前要遍历的元素数。这意味着在列表左端（头）的某处插入可以认为是 O(1)，而在右端（尾）的某处插入是 O(N)。

插入element存储在key引用值之前或之后的列表中pivot。

当key不存在时，则认为是一个空列表，不进行任何操作。

key存在但不包含列表值时返回错误。

返回值

整数回复：插入操作后或未找到-1值时的列表长度pivot。

例子

redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSH mylist "World"
(integer) 2
redis> LINSERT mylist BEFORE "World" "There"
(integer) 3
redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"
redis> 

LLEN

从 1.0.0 开始可用。

时间复杂度： O(1)

返回存储在的列表的长度key。如果key不存在，则将其解释为空列表并0返回。key当存储的值不是列表时返回错误。

返回值

整数回复：列表的长度为key。

例子

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

LMOVE

从 6.2.0 开始可用。

时间复杂度： O(1)

以原子方式返回并删除存储在 的列表的第一个/最后一个元素（头/尾取决于wherefrom参数），并将元素推送到存储在的列表source的第一个/最后一个元素（头/尾取决于whereto 参数）destination。

例如：考虑source持有列表a,b,c，destination 持有列表x,y,z。执行LMOVE source destination RIGHT LEFT结果为sourceholding a,b和destinationholding c,x,y,z。

如果source不存在，nil则返回该值，不进行任何操作。如果source和destination相同，则该操作相当于从列表中删除第一个/最后一个元素并将其作为列表的第一个/最后一个元素推送，因此可以将其视为列表轮换命令（如果wherefrom是，则为无操作）同whereto）。

此命令代替现在已弃用的RPOPLPUSH。做 LMOVE RIGHT LEFT是等价的。

返回值

批量字符串回复：被弹出和推送的元素。

例子

redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LMOVE mylist myotherlist RIGHT LEFT
"three"
redis> LMOVE mylist myotherlist LEFT RIGHT
"one"
redis> LRANGE mylist 0 -1
1) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
2) "one"
redis> 

LMPOP

自 7.0.0 起可用。

时间复杂度： O(N+M)，其中 N 是提供的键数，M 是返回的元素数。

从提供的键名列表中的第一个非空列表键中弹出一个或多个元素。

LMPOP和BLMPOP类似于以下更有限的命令：

• LPOP或RPOP只需要一个键，并且可以返回多个元素。
• BLPOP或BRPOP接受多个键，但仅从一个键返回一个元素。
  有关此命令的阻塞变体，请参见BLMPOP。

根据传递的参数，从第一个非空列表的左侧或右侧弹出元素。返回元素的数量限制为非空列表长度和 count 参数（默认为 1）之间的较低值。

返回值

数组回复：具体来说：

• Anil当没有元素可以被弹出时。
• 一个双元素数组，第一个元素是从中弹出元素的键的名称，第二个元素是元素数组。

例子

redis> LMPOP 2 non1 non2 LEFT COUNT 10
ERR Unknown or disabled command 'LMPOP'
redis> LPUSH mylist "one" "two" "three" "four" "five"
(integer) 5
redis> LMPOP 1 mylist LEFT
ERR Unknown or disabled command 'LMPOP'
redis> LRANGE mylist 0 -1
1) "five"
2) "four"
3) "three"
4) "two"
5) "one"
redis> LMPOP 1 mylist RIGHT COUNT 10
ERR Unknown or disabled command 'LMPOP'
redis> LPUSH mylist "one" "two" "three" "four" "five"
(integer) 10
redis> LPUSH mylist2 "a" "b" "c" "d" "e"
(integer) 5
redis> LMPOP 2 mylist mylist2 right count 3
ERR Unknown or disabled command 'LMPOP'
redis> LRANGE mylist 0 -1
1) "five"
 2) "four"
 3) "three"
 4) "two"
 5) "one"
 6) "five"
 7) "four"
 8) "three"
 9) "two"
10) "one"
redis> LMPOP 2 mylist mylist2 right count 5
ERR Unknown or disabled command 'LMPOP'
redis> LMPOP 2 mylist mylist2 right count 10
ERR Unknown or disabled command 'LMPOP'
redis> EXISTS mylist mylist2
(integer) 2
redis> 

LPOP

从 1.0.0 开始可用。

时间复杂度： O(N)，其中 N 是返回的元素数

返回值

不带count参数调用时：

批量字符串回复：第一个元素的值，或者nil什么时候key不存在。

当使用count参数调用时：

数组回复：弹出元素的列表，或者nil何时key不存在。

例子

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> 

历史

• Redis 版本 >= 6.2.0：添加了 count 参数。

LPOS

从 6.0.6 开始可用。

时间复杂度： O(N)，其中 N 是列表中元素的数量，对于平均情况。当搜索列表的头部或尾部附近的元素时，或者提供了 MAXLEN 选项时，该命令可能会在恒定时间内运行。

该命令返回 Redis 列表中匹配元素的索引。默认情况下，当没有给出选项时，它会从头到尾扫描列表，寻找“元素”的第一个匹配项。如果找到该元素，则返回其索引（列表中从零开始的位置）。否则，如果未找到匹配项，nil则返回。

> RPUSH mylist a b c 1 2 3 c c
> LPOS mylist c
2

可选参数和选项可以修改命令的行为。该RANK选项指定要返回的第一个元素的“排名”，以防有多个匹配项。等级 1 表示返回第一个匹配项，2 表示返回第二个匹配项，依此类推。

例如，在上面的例子中，元素“c”出现了多次，如果我想要第二个匹配的索引，我会写：

> LPOS mylist c RANK 2
6

也就是说，“c”的第二次出现在位置 6。作为RANK参数的负“等级”告诉LPOS反转搜索方向，从尾部到头部。

所以，我们想说，给我从列表尾部开始的第一个元素：

> LPOS mylist c RANK -1
7

请注意，索引仍然以“自然”方式报告，即考虑从索引 0 处的列表头部开始的第一个元素，索引 1 处的下一个元素，依此类推。这基本上意味着无论排名是正还是负，返回的索引都是稳定的。

有时我们不仅要返回第 N 个匹配元素，还要返回所有前 N 个匹配元素的位置。这可以使用该COUNT选项来实现。

> LPOS mylist c COUNT 2
[2,6]

我们可以组合COUNTand RANK，这样COUNT将尝试返回指定数量的匹配项，但从RANK选项指定的第 N 个匹配项开始。

> LPOS mylist c RANK -1 COUNT 2
[7,6]

使用时COUNT，可以将 0 指定为匹配数，以告诉命令我们希望将所有找到的匹配作为索引数组返回。这比给出一个非常大的COUNT选项要好，因为它更通用。

> LPOS mylist c COUNT 0
[2,6,7]

使用时COUNT未找到匹配项，则返回一个空数组。但是，当COUNT未使用且没有匹配项时，命令返回nil.

最后，该MAXLEN选项告诉命令仅将提供的元素与给定的最大列表项数进行比较。因此，例如指定MAXLEN 1000将确保命令仅执行 1000 次比较，有效地在列表的子集上运行算法（第一部分或最后一部分取决于我们使用正或负排名的事实）。这对于限制命令的最大复杂性很有用。当我们希望很早就找到匹配项时，它也很有用，但要确保万一这不是真的，该命令不会花费太多时间来运行。

使用时MAXLEN，可以指定 0 作为最大比较次数，作为告诉命令我们想要无限比较的一种方式。这比给出一个非常大的MAXLEN选项要好，因为它更通用。

返回值

该命令返回表示匹配元素的整数，或者nil如果没有匹配项。但是，如果COUNT给出该选项，该命令将返回一个数组（如果没有匹配项则为空）。

例子

redis> RPUSH mylist a b c d 1 2 3 4 3 3 3
(integer) 11
redis> LPOS mylist 3
(integer) 6
redis> LPOS mylist 3 COUNT 0 RANK 2
1) (integer) 8
2) (integer) 9
3) (integer) 10
redis> 

LPUSH

从 1.0.0 开始可用。

时间复杂度：每个添加的元素 O(1)，因此当使用多个参数调用命令时添加 N 个元素是 O(N)。

将所有指定的值插入存储在的列表的头部key。如果key不存在，则在执行推送操作之前将其创建为空列表。当key保存一个不是列表的值时，将返回错误。

可以使用单个命令调用推送多个元素，只需在命令末尾指定多个参数。元素一个接一个地插入到列表的头部，从最左边的元素到最右边的元素。因此，例如，该命令LPUSH mylist a b c将生成一个包含c第一个元素、b第二个元素和a第三个元素的列表。

返回值

整数回复：推送操作后的列表长度。

例子

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

历史

• Redis 版本 >= 2.4.0：接受多个 element 参数。

LPUSHX

从 2.2.0 开始可用。

时间复杂度：每个添加的元素 O(1)，因此当使用多个参数调用命令时添加 N 个元素是 O(N)。

key仅当key 已存在并持有一个列表时，才在存储在 的列表的开头插入指定的值。与LPUSH相反，当key还不存在时不会执行任何操作。

返回值

整数回复：推送操作后的列表长度。

例子

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 list or set)
redis> 

历史

• Redis 版本 >= 4.0.0：接受多个 element 参数。

LRANGE

从 1.0.0 开始可用。

时间复杂度： O(S+N)，其中 S 是小列表的起始偏移量到 HEAD 的距离，大列表到最近端（HEAD 或 TAIL）的距离；N 是指定范围内的元素个数。

返回存储在的列表的指定元素key。偏移量start和stop是从零开始的索引，0是列表的第一个元素（列表的头部），1是下一个元素，依此类推。

这些偏移量也可以是负数，表示从列表末尾开始的偏移量。例如，-1是列表的最后一个元素，-2倒数第二个，等等。

与各种编程语言中的范围函数保持一致

请注意，如果您有一个从 0 到 100 的数字列表，LRANGE list 0 10将返回 11 个元素，即包含最右边的项目。这可能与您选择的编程语言中与范围相关的函数的行为一致，也可能不一致（想想 Ruby 或 Python 的Range.new函数）。Array#slicerange()

超出范围的索引

超出范围的索引不会产生错误。如果start大于列表的末尾，则返回一个空列表。如果stop大于列表的实际末尾，Redis 会将其视为列表的最后一个元素。

返回值

数组回复：指定范围内的元素列表。

例子

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 list or set)
redis> 

LREM

从 1.0.0 开始可用。

时间复杂度： O(N+M)，其中 N 是列表的长度，M 是移除的元素数。

从存储在的列表中删除第一次count出现的等于 的元素。该参数通过以下方式影响操作：elementkeycount

• count > 0：删除元素等于从头到尾element移动。
• count < 0：删除元素等于element从尾部移动到头部。
• count = 0: 删除所有等于 的元素element。
  例如，LREM list -2 "hello"将删除 "hello"存储在的列表中最后两次出现的list。

请注意，不存在的键被视为空列表，因此当key不存在时，该命令将始终返回0.

返回值

整数回复：移除元素的数量。

例子

redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "hello"
(integer) 2
redis> RPUSH mylist "foo"
(integer) 3
redis> RPUSH mylist "hello"
(integer) 4
redis> LREM mylist -2 "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "foo"
redis> 

LSET

从 1.0.0 开始可用。

时间复杂度： O(N)，其中 N 是列表的长度。设置列表的第一个或最后一个元素是 O(1)。

将列表元素设置index为element。有关index参数的更多信息，请参阅LINDEX。
超出范围的索引返回错误。

返回值

简单的字符串回复

例子

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> 

LTRIM

从 1.0.0 开始可用。

时间复杂度： O(N)，其中 N 是操作要删除的元素数。

修剪现有列表，使其仅包含指定范围的指定元素。start和都是stop从零开始的索引，其中0是列表的第一个元素（头部），1下一个元素等等。

例如：LTRIM foobar 0 2将修改存储在的列表，foobar以便仅保留列表的前三个元素。

start并且end也可以是负数，表示距列表末尾的偏移量，其中-1是列表的最后一个元素，-2倒数第二个元素等等。

超出范围的索引不会产生错误：如果start大于列表的末尾，或者start > end，结果将是一个空列表（导致key被删除）。如果end大于列表的末尾，Redis 会将其视为列表的最后一个元素。

LTRIM的一个常见用途是与LPUSH / RPUSH一起使用。例如：

LPUSH mylist someelement
LTRIM mylist 0 99

这对命令将在列表中推送一个新元素，同时确保列表不会超过 100 个元素。例如，这在使用 Redis 存储日志时非常有用。重要的是要注意，当以这种方式使用时，LTRIM是一个O(1)操作，因为在平均情况下，只会从列表的尾部删除一个元素。

返回值

简单的字符串回复

例子

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

RPOP

从 1.0.0 开始可用。

时间复杂度： O(N)，其中 N 是返回的元素数

删除并返回存储在的列表的最后一个元素key。

默认情况下，该命令从列表末尾弹出一个元素。当提供可选count参数时，回复将由多达count元素组成，具体取决于列表的长度。

返回值

不带count参数调用时：

批量字符串回复：最后一个元素的值，或者nil什么时候key不存在。

当使用count参数调用时：

数组回复：弹出元素的列表，或者nil何时key不存在。

例子

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

历史

• Redis 版本 >= 6.2.0：添加了 count 参数。

RPOPLPUSH

从 1.2.0 开始可用。

时间复杂度： O(1)

弃用通知： 从 Redis 版本 6.2.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但最好使用带有 RIGHT 和 LEFT 参数的 LMOVE 来代替。

以原子方式返回并删除存储在 的列表的最后一个元素（尾） source，并将该元素推送到存储在的列表的第一个元素（头）destination。

例如：考虑source持有列表a,b,c，destination 持有列表x,y,z。执行RPOPLPUSH导致sourceholdinga,b和destination holding c,x,y,z。

如果source不存在，nil则返回该值，不进行任何操作。如果source和destination相同，则该操作相当于从列表中删除最后一个元素并将其作为列表的第一个元素推送，因此可以认为是列表旋转命令。

返回值

批量字符串回复：被弹出和推送的元素。

例子

redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOPLPUSH mylist myotherlist
"three"
redis> LRANGE mylist 0 -1
1) "one"
2) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
redis> 

模式：可靠队列
Redis 通常用作消息传递服务器，以实现处理后台作业或其他类型的消息传递任务。一种简单的队列形式通常是在生产者端将值推送到一个列表中，并在消费者端使用RPOP （使用轮询）等待这个值，或者如果客户端通过阻塞操作更好地服务，则使用BRPOP 。

然而，在这种情况下，获得的队列是不可靠的，因为消息可能会丢失，例如在网络问题的情况下，或者如果消费者在收到消息后但在处理之前崩溃。

RPOPLPUSH（或阻塞变体的BRPOPLPUSH）提供了一种避免此问题的方法：消费者获取消息并同时将其推送到处理列表中。一旦消息被处理，它将使用LREM命令从 处理列表中删除消息。

额外的客户端可能会监视处理列表中停留时间过长的项目，如果需要，将超时的项目再次推送到队列中。

模式：循环列表

使用具有相同源和目标键的RPOPLPUSH ，客户端可以在O(N)中一个接一个地访问 N 元素列表的所有元素，而无需使用单个LRANGE 操作将完整列表从服务器传输到客户端.

即使出现以下一种或两种情况，上述模式仍然有效：

• 有多个客户端轮换列表：它们将获取不同的元素，直到列表的所有元素都被访问，并且进程重新启动。
• 其他客户正在积极推动列表末尾的新项目。

以上使得实现一个系统变得非常简单，其中一组项目必须由 N 个工作人员以尽可能快的速度连续处理。一个例子是一个监控系统，它必须检查一组网站是否可以访问，并且使用多个并行工作程序以尽可能小的延迟。

请注意，worker 的这种实现具有微不足道的可扩展性和可靠性，因为即使消息丢失，该项目仍在队列中，并将在下一次迭代中处理。

RPUSH

从 1.0.0 开始可用。

时间复杂度：每个添加的元素 O(1)，因此当使用多个参数调用命令时添加 N 个元素是 O(N)。

将所有指定的值插入到存储在的列表的尾部key。如果key不存在，则在执行推送操作之前将其创建为空列表。当key保存一个不是列表的值时，将返回错误。

可以使用单个命令调用推送多个元素，只需在命令末尾指定多个参数。元素一个接一个地插入到列表的尾部，从最左边的元素到最右边的元素。因此，例如，该命令RPUSH mylist a b c将生成一个包含a第一个元素、b第二个元素和c第三个元素的列表。

返回值

整数回复：推送操作后的列表长度。

例子

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

历史

• Redis 版本 >= 2.4.0：接受多个 element 参数。

RPUSHX

从 2.2.0 开始可用。

时间复杂度：每个添加的元素 O(1)，因此当使用多个参数调用命令时添加 N 个元素是 O(N)。

key仅当key 已存在并持有一个列表时，才在存储在 的列表的尾部插入指定的值。与RPUSH相反，当key还不存在时不会执行任何操作。

返回值

整数回复：推送操作后的列表长度。

例子

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 list or set)
redis> 

历史

• Redis 版本 >= 4.0.0：接受多个 element 参数。