SORT — Redis 命令参考

SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

前往或保留给定列表、集合、有序集合 key 中经过排序的元素。

排序默认以数字也是对象，值被解释为双精度浮点数，然后进行比较。

最简单的 使用方式是 SORT key 和 SORT key DESC ：

假设 today_cost 列表保存了今日的支出金额，所以可以用 命令对它进行排序：

# 开销金额列表
redis> LPUSH today_cost 30 1.5 10 8
(integer) 4
# 排序
redis> SORT today_cost
1) "1.5"
2) "8"
3) "10"
4) "30"
# 逆序排序
redis 127.0.0.1:6379> SORT today_cost DESC
1) "30"
2) "10"
3) "8"
4) "1.5"

因为 命令默认排序对象为数字，当需要对字符串进行排序时，需要显式地在 命令以后添加 ALPHA 修饰符：

# 网址
redis> LPUSH website "www.reddit.com"
(integer) 1
redis> LPUSH website "www.slashdot.com"
(integer) 2
redis> LPUSH website "www.infoq.com"
(integer) 3
# 默认（按数字）排序
redis> SORT website
1) "www.infoq.com"
2) "www.slashdot.com"
3) "www.reddit.com"
# 按字符排序
redis> SORT website ALPHA
1) "www.infoq.com"
2) "www.reddit.com"
3) "www.slashdot.com"

因为功能正确地设置了 LC_COLLATE 环境变量的话，Redis能识别 UTF-8 编码。

排序之后回到元素的人数可以借助 LIMIT 修饰符进行限制，修饰符接受 offset 和 count 两个参数：

以上实例返回排序结果的前 5 个对象( offset 为 表示没有元素被跳过)。

# 添加测试数据，列表值为 1 指 10
redis 127.0.0.1:6379> RPUSH rank 1 3 5 7 9
(integer) 5
redis 127.0.0.1:6379> RPUSH rank 2 4 6 8 10
(integer) 10
# 返回列表中最小的 5 个值
redis 127.0.0.1:6379> SORT rank LIMIT 0 5
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"

可以组合使用多个修饰符。以下实例返回从大到小排序的前 5 个对象。

redis 127.0.0.1:6379> SORT rank LIMIT 0 5 DESC
1) "10"
2) "9"
3) "8"
4) "7"
5) "6"

可以使用内部 key 的数据也是权重，取代默认的直接对比键值的方法来进行排序。

假设现在有用户数据如下：

uiduser_name_{uid}user_level_{uid}

admin

peter

以上代码将数据输入到 Redis 中：

# admin
redis 127.0.0.1:6379> LPUSH uid 1
(integer) 1
redis 127.0.0.1:6379> SET user_name_1 admin
OK
redis 127.0.0.1:6379> SET user_level_1 9999
OK
# jack
redis 127.0.0.1:6379> LPUSH uid 2
(integer) 2
redis 127.0.0.1:6379> SET user_name_2 jack
OK
redis 127.0.0.1:6379> SET user_level_2 10
OK
# peter
redis 127.0.0.1:6379> LPUSH uid 3
(integer) 3
redis 127.0.0.1:6379> SET user_name_3 peter
OK
redis 127.0.0.1:6379> SET user_level_3 25
OK
# mary
redis 127.0.0.1:6379> LPUSH uid 4
(integer) 4
redis 127.0.0.1:6379> SET user_name_4 mary
OK
redis 127.0.0.1:6379> SET user_level_4 70
OK

默认状况下， SORT uid 直接按 uid 中的值排序：

redis 127.0.0.1:6379> SORT uid
1) "1"      # admin
2) "2"      # jack
3) "3"      # peter
4) "4"      # mary

通过使用 BY 选项，可以让 uid 按这些键的元素来排序。

比如说，以上代码让 uid 键根据 user_level_{uid} 的形状来排序：

redis 127.0.0.1:6379> SORT uid BY user_level_*
1) "2"      # jack , level = 10
2) "3"      # peter, level = 25
3) "4"      # mary, level = 70
4) "1"      # admin, level = 9999

user_level_* 是一个占位符，它先放入 uid 中的值，然后再用这个值来查找相应的键。

比如在对 uid 列表进行排序时，流程都会先放入 uid 的值 1 、 2 、 3 、 4sort 排序，然后使用 user_level_1 、 user_level_2 、 user_level_3 和 user_level_4 的值也是排序 uid 的指数。

使用 GET 选项，可以按照排序的结果来放入相应的函数。

比如说，以上代码先排序 uid ，再放入键 user_name_{uid} 的值：

redis 127.0.0.1:6379> SORT uid GET user_name_*
1) "admin"
2) "jack"
3) "peter"
4) "mary"

通过组合使用 BY 和 GET ，可以让排序结果以更直观的方法表明出来。

比如说，以上代码先按 user_level_{uid} 来排序 uid 列表，再放入相应的 user_name_{uid} 的值：

