Redis 命令详情介绍

自1.0.0版本可用

时间复杂度: O(N) ，N为将要被删除的key的个数。 当要删除一个保存的值类型不是string的key时，对于这个key的单独的时间复杂度是(M) ，M代表 list, set, sorted set or hash里的元素个数，删除string类型值的key的时间复杂度是O(1)。

　　删除给定的key。忽略不存在的key。

返回值

　　整型Integer reply: 被删除的key的数量.

例子

redis> SET key1 'hello'
"OK"
redis> SET key2 'world'
"OK"
redis> DEL key1 key2
(interger)2

2. dump

命令格式：DUMP key

可用版本 >= 2.6.0.

时间复杂度 : 访问key是O(1)和序列化O(N*M) ，N表示值由几个Redis对象组成，M是它们的平均大小。因此对于字符串值来说时间复杂度是O(1)+O(1*M) ，由于M很小，所以接近O(1).

以Redis特有的格式序列化存储在key中的值并返回给用户。返回的值可以使用 RESTORE 命令存储回某个key中。

序列化后的格式是无法理解且无标准的，尽管如此，它仍有一些语义特征：

包含用来检查是否有错误的64位检验和。RESTORE command makes sure to check the checksum before synthesizing a key using the serialized value.
值的编码格式和RDB相同。
RDB的版本被包含在序列化结果中，所以使用不兼容RDB格式的不同Redis版本之间，不能处理对方序列化后的值。

序列化的值不包含到期信息。为了获得当前key的值的生存时间，应该使用 PTTL 命令。

如果key不存在，空批量回复（nil bulk reply）被返回。

返回值

　　批量回复Bulk string reply: 序列化的值。

例子

redis> SET mykey 10
"OK"
redis> DUMP mykey
"
0000xC0
u0000撞xBBxFaxA7xB7xE9x83”
redis>

3. exists

命令格式：EXISTS key [key …]

自1.0.0版本可用

时间复杂度: O(1)

返回key是否存在。

自Redis 3.0.3起可以指定多个key来替代一个key。这种情况下，返回存在key的总数。对单个key返回1或0只是多个参数的一个具体实例，所以这个命令是向后兼容的。

用户需要注意，如果相同的key在参数列表中出现了多次，它会被计算多次。所以，如果somekey存在, EXISTS somekey somekey 命令返回 2.

返回值

整型Integer reply,:

1 如果key存在
0 如果key不存在

自Redis 3.0.3命令可以处理可变参数的多个key，返回值总结：

返回参数给定的存在的key的数量。key如果存出现多次会被重复计算。

例子

redis> SET key1 'Hello'
"OK"
redis> EXISTS key1
(integer) 1
redis> EXISTS nosuchkey
(integer) 0
redis> SET key2 "world"
"OK"
redis> EXISTS key1 key2 nosuchkey
(integer) 0

4. expire

命令格式：EXPIRE key seconds

自 1.0.0版本可用

时间复杂度: O(1)

命令格式：EXPIRE key seconds

自 1.0.0版本可用

时间复杂度: O(1)

给key设置超时时间(timeout)。设置的超时时间过期后，key会被自动删除。在Redis术语中带有超时时间的key通常被称为不稳定的(volatile)。

超时时间只能被删除或者覆盖key内容的命令清除，包括 DEL, SET, GETSET 和所有的 *STORE 命令。从概念上来说，那些修改key中存储的值，而不是用新值替换旧值的命令，不会修改timeout。例如, 自增key存储的值的 INCR, 向list中新增一个值 LPUSH, 或者修改hash域的值 HSET ，这些都不会修改key的timeout。

通过使用 PERSIST命令把key改回持久类型(persistent)的key，这样key的timeout也可以被清除。

一个key使用RENAME改名后，生存时间被转移到新key上。

一个已存在的旧key使用RENAME重写，那么新key会继承所有旧key的属性。例如，一个名为Key_A的 key 使用命令 RENAME Key_B Key_A重写，原Key_A有没有设置timeout都没影响，新的Key_A会继承所有Key_B的属性。

