Redis命令参考(Commands Reference)中文翻译【Key部分】

http://redis.readthedocs.org/en/latest/

http://huangz.iteye.com/blog/1005601

进度

 

Redis的官方命令参考共10个部分(Keys, Strings, Hashes, Lists ...)。

计划每3-5天更新一部分，但不保证。

欢迎任何积极性意见和反馈@huangz1990

 

2011.4.17 Keys部分完成

2011.4.21 Strings部分完成

2011.4.29 Hash部分完成，Redis升级到2.2.5。

 

 

KEYS部分

DEL key [key2, ...]

 

    删除指定的key 

 

        复杂度：

            单个字符串O(1), 多个字符串（数量N）为O(N)。

            列表、集合、有序集合和哈希表(list，set，zset，hash)为O(M)，M为以上数据结构内的key数量。

 

        返回值：

            被移除key的数量。

 

Redis代码  

1. redis> mset name "huangz" age 20  # 一次set多个key-value  
2. OK  
3.   
4. redis> del name  
5. (integer) 1  
6.   
7. redis> del age fake_key  # fake_key不存在，只有age被删除  
8. (integer) 1  

 

 

KEYS pattern

 

    查找符合给定模式的key 

 

    h?llo命中hello, hallo and hxllo，等。

    h*llo命中hllo和heeeeello等。

    h[ae]llo命中hello和hallo，但不命中hillo。

 

    特殊符号用"\"隔开

 

        复杂度：

            O(N)，N为数据库中key的数量。

 

            KEYS的速度非常快，使用一般的手提电脑可以在40毫秒内扫描100万个key。

            但在一个大的数据库中频繁使用KEYS命令仍然可能造成性能问题，如果你需要从一个数据集中查找特定的key，你最好还是用集合（set）结构。

 

        返回值：

            符合给定模式的key列表。

 

Redis代码  

1. redis> mset one 1 two 2 three 3 four 4  
2. OK  
3.   
4. redis> keys *o*  
5. 1) "four"  
6. 2) "two"  
7. 3) "one"  
8.   
9. redis> keys t??  
10. 1) "two"  
11.   
12. redis> keys t[w]*  
13. 1) "two"  
14.   
15. redis> keys *  # 匹配数据库内所有key  
16. 1) "four"  
17. 2) "three"  
18. 3) "two"  
19. 4) "one"  

 

RANDOMKEY

 

    从当前数据库中随机返回一个key

 

        复杂度：

            O(1)

 

        返回值：

            一个key。

            当数据库为空时，返回nil。

 

Redis代码  

1. redis> mset fruit "apple" drink "beer" food "cookies"  
2. OK  
3.   
4. redis> randomkey  
5. "fruit"  
6.   
7. redis> randomkey  
8. "food"  
9.   
10. redis> flushdb # 删除当前数据库所有key  
11. OK  
12.   
13. redis> randomkey  
14. (nil)  

 

 

TTL key

 

    返回给定key的剩余生存时间。

 

        复杂度：

            O(1)

 

        返回值：

            剩余生存时间（以秒为单位）。

            当key不存在或过期时，返回-1 。

 

Redis代码  

1. redis> set name "huangz"  
2. OK  
3.   
4. redis> expire name 30  # 设置过期时间为30秒  
5. (integer) 1  
6.   
7. redis> get name  
8. "huangz"  
9.   
10. redis> ttl name  
11. (integer) 25  
12.   
13. redis> get name  
14. "huangz"  
15.   
16. redis> ttl name  
17. (integer) 15  
18.   
19. redis> ttl name  # 30秒过去，name过期  
20. (integer) -1  
21.   
22. redis> get name  
23. (nil)  

 

EXISTS key

 

    检查给定key是否存在。

 

        复杂度：

            O(1)

 

        返回值：

            若key存在，返回1。

            不存在则返回0 。

 

Redis代码  

1. redis> set db "redis"  
2. OK  
3.   
4. redis> exists db  # key存在  
5. (integer) 1  
6.   
7. redis> del db  
8. (integer) 1  
9.   
10. redis> exists db  # key不存在  
11. (integer) 0  

 