redis 127.0.0.1:6379> SORT uid BY user_level_* GET user_name_*
1) "jack"       # level = 10
2) "peter"      # level = 25
3) "mary"       # level = 70
4) "admin"      # level = 9999

现在的排序结果要比只使用 SORT uid BY user_level_* 要直观得多。

可以同样使用多个 GET 选项，获取多个内部键的值。

以上代码就按 uid 分别获取 user_level_{uid} 和 user_name_{uid} ：

redis 127.0.0.1:6379> SORT uid GET user_level_* GET user_name_*
1) "9999"       # level
2) "admin"      # name
3) "10"
4) "jack"
5) "25"
6) "peter"
7) "70"
8) "mary"

GET 有一个额外的取值规则，那就是 —— 可以用 # 获取被排序键的值。

以上代码就将 uid 的值、及其相应的 user_level_* 和 user_name_* 都离开为结果：

redis 127.0.0.1:6379> SORT uid GET # GET user_level_* GET user_name_*
1) "1"          # uid
2) "9999"       # level
3) "admin"      # name
4) "2"
5) "10"
6) "jack"
7) "3"
8) "25"
9) "peter"
10) "4"
11) "70"
12) "mary"

通过将一个不存在的键也是参数传给 BY 选项sort 排序，可以让 SORT 跳过排序操作，直接前往结果：

redis 127.0.0.1:6379> SORT uid BY not-exists-key
1) "4"
2) "3"
3) "2"
4) "1"

这样用法在单独使用时，没怎么实际用处。

但是，通过将这些用法和 GET 选项配合，就可以在不排序的现象下，获取多个内部键，相当于执行一个整合的获取操作（类似于 SQL 的 join 关键字）。

以上代码演示了，怎么在不引发排序的现象下，应用 SORT 、 BY 和 GET 获取多个内部键：

redis 127.0.0.1:6379> SORT uid BY not-exists-key GET # GET user_level_* GET user_name_*
1) "4"      # id
2) "70"     # level
3) "mary"   # name
4) "3"
5) "25"
6) "peter"
7) "2"
8) "10"
9) "jack"
10) "1"
11) "9999"
12) "admin"

除了可以将字符串键之外，哈希表也可以成为 GET 或 BY 选项的取值来使用。

比如说，对于后面给出的用户信息表：

uiduser_name_{uid}user_level_{uid}

admin

peter

我们可以不将用户的昵称和级别保存在 user_name_{uid} 和 user_level_{uid} 两个字符串键中，只是用一个带有 name 域和 level 域的哈希表 user_info_{uid} 来保留用户的昵称和级别信息：

redis 127.0.0.1:6379> HMSET user_info_1 name admin level 9999
OK
redis 127.0.0.1:6379> HMSET user_info_2 name jack level 10
OK
redis 127.0.0.1:6379> HMSET user_info_3 name peter level 25
OK
redis 127.0.0.1:6379> HMSET user_info_4 name mary level 70
OK

以后， BY 和 GET 选项都可以用 key->field 的文档来获取哈希表中的域的值，其中 key 表示哈希表键，而 field 则认为哈希表的域：

redis 127.0.0.1:6379> SORT uid BY user_info_*->level
1) "2"
2) "3"
3) "4"
4) "1"
redis 127.0.0.1:6379> SORT uid BY user_info_*->level GET user_info_*->name
1) "jack"
2) "peter"
3) "mary"
4) "admin"

默认状况下， 操作只是简单地离开排序结果，并不进行任何保存操作。

通过给 STORE 选项指定一个 key 参数，可以将排序结果保留到给定的键上。

因为被指定的 key 已存在，所以原有的值将被排序结果覆盖。

# 测试数据
redis 127.0.0.1:6379> RPUSH numbers 1 3 5 7 9
(integer) 5
redis 127.0.0.1:6379> RPUSH numbers 2 4 6 8 10
(integer) 10
redis 127.0.0.1:6379> LRANGE numbers 0 -1
1) "1"
2) "3"
3) "5"
4) "7"
5) "9"
6) "2"
7) "4"
8) "6"
9) "8"
10) "10"
redis 127.0.0.1:6379> SORT numbers STORE sorted-numbers
(integer) 10
# 排序后的结果
redis 127.0.0.1:6379> LRANGE sorted-numbers 0 -1
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"
10) "10"

可以通过将 命令的执行结果保留，并用 为结果设置生存时间，借此来形成一个 操作的结果缓存。

如此就可以避免对 操作的频繁调用：只有当结果集过期时，才需要再读取一次 操作。

如果，为了正确实现这一用法，你应该需要加锁以防止多个客户端同时进行缓存重建(也就是多个客户端，同一时间进行 操作，并保留为结果集)，具体参见 命令。

可用版本：

>= 1.0.0

时间复杂度：

O(N+M*log(M))， N 为要排序的页面或集合内的元素数目， M 为要回到的元素数目。

因为只是使用 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。

返回值：

没有使用 STORE 参数，回到页面方式的排序结果。

使用 STORE 参数，回到排序结果的元素数目。

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-118515-1.html