特别注意，使用非正的timeout调用 EXPIRE/PEXPIRE 或使用过去的时间调用 EXPIREAT/PEXPIREAT ，那么key会被删除 deleted 而不是过期。 (因此, 发出的 key event 将是 del, 而不是 expired).

刷新超时时间

已经设置过期的key，可以调用 EXPIRE 重新设置。在这种情况下key的生存时间被更新为新值。因为这个特性出现了很多有用的应用，本文下面的 Navigation session pattern 部分就是一个例子。

Expire在Redis 2.1.3之前版本的不同

在 2.1.3 之前的版本使用Expire修改已经设置过生存时间的key，将会和删掉key有同样的效果。这是被已被修复的复制层的限制所有需要的特性。

返回值

Integer reply:

1 设置成功。
0 key不存在或设置失败。

例子

redis> SET mykey “Hello”
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10
redis> SET mykey “Hello World”
"OK"
redis> TTL mykey
(integer) -1

模式: 导航会话(Navigation session)

假设你有个web服务并且你关注用户最近最新访问的N个页面，考虑到每个相邻新页面的访问不会超过访问前一个页面60秒，概念上我们可以考虑把这一系列的页面访问作为一个用户的导航会话。这里面包含了很多关于用户正在寻找什么样产品的有用信息，你可以据此给用户推荐产品。

在Redis中使用下面的策略你可以很容义给这种模式建模：用户每访问一个页面，你都执行下面的指令：

MULTI
RPUSH pagewviews.user:<userid> http://.....
EXPIRE pagewviews.user:<userid> 60
EXEC

如果用户所访问的页面空闲时间超过 60 秒,，那么这个key将会被删除，只有那些接下来少于60秒空闲的页面访问将会被保留。这个模式可以修改为使用计数指令 INCR 替换列表的 RPUSH.

附录: Redis expires

带有生存时间的key

一般来说Redis中创建key的是不带生存时间，如果你不使用类似DEL 命令明确删除它，这个key将会一直存在。

EXPIRE 命令族可以给指定的key关联生存时间，key会额外多占用一些内存。一旦一个key设置了生存时间，那么指定的时间消耗完后，Redis需要确保指令被删除。

key的生存时间可以被EXPIRE命令更新或PERSIST 命令删掉。

生存时间的精度

Redis 2.4 生存时间并不精准，一般在0到1秒多。

从Redis 2.6起，生存时间精度提高到0到1毫秒多。

过期和持久性

key的生存时间以绝对Unix时间戳的方式存储。这意味无论Redis是否运行，生存时间都会流逝。

服务器的时间必须稳定，这样生存时间才能更准确。如果在两个时间相差多的机器之间移动RDB文件，那么可能会出现所有的key在加载的时候都过期了。

运行的Redis也会不停的检查服务器的时间，如果你设置一个带有1000秒生存时间的key，然后你把服务器的时间向前调了2000秒，那么这个key会立刻过期，不是等1000秒后过期。

Redis如何淘汰过期Key

Redis的key有两种过期淘汰的方式：被动方式、主动方式。

被动过期：用户访问某个key的时候，key被发现过期。

当然，被动方式过期对于那些永远也不会再次被访问的key并没有效果。不管怎么，这些key都应被过期淘汰，所以Redis周期性随机检查一部分被设置生存时间的key，那些已经过期的key会被从key空间中删除。

Redis每秒执行10次下面的操作：

从带有生存时间的key的集合中随机选20进行检查。
删除所有过期的key。
如20里面有超过25%的key过期，立刻继续执行步骤1。

这是一个狭义概率算法，我们假设我们选出来的样本key代表整个key空间，我们继续过期检查直到过期key的比例降到25%以下。

这意味着在任意时刻已经过期但还占用内存的key的数量，最多等于每秒最多写操作的四分之一。