MOVE key db

 

    将当前数据库（默认为0）的key移动到指定的数据库db。

    如果当前数据库（源数据库）和指定数据库（目标数据库）有相同名字的指定key，或者key不存在于当前数据库，那么MOVE没有任何效果。因此，也可以利用这一特性，将MOVE当作锁（locking）。

 

        复杂度：

            O(1)

 

        返回值：

            移动成功返回1。

            失败则返回0 。

 

Redis代码  

1. redis> SELECT 0  # redis默认使用数据库0，为了清晰起见，这里再显式指定一次。  
2. OK  
3.   
4. redis> SET song "secret base - Zone"  
5. OK  
6.   
7. redis> MOVE song 1  # 将song移动到数据库1  
8. (integer) 1  
9.   
10. redis> EXISTS song  # song已经被移走  
11. (integer) 0  
12.   
13. redis> SELECT 1  # 使用数据库1  
14. OK  
15.   
16. redis:1> EXISTS song  # 证实song被移到了数据库1（注意命令操作符变成了"redis:1"，表明正在使用数据库1）  
17. (integer) 1  
18.    
19.   
20. # 当key不存在的时候   
21.   
22. redis:1> EXISTS fake_key    
23. (integer) 0  
24.   
25. redis:1> MOVE fake_key 0  # 试图从数据库1移动一个不存在的key到数据库0，失败  
26. (integer) 0  
27.   
28. redis:1> select 0  # 使用数据库0  
29. OK  
30.   
31. redis> EXISTS fake_key  # 证实fake_key不存在  
32. (integer) 0  
33.   
34.   
35. # 当源数据库和目标数据库有相同的key时  
36.   
37. redis> SELECT 0  # 使用数据库0  
38. OK  
39.   
40. redis> SET favorite_fruit "banana"  
41. OK  
42.   
43. redis> SELECT 1  # 使用数据库1  
44. OK  
45. redis:1> SET favorite_fruit "apple"  
46. OK  
47.   
48. redis:1> SELECT 0  # 使用数据库0，并试图将favorite_fruit移动到数据库1  
49. OK  
50.   
51. redis> MOVE favorite_fruit 1  # 因为两个数据库有相同的key，MOVE失败  
52. (integer) 0  
53.   
54. redis> GET favorite_fruit  # 数据库0的favorite_fruit没变  
55. "banana"  
56.   
57. redis> SELECT 1  
58. OK  
59.   
60. redis:1> GET favorite_fruit  # 数据库1的favorite_fruit也是  
61. "apple"  

  

RENAME key newkey

    

    将key改名为newkey。

    当key和newkey相同或者key不存在时，返回一个错误。

    当newkey已经存在时，RENAME将覆盖之。

        复杂度：

            O(1)

        返回值：

            成功时提示OK。

            失败时候返回一个错误。

Redis代码  

1. redis:1> SET message "hello world"  
2. OK  
3.   
4. redis:1> RENAME message greeting  
5. OK  
6.   
7. redis:1> EXISTS message  # message不复存在  
8. (integer) 0  
9.   
10. redis:1> EXISTS greeting  # greeting取而代之  
11. (integer) 1  
12.   
13.   
14. # 当key不存在时，返回错误  
15.   
16. redis:1> RENAME fake_key never_exists  
17. (error) ERR no such key  
18.   
19.   
20. # 当newkey已存在时，RENAME会覆盖旧newkey  
21.   
22. redis:1> SET pc "lenovo"  
23. OK  
24.   
25. redis:1> SET personal_computer "dell"  
26. OK  
27.   
28. redis:1> RENAME pc personal_computer  
29. OK  
30.   
31. redis:1> GET pc  
32. (nil)  
33.   
34. redis:1> GET personal_computer  # dell“没有”了  
35. "lenovo"  

 

TYPE key

    返回key中储存的value（值）的类型。

        复杂度：

            O(1)

        返回值：

            字符串，列表，集合，有序集合和哈希表(string, list, set, zset, hash)。

Redis代码  

1. redis:1> SET weather "sunny"  # 构建一个字符串  
2. OK  
3.   
4. redis:1> TYPE weather   
5. string  
6.   
7. redis:1> LPUSH book_list "programming in scala"  # 构建一个列表  
8. (integer) 1  
9.   
10. redis:1> LPUSH book_list "algorithms in C"  
11. (integer) 2  
12.   
13. redis:1> TYPE book_list   
14. list  
15.   
16. redis:1> SADD pat "dog"  # 构建一个集合  
17. (integer) 1  
18.   
19. redis:1> TYPE pat  
20. set  

 

 

EXPIRE key seconds

    为给定key设置过期时间。

    当key过期时，它会被自动删除。

    在Redis的术语中，带有过期时间的key称为可挥发的(volatile) 。

    

    在版本低于2.1.3版本的Redis中，已存在的过期时间不可覆盖。

    从2.1.3开始，key的过期时间可以被更新，也可以被移除（见PERSIST命令）。

        复杂度：

            O(1)

        返回值：

            设置成功返回1。

            当key不存在或者不能为key设置过期时间（比如在低于2.1.3中你尝试更新key的过期时间），返回0 。

Redis代码  

1. redis> SET cache_page "www.twitter.com/huangz1990"  
2. OK  
3.   
4. redis> EXPIRE cache_page 30  # 设置30秒后过期  
5. (integer) 1  
6.   
7. redis> TTL cache_page  
8. (integer) 24  
9.   
10. redis> EXPIRE cache_page 30000  # 更新过期时间，30000秒  
11. (integer) 1  
12.   
13. redis> TTL cache_page  
14. (integer) 29996  

 

OBJECT subcommand [arguments [arguments]]

    OBJECT命令允许从内部察看给定key的Redis对象。

    它通常用在除错(debugging)或者了解为了节省空间而对key使用特殊编码的情况。

    当将Redis用作缓存程序时，你也可以通过OBJECT命令中的信息，决定key的驱逐策略（eviction policies）。

    OBJECT命令有多个子命令：

        OBJECT REFCOUNT <key> 返回给定key引用value的次数。此命令主要用于除错。

        OBJECT ENCODING <key> 返回给定key的value所使用的内部表示(representation)。

        OBJECT IDLETIME <key> 返回给定key自储存以来的空转时间（idle， 没有被读取也没有被写入），以秒为单位。

    对象可以以多种方式编码：

        字符串可以被编码为raw（一般字符串）或int（用字符串表示64位数字是为了节约空间）。

        列表可以被编码为ziplist或linkedlist。ziplist是为节约小(small size)列表空间而作的特殊表示。

        集合可以被编码为intset或者hashtable。intset只储存数字的小集合的特殊表示。

        哈希表可以编码为zipmap或者hashtable。zipmap是小哈希表的特殊表示。

        有序集合可以被编码为ziplist或者skiplist格式。ziplist用于表示小的有序集合，而skiplist则用于表示任何大小的有序集合。

        

        假如你做了什么让Redis没办法再使用节省空间的编码时（比如将一个只有1个元素的集合扩展为一个有100万个元素的集合），特殊表示类型（specially encoded types）会自动转换成通用类型（general type）。

        

        复杂度：

            O(1)

        返回值：

            REFCOUNT和IDLETIME返回数字。

            ENCODING返回相应的编码类型。

Redis代码  

1. redis> SET game "COD"  # 一个字符串  
2. OK  
3.   
4. redis> OBJECT REFCOUNT game  # 只有一个引用  
5. (integer) 1  
6.   
7. redis> OBJECT IDLETIME game  # 空转时间  
8. (integer) 90  
9.   
10. redis> GET game  # 提取game， 让它处于活跃（active）状态  
11. "COD"  
12.   
13. redis> OBJECT IDLETIME game  # 不再处于空转  
14. (integer) 0  
15.   
16. redis> OBJECT ENCODING game  # 字符串的编码方式  
17. "raw"  
18.   
19. redis> SET phone 15820123123  # 长的数字被编码为字符串  
20. OK  
21.   
22. redis> OBJECT ENCODING phone  
23. "raw"  
24.   
25. redis> SET age 20  # 短数字被编码为int  
26. OK  
27.   
28. redis> OBJECT ENCODING age  
29. "int"  

 

RENAMEX key newkey

    当newkey 不存在时，将key改为newkey

    出错的情况和RENAME一样（key不存在时报错）。

    

        复杂度：

            O(1)

        返回值：

            修改成功，返回1。

            若newkey已经存在，返回0。

Redis代码  