复制连接和AOF文件是如何处理过期

为了获得正确结果而不牺牲一致性。当一个key过期, 一个 DEL 操作同时在AOF文件和当前配置的所有的从服务器实例上执行。过期处理中心化在主实例上处理，没有出现一致性错误的机会。

但是，尽管连接到主服务器的从服务器不会独立地使key过期（但会等待来自主服务器的del），但它们仍持有完整的存在数据集中的过期状态，因此当从服务器被选为主服务器时，它将能够独立地使key过期，完全充当主服务器。

5. expireat

命令格式: EXPIREAT key timestamp

自 1.2.0. 版本可用

时间复杂度: O(1)

EXPIREAT 的作用和语义与 EXPIRE 相同，除了它使用绝对Unix时间戳 (自1970年1月1日以来的秒数)代替表示生存时间的秒数。使用过去的时间戳将会立即删除该key。

详细语义说明可以参考 EXPIRE.

背景

EXPIREAT 引入的目的是为了把AOF持久化模式的相对时间转换为绝对时间。当然，也可以直接指明某个 key在未来某个时间过期。

返回值

整型Integer reply:

1 timeout设置成功.
0 key不存在或timeout设置失败 (详见: EXPIRE).

例子

redis> SET mykey “Hello”
"OK"
redis> EXISTS mykey
(integer) 1
redis> EXPIREAT mykey 1293840000
(integer) 1
redis> EXISTS mykey
(integer) 0

6. keys

命令格式KEYS pattern

自1.0.0版本可用

时间复杂度: O(N) , 假设数据库中的键名和给定的模式的长度有限的情况下，N为数据库中key的个数。

返回匹配模式pattern的所有key。

尽管这个操作的时间复杂度是 O(N), 但是常量时间相当低。例如，在一个普通笔记本上跑Redis，扫描100万个key只要40毫秒。

Warning: 生产环境使用 KEYS 命令需要非常小心。在大的数据库上执行命令会影响性能。这个命令适合用来调试和特殊操作，像改变键空间keyspace布局。不要在你的代码中使用 KEYS 。如果你需要一个寻找键空间中的key子集，考虑使用SCAN 或 sets。

支持的匹配模式 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

使用转义你想匹配的特殊字符。

返回值

Array reply: 以数组的形式返回匹配模式pattern的key的列

例子

redis> MSET one 1 two 2 three 3 four 4
"OK"
redis> KEYS *o*
1) "two"
2) "four"
3) "one"
redis> KEYS t??
1) "two"
redis> KEYS *
1) "two"
2) "four"
3) "one"
4) "three"

7. migrate

Redis迁移命令

MIGRATE 主机端口密钥|“” destination-db 超时 [复制] [替换] [密钥[密钥…]]

可用版本> = 2.6.0。

时间复杂度：该命令实际上在源实例中执行DUMP + DEL，而在目标实例中执行RESTORE。有关时间复杂度，请参见这些命令的页面。同样，在两个实例之间执行O（N）数据传输。

将密钥从源Redis实例原子转移到目标Redis实例。成功后，密钥将从原始实例中删除，并保证存在于目标实例中。

该命令是原子的，并且在转移密钥所需的时间内阻止了这两个实例，在任何给定时间，该密钥似乎都将存在于给定实例或另一个实例中，除非发生超时错误。在3.2及更高版本中，可以通过传递空字符串（“”）作为键并添加KEYS子句来在一次对MIGRATE的调用中通过管线传递多个键。

该命令在内部使用DUMP生成键值的序列化版本，并使用RESTORE以便在目标实例中合成键。源实例充当目标实例的客户端。如果目标实例对RESTORE命令返回OK ，则源实例使用DEL删除密钥。

超时指定在与目标实例进行通信的任何时刻的最大空闲时间（以毫秒为单位）。这意味着不需要在指定的毫秒数内完成操作，但是传输应该在不阻塞超过指定的毫秒数的情况下进行。