1. # newkey不存在，成功  
2.   
3. redis> SET player "MPlyaer"  
4. OK  
5.   
6. redis> EXISTS best_player  
7. (integer) 0  
8.   
9. redis> RENAMENX player best_player  
10. (integer) 1  
11.   
12.   
13. # newkey存在时，失败  
14.   
15. redis> SET animal "bear"  
16. OK  
17.   
18. redis> SET favorite_animal "butterfly"  
19. OK  
20.   
21. redis> RENAMENX animal favorite_animal  
22. (integer) 0  
23.   
24. redis> get animal  
25. "bear"  
26.   
27. redis> get favorite_animal  
28. "butterfly"  

 

EXPIREAT key timestamp

   

    EXPIREAT的作用和EXPIRE一样，不同在于EXPIREAT接受的时间参数是unix timestamp。

        复杂度：

            O(1)

        返回值：

            过期时间设置成功，返回1。

            key不存在或没办法设置过期时间，返回0

Redis代码  

1. redis> SET live_man "fake person"  
2. OK  
3.   
4. redis> EXPIREAT live_man 2000000000  # unix steamp DATE: 05 / 17 / 33 @ 10:33:20pm EST  
5. (integer) 1  
6.   
7. redis> TTL live_man  
8. (integer) 697061482  

 

PERSIST key

    移除给定key的过期时间。

        复杂度：

            O(1)

        返回值：

            移除成功，返回1。

            key不存在或key没有设置过期时间，返回0。

Redis代码  

1. redis> SET time_to_say_goodbye "oh, please no delete me"  
2. OK  
3.   
4. redis> EXPIRE time_to_say_goodbye 300  
5. (integer) 1  
6.   
7. redis> TTL time_to_say_goodbye  
8. (integer) 293  
9.   
10. redis> PERSIST time_to_say_goodbye  
11. (integer) 1  
12.   
13. redis> TTL time_to_say_goodbye  # 移除成功  
14. (integer) -1  

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

    返回或保存给定列表、集合、有序集合key中的(经过排序的）元素。

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

     一般SORT方式

    SORT [data set]

 

    假设today_cost是一个保存数字的列表，SORT命令会返回该列表值的从小到大排序结果。

Redis代码  

1. redis> LPUSH today_cost 30  
2. (integer) 1  
3.   
4. redis> LPUSH today_cost 1.5  
5. (integer) 2  
6.   
7. redis> LPUSH today_cost 10  
8. (integer) 3  
9.   
10. redis> LPUSH today_cost 8  
11. (integer) 4  
12.   
13. redis> SORT today_cost  
14. 1) "1.5"  
15. 2) "8"  
16. 3) "10"  
17. 4) "30"  

 

    当数据集中保存的是字符串值时，你可以用ALPHA修饰符（modifier）进行排序。

Redis代码  

1. redis> LPUSH website "www.reddit.com"  
2. (integer) 1  
3. redis> LPUSH website "www.slashdot.com"  
4. (integer) 2  
5. redis> LPUSH website "www.infoq.com"  
6. (integer) 3  
7.   
8. # 默认排序  
9.   
10. redis> SORT website  
11. 1) "www.infoq.com"  
12. 2) "www.slashdot.com"  
13. 3) "www.reddit.com"  
14.   
15. # 按字符排序  
16.   
17. redis> SORT website ALPHA  
18. 1) "www.infoq.com"  
19. 2) "www.reddit.com"  
20. 3) "www.slashdot.com"  

 

    如果你正确设置了!LC_COLLATE环境变量的话，Redis能识别UTF-8编码。

    排序之后返回的元素数量可以通过LIMIT修饰符进行限制。LIMIT修饰符接受两个参数：offset和count。

    offset指定要跳过的元素数量，count指定跳过offset指定的元素之后，要返回多少个对象。

    以下例子返回排序结果的前5个对象（offset为0表示没有元素被跳过）。

Redis代码  