MIGRATE需要执行I / O操作并遵守指定的超时。如果在传输过程中发生I / O错误，或者如果达到超时，操作将中止，并IOERR返回特殊错误– 。发生这种情况时，可能出现以下两种情况：

该密钥可能同时在两个实例上。
密钥只能在源实例中。

在超时的情况下，密钥不可能丢失，但是在发生超时错误的情况下，调用MIGRATE的客户端应检查该密钥是否也存在于目标实例中并采取相应的措施。

当返回任何其他错误时（以开头ERR），MIGRATE保证密钥仍仅存在于原始实例中（除非目标实例中已经存在相同名称的密钥）。

如果在源实例中没有要迁移的键，NOKEY则返回。因为在正常情况下可能会丢失键，例如从到期起算，NOKEY这不是错误。

通过单个命令迁移多个键

从Redis 3.0.6开始，MIGRATE支持一种新的批量迁移模式，该模式使用流水线操作，以便在实例之间迁移多个密钥，而不会产生往返时间延迟以及使用单个MIGRATE调用移动每个密钥时的其他开销。

为了启用此格式，使用了KEYS选项，并且正常的key参数设置为空字符串。实际的键名将在KEYS参数本身之后提供，如以下示例所示：

MIGRATE 192.168.1.34 6379 "" 0 5000 KEYS key1 key2 key3

使用此格式NOKEY时，仅当实例中不存在任何键时才返回状态代码，否则即使仅存在一个键也将执行命令。

选件

COPY —不要从本地实例中删除密钥。
REPLACE —替换远程实例上的现有密钥。
KEYS —如果key参数是一个空字符串，那么该命令将迁移所有在KEYS选项之后的键（有关更多信息，请参见上一节）。

COPY并且REPLACE仅在3.0及更高版本中可用。从Redis 3.0.6开始可以使用KEYS。

返回值

简单字符串回复：成功或NOKEY在源实例中未找到任何键时，该命令将返回OK 。

8. move

命令格式：MOVE key db

自1.0.0版本可用

时间复杂度: O(1)

把key从当前select数据库 (参考 SELECT) 移动到指定的目的数据库。如果key在目标数据库中已存在，或者在源数据库中不存在，那么什么也不会发生。出于这个原因，可以把使用 MOVE 作为锁原语(locking primitive )

返回值

Integer reply:

1 如果key移动成功。
0 如果key移动失败。

9. object

OBJECT 子命令 [arguments [arguments…]]

可用版本> = 2.2.3。

时间复杂度： O（1）用于所有当前实现的子命令。

的OBJECT命令允许检查与密钥相关联的Redis对象的内部结构。这对于调试或了解您的密钥是否使用特殊编码的数据类型以节省空间很有用。在将Redis用作缓存时，您的应用程序还可以使用OBJECT命令报告的信息来实现应用程序级密钥收回策略。

的OBJECT命令支持的多个子命令：

OBJECT REFCOUNT <key>返回与指定键关联的值的引用数。该命令主要用于调试。
OBJECT ENCODING <key> 返回用于存储与键关联的值的内部表示形式的类型。
OBJECT IDLETIME <key>返回自存储在指定键处的对象处于空闲状态以来的秒数（读或写操作未请求）。虽然以秒为单位返回该值，但此计时器的实际分辨率为10秒，但在将来的实现中可能会有所不同。

可以用不同的方式对对象进行编码：

可以将字符串编码为raw（常规字符串编码）或int（以这种方式编码表示64位有符号间隔中的整数的字符串以节省空间）。
列表可以编码为ziplist或linkedlist。这ziplist是特殊的表示形式，用于节省小列表的空间。
集可以编码为intset或hashtable。该intset是用于单纯的整数组成的小集的特殊编码。
哈希可以编码为ziplist或hashtable。该ziplist是用于小型哈希一个特殊的编码。
排序集可以编码为ziplist或skiplist格式。至于List类型，可以使用专门对小的排序集进行编码ziplist，而skiplist编码是适用于任何大小的排序集的编码。