1. redis> LPUSH rank 30  
2. (integer) 1  
3. redis> LPUSH rank 56  
4. (integer) 2  
5. redis> LPUSH rank 42  
6. (integer) 3  
7. redis> LPUSH rank 22  
8. (integer) 4  
9. redis> LPUSH rank 0  
10. (integer) 5  
11. redis> LPUSH rank 11  
12. (integer) 6  
13. redis> LPUSH rank 32  
14. (integer) 7  
15. redis> LPUSH rank 67  
16. (integer) 8  
17. redis> LPUSH rank 50  
18. (integer) 9  
19. redis> LPUSH rank 44  
20. (integer) 10  
21. redis> LPUSH rank 55  
22. (integer) 11  
23.   
24. redis> SORT rank LIMIT 0 5  
25. 1) "0"  
26. 2) "11"  
27. 3) "22"  
28. 4) "30"  
29. 5) "32"  

  

    修饰符可以组合使用。以下例子返回降序（从大到小）的前5个对象。

Redis代码  

1. redis> SORT rank LIMIT 0 5 DESC  
2. 1) "78"  
3. 2) "67"  
4. 3) "56"  
5. 4) "55"  
6. 5) "50"  

     使用外部key进行排序

    有时候你会希望使用外部的key作为权重来比较元素，代替默认的对比方法。

    假设现在有以下用户（user）数据：

    id        |  name    |  level

    ---------------------------------------

    1         |  admin    |  9999

    2         |  huangz   | 10 

    59230     |  jack      | 3   

    222       |  hacker    |  9999

    id数据保存在user_id列表中

    name数据保存在user_name_{id}的key中

    level数据保存在user_level_{id}的key中

Redis代码  

1. # admin  
2.   
3. redis> LPUSH user_id 1  
4. (integer) 1  
5. redis> SET user_name_1 admin  
6. OK  
7. redis> SET user_level_1 9999  
8. OK  
9.   
10. # huangz  
11.   
12. redis> LPUSH user_id 2  
13. (integer) 2  
14. redis> SET user_name_2 huangz  
15. OK  
16. redis> SET user_level_2 10  
17. OK  
18.   
19. # jack  
20.   
21. redis> LPUSH user_id 59230  
22. (integer) 3  
23. redis> SET user_name_59230 jack  
24. OK  
25. redis> SET user_level_59230 3  
26. OK  
27.   
28. # hacker  
29.   
30. redis> LPUSH user_id 222  
31. (integer) 4  
32. redis> SET user_name_222 hacker  
33. OK  
34. redis> SET user_level_222 9999  
35. OK  

 

    如果希望按level从大到小排序user_id，可以使用BY操作：

Redis代码  

1. redis> SORT user_id BY user_level_* DESC  
2. 1) "222"  
3. 2) "1"  
4. 3) "2"  
5. 4) "59230"  

 

    但是有时候只是返回相应的id没有什么用，你可能更希望排序后返回id对应的用户名，这样更友好一点，GET操作可以做到：

Redis代码  

1. redis> SORT user_id BY user_level_* DESC GET user_name_*  
2. 1) "hacker"  
3. 2) "admin"  
4. 3) "huangz"  
5. 4) "jack"  

 

    可以多次地、 有序地使用GET操作来获取更多外部key。

    比如你不但希望获取用户名，还希望连用户的密码也一并列出，可以使用以下命令：

Redis代码  

1. # 先添加一些测试数据  
2.   
3. redis> SET user_password_222 "hey,im in"  
4. OK  
5. redis> SET user_password_1 "a_long_long_password"  
6. OK  
7. redis> SET user_password_2 "nobodyknows"  
8. OK  
9. redis> SET user_password_59230 "jack201022"  
10. OK  
11.   
12. # 获取name和password  
13.   
14. redis> SORT user_id BY user_level_# DESC GET user_name_* GET user_password_*  
15. 1) "hacker"       # 用户名  
16. 2) "hey,im in"    # 密码  
17. 3) "jack"  
18. 4) "jack201022"  
19. 5) "huangz"  
20. 6) "nobodyknows"  
21. 7) "admin"  
22. 8) "a_long_long_password"  
23.   
24. # 注意GET操作是有序的，GET user_name_* GET user_password_* 和 GET user_password_* GET user_name_*返回的结果位置不同  
25.   
26. redis> SORT user_id BY user_level_# DESC GET user_password_* GET user_name_*  
27. 1) "hey,im in"    # 密码  
28. 2) "hacker"       # 用户名  
29. 3) "jack201022"  
30. 4) "jack"  
31. 5) "nobodyknows"  
32. 6) "huangz"  
33. 7) "a_long_long_password"  
34. 8) "admin"  

 

    GET还有一个特殊的规则——"GET #"，用于获取被排序对象（我们这里的例子是user_id)的当前元素。

    比如你希望user_id按level排序，还要列出id、name和password，可以使用以下命令：

Redis代码  

1. redis> SORT user_id BY user_level_* DESC GET # GET user_name_* GET user_password_*  
2.  1) "222"            # id  
3.  2) "hacker"       # name  
4.  3) "hey,im in"    # password  
5.  4) "1"  
6.  5) "admin"  
7.  6) "a_long_long_password"  
8.  7) "2"  
9.  8) "huangz"  
10.  9) "nobodyknows"  
11. 10) "59230"  
12. 11) "jack"  
13. 12) "jack201022"  

 

     只获取对象而不排序

    

    BY修饰符可以将一个不存在的key当作权重，让SORT跳过排序操作。

    该方法用于你 希望获取外部对象而又不希望引起排序开销时使用。(这听上去有点像关系数据库的外键？）

Redis代码  

1. # 确保fake_key不存在  
2.   
3. redis> EXISTS fake_key  
4. (integer) 0  
5.   
6. # 以fake_key作BY参数，不排序，只GET name 和 GET password  
7.   
8. redis> SORT user_id BY fake_key GET # GET user_name_* GET user_password_*  
9.  1) "222"  
10.  2) "hacker"  
11.  3) "hey,im in"  
12.  4) "59230"  
13.  5) "jack"  
14.  6) "jack201022"  
15.  7) "2"  
16.  8) "huangz"  
17.  9) "nobodyknows"  
18. 10) "1"  
19. 11) "admin"  
20. 12) "a_long_long_password"  

 

     保存排序结果

    默认情况下，SORT操作只是简单地返回排序结果，如果你希望保存排序结果，可以用STORE操作指定一个key，排序结果将以列表的形式被保存。（若指定key已存在，则覆盖。）

Redis代码  

1. redis> EXISTS user_info_sorted_by_level  # 确保指定key不存在  
2. (integer) 0  
3.   
4. redis> SORT user_id BY user_level_* GET # GET user_name_* GET user_password_* STORE user_info_sorted_by_level    # 排序  
5. (integer) 12  # 显示有12条结果被保存了  
6.   
7. redis> LRANGE user_info_sorted_by_level 0 11  # 查看排序结果  
8.  1) "59230"  
9.  2) "jack"  
10.  3) "jack201022"  
11.  4) "2"  
12.  5) "huangz"  
13.  6) "nobodyknows"  
14.  7) "222"  
15.  8) "hacker"  
16.  9) "hey,im in"  
17. 10) "1"  
18. 11) "admin"  
19. 12) "a_long_long_password"  

 

    一个有趣的用法是将SORT结果保存，用EXPIRE为结果集设置过期时间，这样结果集就成了SORT操作的一个缓存。

    这样就不必频繁地调用SORT操作了，只有当结果集过期时，才需要再调用一次SORT操作。

    有时候为了正确实现这一用法，你可能需要加锁以避免多个客户端同时进行缓存重建（也就是多个客户端，同一时间进行SORT操作，并保存为结果集），具体参见SETNX命令。

     在GET和BY中使用哈希表

    在SORT操作中，可以使用哈希表特有的语法，对其使用GET和BY。

Redis代码  

1. # 假设现在我们的用户表新增了一个serial项来为作为每个用户的序列号  
2. #  序列号以哈希表的形式保存在serial哈希域内。  
3.   
4. redis> HMSET serial 1 23131283 2 23810573 222 502342349 59230 2435829758  
5. OK  
6.   
7. # 我们希望以比较serial中的大小来作为排序user_id的方式  
8.   
9. redis> SORT user_id BY *->serial  
10. 1) "222"  
11. 2) "59230"  
12. 3) "2"  
13. 4) "1"  

 

    字符串"->"用于分割关键字（key name）和索引域（hash field），格式为"key->field"。

    除此之外，哈希表的BY和GET操作和上面介绍的其他数据结构（列表、集合、有序集合）没有什么不同。

        复杂度：

            O(N+M*log(M))，N为要排序的列表或集合内的元素数量，M为要返回的元素数量。

   

        返回值：

            没有使用STORE参数，返回列表形式的排序结果。

            使用STORE参数，返回排序结果的元素数量。