一旦执行了使Redis无法保留节省空间的编码的操作，所有特殊编码的类型都会自动转换为通用类型。

返回值

不同的返回值用于不同的子命令。

子命令refcount并idletime返回整数。
子命令encoding返回批量答复。

如果缺少您要检查的对象，则返回空批量答复。

例子

redis> lpush mylist "Hello World"
(integer) 4
redis> object refcount mylist
(integer) 1
redis> object encoding mylist
"ziplist"
redis> object idletime mylist
(integer) 10

在以下示例中，您可以看到一旦Redis不再能够使用节省空间的编码，编码将如何更改。

redis> set foo 1000
OK
redis> object encoding foo
"int"
redis> append foo bar
(integer) 7
redis> get foo
"1000bar"
redis> object encoding foo
"raw"

10. persist

命令格式：PERSIST key

自2.2.0版本可用

时间复杂度: O(1)

删除key的超时(timeout)，把key从易变的 (带有超时的key)变成持久的 (不设置生存时间永不过期的key)。

返回值

Integer reply:

1 如果timeout被删除。
0 如果key不存在或key没有关联timeout。

例子

redis> SET mykey “Hello”
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10
redis> PERSIST mykey
(integer) 1
redis> TTL mykey
(integer) -1

11. pexpire

PEXPIRE key milliseconds

可用版本 >= 2.6.0.

时间复杂度 : O(1)

此命令的工作方式与EXPIRE完全相同，但密钥的生存时间以毫秒为单位指定，而不是以秒为单位。

返回值

Integer reply, specifically:

1 if the timeout was set.
0 if key does not exist or the timeout could not be set.

例子

redis> SET mykey “Hello”
"OK"
redis> PEXPIRE mykey 1500
(integer) 1
redis> TTL mykey
(integer) 1
redis> PTTL mykey
(integer) 1497

12. pexpireat

命令格式：PEXPIREAT key milliseconds-timestamp

自 2.6.0版本可用

时间复杂度: O(1)

PEXPIREAT 和 EXPIREAT, 用同样的功能和语义，但该键的生存时间是以毫秒而不是以秒为单位指定的。。

返回值

Integer reply, 具体来说:

1 超时设置成功.
0 key不存在或超时设置失败 (详细参考: EXPIRE).

实例

redis> SET mykey “Hello”
"OK"
redis> PEXPIREAT mykey 1555555555005
(integer) 1
redis> TTL mykey
(integer) 68649199
redis> PTTL mykey
(integer) 68649198623

13. pttl

命令格式:PTTL key

自2.6.0.版本可用

时间复杂度: O(1)

和 TTL 命令一样，PTTL命令返回设置超时key的剩余生存时间，唯一的不同是TTL是以秒为单位，PTTL是以毫秒为单位。

在Redis 2.6或之前的版本，如果key不存在或者key存在但是没有关联超时，则命令返回 -1

自Redis 2.8起，返回值根据不同的错误而变：

-2 如果key不存在。
-1 如果key存在但是没有关联超时。

返回值

　　整型Integer reply: 以毫秒为单位的TTL，或者负数值表示某个错误。

例子

redis> SET mykey “Hello”
"OK"
redis> EXPIRE mykey 1
(integer) 1
redis> PTTL mykey
(integer) 999

14. randomkey

RANDOMKEY

可用版本 >= 1.0.0.

时间复杂度： O(1)

从当前数据库中返回随机密钥

返回值

批量字符串回复：随机密钥，如果数据库为空，则为空。

15. rename

命令格式： RENAME key newkey

自1.0.0版本可用

时间复杂度: O(1)

修改key的名字为newkey。如果key不存在返回错误。如果newkey是一个已存在的键，那么newkey会被覆盖，当newkey被覆盖的时候， RENAME 执行一个隐式的 DEL 操作，所以如果被删除的key包含一个非常大的值,这可能会引起高延迟，即使 RENAME 本身通常是一个常量时间的操作。

特别注意: Redis 3.2.0之前, 如果源和目的key相同将返回错误。

返回值

简单字符串回复

例子

redis> SET mykey “Hello”
"OK"
redis> RENAME mykey myotherkey
"OK"
redis> GET myotherkey
"Hello"

16. renamenx

命令格式：RENAMENX key newkey

自1.0.0.版本可用

时间复杂度: O(1)

如果newkey不存在，重命名key为newkey。当key不存在时返回错误。

注意: 在Redis 3.2.0版本之前，如果源和目的key名字相同返回错误。

返回值

整型Integer reply:

1 设置成功
0 如果newkey已经存在。

例子

redis> SET mykey “Hello”
"OK"
redis> SET myotherkey “World”
"OK"
redis> RENAMENX mykey myotherkey
(integer) 0
redis> GET myotherkey
"World"

17. restore

RESTORE 键 ttl 序列化值 [REPLACE] [ABSTTL] [IDLETIME秒] [FREQ频率]

可用版本> = 2.6.0。

时间复杂度： O（1）用于创建新密钥，O（N * M）用于重建序列化值，其中N是组成该值的Redis对象的数量，M是其平均大小。因此，对于较小的字符串值，时间复杂度为O（1）+ O（1 * M），其中M很小，因此简单地为O（1）。但是，对于排序的集合值，复杂度为O（N * M * log（N）），因为将值插入排序的集合中为O（log（N））。

创建与通过反序列化提供的序列化值（通过DUMP获得）而获得的值关联的键。

如果ttl为0，则创建密钥时不会有任何过期，否则将设置指定的过期时间（以毫秒为单位）。

如果使用了ABSTTL修饰符，ttl则应表示密钥将在其中终止的绝对Unix时间戳（以毫秒为单位）。（Redis 5.0或更高版本）。

为了驱逐目的，您可以使用IDLETIME或FREQ修饰符。有关更多信息，请参见“ 对象 ”（Redis 5.0或更高版本）。

key除非使用REPLACE修改器（Redis 3.0或更高版本），否则RESTORE在存在时将返回“目标键名称正忙”错误。

RESTORE检查RDB版本和数据校验和。如果它们不匹配，则返回错误。

返回值

简单字符串答复：命令成功返回OK。

实例

redis> DEL mykey
0
redis> RESTORE mykey 0 "
x17x17x00x00x00x12x00x00x00x03x00
                        x00xc0x01x00x04xc0x02x00x04xc0x03x00
                        xffx04x00u#<xc0;.xe9xdd"
OK
redis> TYPE mykey
list
redis> LRANGE mykey 0 -1
1) "1"
2) "2"
3) "3"

18. sort

排序键 [BY模式] [LIMIT偏移计数] [GET模式[GET模式…]] [ASC | DESC] [ALPHA] [存储目的地]

可用版本> = 1.0.0。

时间复杂度： O（N + M * log（M））其中N是列表中或要排序的元素的数量，M是返回的元素的数量。如果不对元素进行排序，则当前的复杂度为O（N），因为在下一发行版中将避免复制步骤。

返回或存储包含在元素列表，集或排序集合的key。默认情况下，排序是数字形式的，并且将元素的值进行比较以解释为双精度浮点数。这是最简单形式的SORT：

SORT mylist

假设mylist是一个数字列表，此命令将返回相同的列表，其元素从小到大排序。为了将数字从大到小排序，请使用DESC修饰符：

SORT mylist DESC

当mylist包含字符串值并且您要按字典顺序对其进行排序时，请使用ALPHA修饰符：

SORT mylist ALPHA

假设您正确设置了!LC_COLLATE环境变量，Redis可以识别UTF-8 。

可以使用LIMIT修饰符限制返回元素的数量。此修饰符采用offset参数（指定要跳过的元素数）和count参数（指定从处返回的元素数）offset。以下示例将从mylist元素0（offset从零开始）开始，返回的排序版本的10个元素：

SORT mylist LIMIT 0 10

几乎所有修饰符都可以一起使用。以下示例将返回按字典顺序降序排列的前5个元素：

SORT mylist LIMIT 0 5 ALPHA DESC

按外键排序

有时您想使用外部键作为权重对元素进行排序，而不是比较列表，集合或排序集中的实际元素。比方说，清单mylist中包含的元素1，2并3表示存储在对象的唯一ID object_1，object_2和object_3。当这些对象都有关联的存储的权重weight_1，weight_2并且weight_3，SORT可以指示使用这些权重的排序mylist与下面的语句：

SORT mylist BY weight_*

该BY选项采用一种模式（weight_*在此示例中等于），该模式用于生成用于排序的键。获得这些键名称代的第一次出现*在列表中的元件的实际值（1，2并且3在这个例子中）。

跳过元素排序

该BY选项还可以采用不存在的密钥，这将导致SORT跳过排序操作。如果要检索外部键（请参阅GET下面的选项）而没有排序的开销，这将很有用。

SORT mylist BY nosort

检索外部密钥

我们前面的示例仅返回排序后的ID。在某些情况下，以获得实际的对象，而不是它们的ID（更多有用的object_1，object_2和object_3）。可以使用以下命令基于列表，集合或排序集合中的元素检索外部键：

SORT mylist BY weight_* GET object_*

该GET选项可以多次使用，以获取原始列表，集合或排序集合的每个元素的更多键。

GET元素本身也可以使用特殊模式#：

SORT mylist BY weight_* GET object_* GET #

一个有趣的模式SORT ... STORE是将EXPIRE超时与结果键相关联，以便在SORT操作的结果可以缓存一段时间的应用程序中使用。其他客户端将使用缓存的列表，而不是为每个请求调用SORT。当密钥超时时，可以通过SORT ... STORE再次调用来创建缓存的更新版本。

请注意，为了正确实现此模式，重要的是避免多个客户端同时重建缓存。这里需要某种锁定（例如，使用SETNX）。

在`BY`和中使用哈希`GET`

可以通过以下语法对哈希字段使用BY和GET选项：

SORT mylist BY weight_*->fieldname GET object_*->fieldname

该字符串->用于将键名与哈希字段名分开。如上文所述替换键，并访问存储在结果键处的哈希值以检索指定的哈希字段。

返回值

数组回复：在不传递store选项的情况下，命令将返回已排序元素的列表。整数回复：store指定该选项后，命令将返回目标列表中已排序元素的数量。

19. touch

TOUCH key [key …]

可用版本 >= 3.2.1.

时间复杂度： O(N) where N is the number of keys that will be touched.

更改密钥的上次访问时间。如果密钥不存在，则忽略该密钥。

返回值

整数回复：触摸的键数。

实例

redis> SET key1 “Hello”
"OK"
redis> SET key2 “World”
"OK"
redis> TOUCH key1 key2
(integer) 2

20. ttl

命令格式：TTL key

自1.0.0版本可用

时间复杂度: O(1)

返回带有timeout的key的剩余生存时间。这个自查能力使Redis客户端能检查给定的key还能在数据库中存在多久。

在Redis 2.6 或之前的版本中，这个命令返回-1,如果key不存在或者key存在但没有关联超时。

自 Redis 2.8起，错误情况下的返回值变化如下：

-2 如果key不存在。
-1 如果key存在但没有关联超时。

也可以参考 PTTL 命令，它返回相同的信息以毫秒为单位（2.6或之后版本可用）。

返回值

　　整型Integer reply: 以秒为单位的TTL ，或一个表示错误的负数值。

例子

redis> SET mykey “Hello”
"OK"
redis> EXPIRE mykey 10
(integer) 1
redis> TTL mykey
(integer) 10

21. type

命令格式：TYPE key

自1.0.0版本起可用

时间复杂度: O(1)

以字符串的形式返回存储在 key 中的值的类型。可返回的不同类型是: string, list, set, zset,hash 和 stream。

返回值

简单字符串返回: key 的类型, 当键不存在的时候返回none。

例子

redis> SET key1 "value"
"OK"
redis> LPUSH key2 "value"
(integer) 1
redis> SADD key3 "value"
(integer) 1
redis> TYPE key1
"string"
redis> TYPE key2
"list"
redis> TYPE key3
"set"

22. unlink

UNLINK 键[键…]

可用版本> = 4.0.0。

时间复杂度：删除的每个键的大小为O（1）。然后，该命令O（N）在不同的线程中工作以回收内存，其中N是组成删除对象的分配数。

此命令与DEL非常相似：它删除指定的密钥。与DEL一样，如果密钥不存在，则将其忽略。但是，该命令在另一个线程中执行实际的内存回收，因此它不会阻塞，而DEL是。这是命令名称的来源：该命令只是将键与键空间断开链接。实际的删除将稍后异步发生。

返回值

整数回复：取消链接的键数。

实例

Redis> SET key1“你好”
“好”
Redis> SET key2“世界”
“好”
Redis> UNLINK键1键2键3
（整数）2

23. wait

等待 numreplicas 超时

可用版本> = 3.0.0。

时间复杂度： O（1）

该命令将阻塞当前客户端，直到所有先前的写命令均已成功传输并至少由指定数量的副本进行确认。如果达到了以毫秒为单位指定的超时时间，即使尚未达到指定数量的副本，命令也会返回。

在达到指定的副本数或达到超时的情况下，该命令将始终返回确认在WAIT命令之前发送的写命令的副本数。

几点评论：

当WAIT返回时，通过WAIT返回的副本数保证可以接收在当前连接上下文中发送的所有先前的写命令。
如果命令是作为MULTI事务的一部分发送的，则该命令不会阻塞，而只会尽快返回确认先前写入命令的副本数。
超时为0表示永远阻止。
由于WAIT返回在失败和成功情况下都达到的副本数，因此客户端应检查返回的值等于或大于其所需的复制级别。

一致性和等待

请注意，WAIT不会使Redis成为一个高度一致的存储：虽然同步复制是复制状态机的一部分，但并不是唯一需要的东西。但是，在Sentinel或Redis群集故障转移的情况下，WAIT可以提高实际数据的安全性。

具体来说，如果将给定的写入转移到一个或多个副本，则更有可能（但不能保证），如果主服务器出现故障，我们将能够在故障转移期间提升接收到该写入的副本：Sentinel和Redis Cluster将尽最大努力在可用副本集中提升最佳副本。

但是，这只是尽力而为，因此可能仍然会丢失同步复制到多个副本的写操作。

实施细节

由于引入了与副本的部分重新同步（PSYNC功能），Redis副本以其复制流中已处理的偏移量异步ping其主副本。有多种使用方法：

检测超时的副本。
断开连接后执行部分重新同步。
实施WAIT。

在WAIT实现的特定情况下，Redis会为每个客户端记住在给定客户端的上下文中执行给定写入命令时所产生的复制流的复制偏移。当WAIT被称为Redis的检查指定的副本数量已经承认了这一点偏移或更大的一个。

返回值

整数回复：该命令返回在当前连接的上下文中执行的所有写入所达到的副本数。

实例

> SET foo bar
OK
> WAIT 1 0
(integer) 1
> WAIT 2 1000
(integer) 1

在以下示例中，对WAIT的首次调用不使用超时，而是要求写入达到1个副本。它以成功返回。在第二次尝试中，我们设置了超时时间，并要求将写入复制到两个副本。由于只有一个副本，因此等待一秒钟后WAIT会解除阻止并返回1，因此副本数已达到。

转载： https://www.redis.com.cn/commands/wait