redis 5大数据类型(以及通用型)之查询数据命令使用

redis 命令使用详情介绍

具体命令：
	类型：
	通用的（Generic）    4个
	字符串类型（String）    5个
	哈希（Hash）    7个
	列表（List）    4个
	集合（Set）    7个
	有序集合（Sorted set）    8个
针对这6个类型做了整理，目前共整理了 35 个命令

一、 通用的（Generic）  
	1. EXISTS 命令  可用版本：>= 1.0.0
	EXISTS 命令用于检查给定 key 是否存在。
	返回值：
		若 key 存在返回 1 ，否则返回 0 。
		基本语法：
			> EXISTS KEY_NAME
				例：
				redis 127.0.0.1:6379> EXISTS runoob-new-key
				(integer) 0
				现在我们创建一个名为 runoob-new-key 的键并赋值，再使用 EXISTS 命令。
				redis 127.0.0.1:6379> set runoob-new-key newkey
				OK
				redis 127.0.0.1:6379> EXISTS runoob-new-key
				(integer) 1

	2. Keys 命令  可用版本：>= 1.0.0
	Keys 命令用于查找所有符合给定模式 pattern 的 key 。
	返回值:
		符合给定模式的 key 列表 (Array)。
	基本语法：
		> KEYS PATTERN
			例：
			首先创建一些 key，并赋上对应值：
			redis> SET runoob1 redis
			OK
			redis> SET runoob2 mysql
			OK
			redis> SET runoob3 mongodb
			OK
			查找以 runoob 为开头的 key：
			redis> KEYS runoob*
			1) "runoob3"
			2) "runoob1"
			3) "runoob2"
			获取 redis 中所有的 key 可用使用 *。
			redis> KEYS *
			1) "runoob3"
			2) "runoob1"
			3) "runoob2"

	3. RANDOMKEY 命令  可用版本：>= 1.0.0
	RANDOMKEY  从当前数据库中随机返回一个 key 。
		返回值：
			当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil （windows 系统返回 null）。
		基本语法：
			> RANDOMKEY 
				例：
				# 数据库不为空
				redis> MSET fruit "apple" drink "beer" food "cookies"   # 设置多个 key
				OK
				redis> RANDOMKEY
				"fruit"
				redis> RANDOMKEY
				"food"
				redis> KEYS *    # 查看数据库内所有key，证明 RANDOMKEY 并不删除 key
				1) "food"
				2) "drink"
				3) "fruit"
				# 数据库为空
				redis> FLUSHDB  # 删除当前数据库所有 key
				OK
				redis> RANDOMKEY
				(nil)

	4. Type 命令  可用版本：>= 1.0.0
	TYPE key  返回 key 所储存的值的类型。
		返回值：
			返回 key 的数据类型，数据类型有：
				none (key不存在)
				string (字符串)
				list (列表)
				set (集合)
				zset (有序集)
				hash (哈希表)
		基本语法：
			> TYPE KEY_NAME 
				例：
				# 字符串
				redis> SET weather "sunny"
				OK
				redis> TYPE weather
				string
				# 列表
				redis> LPUSH book_list "programming in scala"
				(integer) 1
				redis> TYPE book_list
				list
				# 集合
				redis> SADD pat "dog"
				(integer) 1
				redis> TYPE pat
				set

二、 字符串类型（String）  
	字符串数据类型的相关命令用于管理 redis 字符串值，基本语法： > COMMAND KEY_NAME

	1. get  可用版本：>= 1.0.0
	get key
	Get 命令用于获取指定 key 的值。如果 key 不存在，返回 nil 。如果key 储存的值不是字符串类型，返回一个错误。
	返回值：
		返回 key 的值，如果 key 不存在时，返回 nil。 如果 key 不是字符串类型，那么返回一个错误。
	基本语法：
		> GET KEY_NAME
			例：
			# 对不存在的 key 或字符串类型 key 进行 GET
			> GET ismykey
			(nil)
			> SET ismykey hello
			OK
			> GET ismykey
			"hello"

			# 对不是字符串类型的 key 进行 GET
			> DEL db
			(integer) 1
			> LPUSH db redis mongodb mysql
			(integer) 3
			> GET db
			(error) ERR Operation against a key holding the wrong kind of value

	2. Getrange   可用版本：>= 2.4.0
	GETRANGE key start end
	Getrange 命令用于获取存储在指定 key 中字符串的子字符串。字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
	返回值：
		截取得到的子字符串。
	基本语法：
		>GETRANGE KEY_NAME start end
			例：
			> SET mykey "This is a string"
			"OK"
			> GETRANGE mykey 0 3
			"This"
			> GETRANGE mykey -3 -1
			"ing"
			> GETRANGE mykey 0 -1
			"This is a string"
			> GETRANGE mykey 10 100
			"string"

	3. Getset   可用版本：>=1.0.0
	GETSET key value
	Getset 命令用于设置指定 key 的值，并返回 key 的旧值。（返回给定 key 的旧值。 当 key 没有旧值时，即 key 不存在时，返回 nil 。当key存在时，返回旧的值，但此时已经将新值设定为key。 当 key 存在但不是字符串类型时，返回一个错误）
	返回值：
		返回给定 key 的旧值。 当 key 没有旧值时，即 key 不存在时，返回 nil 。
	基本语法：
		>GETSET KEY_NAME VALUE
			例：
			> GETSET db mongodb    # 没有旧值，返回 nil ，此时mongodb将被设定为key值
			(nil)
			> GET db
			"mongodb"
			> GETSET db redis      # 返回旧值 mongodb，此时Redis将被设定为key值
			"mongodb"
			> GET db
			"redis"

	4. GETBIT   可用版本:>= 2.2.0
	GETBIT key offset
	Getbit 命令用于对 key 所储存的字符串值，获取指定偏移量上的位(bit)。
	返回值：
		返回：字符串值指定偏移量上的位(bit)。当偏移量 OFFSET 比字符串值的长度大，或者 key 不存在时，返回 0 。
	基本语法：
		> GETBIT KEY_NAME OFFSET
			例：
			# 对不存在的 key 或者不存在的 offset 进行 GETBIT， 返回 0
			> EXISTS bit
			(integer) 0
			> GETBIT bit 10086
			(integer) 0

			# 对已存在的 offset 进行 GETBIT
			> SETBIT bit 10086 1
			(integer) 0
			> GETBIT bit 10086
			(integer) 1

	5. Mget  可用版本：>=1.0.0
	MGET key1 [key2..]
	Mget 命令返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。
	返回值：
		一个包含所有给定 key 的值的列表。
	基本语法：
		> MGET KEY1 KEY2 .. KEYN
			例：
			> SET key1 "hello"
			OK
			> SET key2 "world"
			OK
			> MGET key1 key2 someOtherKey
			1) "Hello"
			2) "World"
			3) (nil)

三、 哈希（Hash）   
	Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。
Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。

	1. Hexists 命令  可用版本：>= 2.0.0
	HEXISTS key field
	Redis Hexists 命令用于查看哈希表的指定字段是否存在。 
	返回值：
		如果哈希表含有给定字段，返回 1 。 如果哈希表不含有给定字段，或 key 不存在，返回 0 。
	基本语法：
		> HEXISTS KEY_NAME FIELD_NAME 
			例：
			> HSET myhash field1 "foo"
			(integer) 1
			> HEXISTS myhash field1
			(integer) 1
			> HEXISTS myhash field2
			(integer) 0

	2. HGET 命令  可用版本：>= 2.0.0
	HGET key field  获取存储在哈希表中指定字段的值。
		Hget 命令用于返回哈希表中指定字段的值。
		返回值：
			返回给定字段的值。如果给定的字段或 key 不存在时，返回 nil 。
		基本语法：
		> HGET KEY_NAME FIELD_NAME 
			例：
			> HSET myhash field1 "foo"
			(integer) 1
			> HGET myhash field1
			"foo"
			> HGET myhash field2
			(nil)

	3. Hgetall 命令  可用版本：>= 2.0.0
	HGETALL key  获取在哈希表中指定 key 的所有字段和值
		Hgetall  命令用于返回哈希表中，所有的字段和值。在返回值里，紧跟每个字段名(field name)之后是字段的值(value)，所以返回值的长度是哈希表大小的两倍。
		返回值：
			以列表形式返回哈希表的字段及字段值。 若 key 不存在，返回空列表。
		基本语法：
			> HGETALL KEY_NAME 
				例：
				> HSET myhash field1 "Hello"
				(integer) 1
				> HSET myhash field2 "World"
				(integer) 1
				> HGETALL myhash
				1) "field1"
				2) "Hello"
				3) "field2"
				4) "World"
				
	4. HKEYS 命令  可用版本：>= 2.0.0
	HKEYS key  获取所有哈希表中的字段
		Hkeys 命令用于获取哈希表中的所有域（field）。
		返回值：
			包含哈希表中所有域（field）列表。 当 key 不存在时，返回一个空列表。
		基本语法：
			> HKEYS key 
				例：
				> HSET myhash field1 "Hello"
				(integer) 1
				> HSET myhash field2 "World"
				(integer) 1
				> HKEYS myhash
				1) "field1"
				2) "field2"

	5. Hlen 命令  可用版本：>= 2.0.0
	HLEN key 获取哈希表中字段的数量
		Hlen 命令用于获取哈希表中字段的数量。(查询数据的总量) (hget 查询集群的每个ID的数据情况)
		返回值：
			哈希表中字段的数量。 当 key 不存在时，返回 0 。
		基本语法：
			> HLEN KEY_NAME 
				例：
				> HSET myhash field1 "Hello"
				(integer) 1
				> HSET myhash field2 "World"
				(integer) 1
				> HLEN myhash
				(integer) 2

	6. Hmget 命令   可用版本：>= 2.0.0
	HMGET key field1 [field2]  获取所有给定字段的值
		Hmget 命令用于返回哈希表中，一个或多个给定字段的值。如果指定的字段不存在于哈希表，那么返回一个 nil 值。
		返回值：
			一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样。
		基本语法：
			> HMGET KEY_NAME FIELD1...FIELDN 
				例：
				> HSET myhash field1 "Hello"
				(integer) 1
				> HSET myhash field2 "World"
				(integer) 1
				> HMGET myhash field1 field2 nofield
				1) "Hello"
				2) "World"
				3) (nil)

	7. Hvals 命令   可用版本：>= 2.0.0
	HVALS key  获取哈希表中所有值。
		Hvals 命令返回哈希表所有的值。
		返回值：
			一个包含哈希表中所有值的列表。 当 key 不存在时，返回一个空表。
		基本语法：
			> HVALS key
				例：
				> HSET myhash field1 "Hello"
				(integer) 1
				> HSET myhash field2 "World"
				(integer) 1
				> HVALS myhash
				1) "Hello"
				2) "World"

四、列表（List）   
    Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

	1. Lindex 命令  可用版本：>= 1.0.0
	LINDEX key index  通过索引获取列表中的元素
	 	Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素，-2 表示列表的倒数第二个元素，以此类推。
	 	返回值：
			列表中下标为指定索引值的元素。 如果指定索引值不在列表的区间范围内，返回 nil 。
		基本语法：
			> LINDEX KEY_NAME INDEX_POSITION 
				例：
				> LPUSH mylist "World"
				(integer) 1
				> LPUSH mylist "Hello"
				(integer) 2
				> LINDEX mylist 0
				"Hello"
				> LINDEX mylist -1
				"World"
				> LINDEX mylist 3
				(nil)

	2. Llen 命令  可用版本：>=1.0.0
	LLEN key  获取列表长度
		Llen 命令用于返回列表的长度。 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误。
		返回值：
			列表的长度。
		基本语法：
			> LLEN KEY_NAME 
				例：
				> LPUSH mylist "World"
				(integer) 1
				> LPUSH mylist "Hello"
				(integer) 2
				> LLEN mylist
				(integer) 2

	3. Lrange 命令   可用版本：>= 1.0.0
	LRANGE key start stop  获取列表指定范围内的元素
		Lrange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。 也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
		返回值：
			一个列表，包含指定区间内的元素。
		基本语法：
			> LRANGE KEY_NAME START END
				例：
				> RPUSH mylist "one"
				(integer) 1
				> RPUSH mylist "two"
				(integer) 2
				> RPUSH mylist "three"
				(integer) 3
				> LRANGE mylist 0 0
				1) "one"
				> LRANGE mylist -3 2
				1) "one"
				2) "two"
				3) "three"
				> LRANGE mylist -100 100
				1) "one"
				2) "two"
				3) "three"
				> LRANGE mylist 5 10
				(empty array)

	4. Lpop 命令  可用版本：>= 1.0.0
	LPOP key  移出并获取列表的第一个元素
		Lpop 命令用于移除并返回列表的第一个元素。 （将第一个元素删除掉然后列出删除的元素）
		返回值：
			列表的第一个元素。 当列表 key 不存在时，返回 nil 
		基本语法：
			> Lpop KEY_NAME 
				例：
				> RPUSH mylist "one" "two" "three" "four" "five"
				(integer) 5
				> LPOP mylist
				"one"
				> LPOP mylist 2
				1) "two"
				2) "three"
				> LRANGE mylist 0 -1
				1) "four"
				2) "five"

五、 集合（Set）  
	Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
集合对象的编码可以是 intset 或者 hashtable。
Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。
集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
	
	1. Scard 命令    可用版本：>= 1.0.0
	SCARD key  获取集合的成员数
		Scard 命令返回集合中元素的数量。
		返回值：
			集合的数量。 当集合 key 不存在时，返回 0 。
		基本语法：
			> SCARD KEY_NAME 
				例：
				> SADD myset "Hello"
				(integer) 1
				> SADD myset "World"
				(integer) 1
				> SCARD myset
				(integer) 2

	2. Sdiff 命令   可用版本：>= 1.0.0
	SDIFF key1 [key2]  返回第一个集合与其他集合之间的差异。
		Sdiff 命令返回第一个集合与其他集合之间的差异，也可以认为说第一个集合中独有的元素。不存在的集合 key 将视为空集。差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整个 FIRST_KEY OTHER_KEY1..OTHER_KEYN 的差集。
		返回值：
			包含差集成员的列表。
		基本语法：
			> SDIFF FIRST_KEY OTHER_KEY1..OTHER_KEYN 
				例：
				> SADD key1 "a"
				(integer) 1
				> SADD key1 "b"
				(integer) 1
				> SADD key1 "c"
				(integer) 1
				> SADD key2 "c"
				(integer) 1
				> SADD key2 "d"
				(integer) 1
				> SADD key2 "e"
				(integer) 1
				> SDIFF key1 key2
				1) "a"
				2) "b"

	3. Sdiffstore 命令   可用版本:>= 1.0.0
	SDIFFSTORE destination key1 [key2]  返回给定所有集合的差集并存储在 destination 中 (此命令等于SDIFF，但不是返回结果集，而是存储在destination,如果destination已经存在，则将其覆盖。)
		Sdiffstore 命令将给定集合之间的差集存储在指定的集合中。如果指定的集合 key 已存在，则会被覆盖。
		返回值:
			结果集中的元素数量。
		基本语法：
			> SDIFFSTORE DESTINATION_KEY KEY1..KEYN 
				例：
				> SADD key1 "a"
				(integer) 1
				> SADD key1 "b"
				(integer) 1
				> SADD key1 "c"
				(integer) 1
				> SADD key2 "c"
				(integer) 1
				> SADD key2 "d"
				(integer) 1
				> SADD key2 "e"
				(integer) 1
				> SDIFFSTORE key key1 key2
				(integer) 2
				> SMEMBERS key
				1) "a"
				2) "b"

	4. Sinter 命令   可用版本:>= 1.0.0
	SINTER key1 [key2]  返回给定所有集合的交集
		Sinter 命令返回给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
		返回值:
			交集成员的列表。
		基本语法：
			> SINTER KEY KEY1..KEYN 
				例：
				key1 = {a,b,c,d}
				key2 = {c}
				key3 = {a,c,e}
				SINTER key1 key2 key3 = {c}

	5. Smembers 命令   可用版本：>= 1.0.0
	SMEMBERS key  返回集合中的所有成员
		Smembers 命令返回集合中的所有的成员。 不存在的集合 key 被视为空集合。
		返回值：
			集合中的所有成员
		基本语法：
			> SMEMBERS key
				 例：
				> SADD myset "Hello"
				(integer) 1
				> SADD myset "World"
				(integer) 1
				> SMEMBERS myset
				1) "World"
				2) "Hello"

	6. Srandmember 命令   可用版本：>= 1.0.0
	SRANDMEMBER key [count]   返回集合中一个或多个随机数
		Srandmember 命令用于返回集合中的一个随机元素。
		从 Redis 2.6 版本开始， Srandmember 命令接受可选的 count 参数：
			a. 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
			b. 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
        该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 Srandmember 则仅仅返回随机元素，而不对集合进行任何改动。
        返回值:
			只提供集合 key 参数时，返回一个元素；如果集合为空，返回 nil 。 如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组。
		基本语法：
			> SRANDMEMBER KEY [count]
				例：
				> SADD myset one two three
				(integer) 3
				> SRANDMEMBER myset
				"one"
				> SRANDMEMBER myset 2
				1) "one"
				2) "three"
				> SRANDMEMBER myset -5
				1) "three"
				2) "three"
				3) "two"
				4) "one"
				5) "two"

	7.  Sunion 命令  可用版本：>= 1.0.0
	SUNION key1 [key2]  返回所有给定集合的并集
		Sunion 命令返回给定集合的并集。不存在的集合 key 被视为空集。
		返回值：
			并集成员的列表。
		基本语法：
			> SUNION KEY KEY1..KEYN
				例：
				> SADD key1 "a"
				(integer) 1
				> SADD key1 "b"
				(integer) 1
				> SADD key1 "c"
				(integer) 1
				> SADD key2 "c"
				(integer) 1
				> SADD key2 "d"
				(integer) 1
				> SADD key2 "e"
				(integer) 1
				> SUNION key1 key2
				1) "a"
				2) "c"
				3) "e"
				4) "b"
				5) "d"
				更直观表示：
				key1 = {a,b,c,d}
				key2 = {c}
				key3 = {a,c,e}
				SUNION key1 key2 key3 = {a,b,c,d,e}

六、 有序集合（Sorted set） 
	Redis 有序集合(sorted set)
Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

	1. Zcard 命令  可用版本：>= 1.2.0
	ZCARD key  获取有序集合的成员数
		Zcard 命令用于计算集合中元素的数量。
		返回值：
			当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。
		基本语法：
			> ZCARD KEY_NAME
				例：
				> ZADD myset 1 "Hello"
				(integer) 1
				> ZADD myset 2 "World"
				(integer) 1
				> ZCARD myset
				(integer) 2

	2. Zrange 命令   可用版本：>= 1.2.0
	ZRANGE key start stop [WITHSCORES]  通过索引区间返回有序集合指定区间内的成员
		Zrange  返回有序集中，指定区间内的成员。
		其中成员的位置按分数值递增(从小到大)来排序。
		具有相同分数值的成员按字典序(lexicographical order )来排列。
		如果需要成员按值递减(从大到小)来排列，使用 ZREVRANGE 命令。
		下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

		从 Redis 版本 6.2.0 开始：添加了、REV和BYSCORE选项。BYLEXLIMIT   
		从 Redis 6.2.0 开始，此命令可以替换以下命令：ZREVRANGE、ZRANGEBYSCORE、ZREVRANGEBYSCORE和。ZRANGEBYLEXZREVRANGEBYLEX

		返回值：
			指定区间内，带有分数值(可选)的有序集成员的列表。
		基本语法：
			> ZRANGE key start stop [WITHSCORES]
				例：
				> ZADD myzset 1 "one"
				(integer) 1
				> ZADD myzset 2 "two"
				(integer) 1
				> ZADD myzset 3 "three"
				(integer) 1
				> ZRANGE myzset 0 -1
				1) "one"
				2) "two"
				3) "three"
				> ZRANGE myzset 2 3
				1) "three"
				> ZRANGE myzset -2 -1
				1) "two"
				2) "three"

	3. Zrangebylex 命令  可用版本：>= 2.8.9
	ZRANGEBYLEX key min max [LIMIT offset count]    通过字典区间返回有序集合的成员
		Zrangebylex 通过字典区间返回有序集合的成员。
		返回值：
			指定区间内的元素列表。
		基本语法：
			> ZRANGEBYLEX key min max [LIMIT offset count]
			有效的 start 和 stop 必须以 ( 或 [ 开头，以指定范围项分别是独占还是包含。
				例：
				> ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
				(integer) 7
				> ZRANGEBYLEX myzset - [c
				1) "a"
				2) "b"
				3) "c"
				> ZRANGEBYLEX myzset - (c
				1) "a"
				2) "b"
				> ZRANGEBYLEX myzset [aaa (g
				1) "b"
				2) "c"
				3) "d"
				4) "e"
				5) "f"

	4. Zrangebyscore 命令   可用版本：>= 1.0.5
	ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]   通过分数返回有序集合指定区间内的成员
		Zrangebyscore 返回有序集合中指定分数区间的成员列表。有序集成员按分数值递增(从小到大)次序排列。
		具有相同分数值的成员按字典序来排列(该属性是有序集提供的，不需要额外的计算)。
		默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。
			如：
			ZRANGEBYSCORE zset (1 5
			返回所有符合条件 1 < score <= 5 的成员，而

			ZRANGEBYSCORE zset (5 (10
			则返回所有符合条件 5 < score < 10 的成员。
		返回值：
			指定区间内，带有分数值(可选)的有序集成员的列表。

		基本语法：
			> ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
				例：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZADD myzset 2 "two"
				(integer) 1
				redis:6379> ZADD myzset 3 "three"
				(integer) 1
				redis:6379> ZRANGEBYSCORE myzset -inf +inf
				1) "one"
				2) "two"
				3) "three"
				redis:6379> ZRANGEBYSCORE myzset 1 2
				1) "one"
				2) "two"
				redis:6379> ZRANGEBYSCORE myzset (1 2
				1) "two"
				redis:6379> ZRANGEBYSCORE myzset (1 (2
				(empty array)

	4. Zrank 命令  可用版本：>= 2.0.0
	ZRANK key member   返回有序集合中指定成员的索引
		Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增(从小到大)顺序排列。
		返回值：
			如果成员是有序集 key 的成员，返回 member 的排名。 如果成员不是有序集 key 的成员，返回 nil 。
		基本语法：
			> ZRANK key member
				例：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZADD myzset 2 "two"
				(integer) 1
				redis:6379> ZADD myzset 3 "three"
				(integer) 1
				redis:6379> ZRANK myzset "three"
				(integer) 2
				redis:6379> ZRANK myzset "four"
				(nil)

	5. Zrevrange 命令  可用版本：>= 1.2.0
	ZREVRANGE key start stop [WITHSCORES]    返回有序集中指定区间内的成员，通过索引，分数从高到低
		Zrevrange 命令返回有序集中，指定区间内的成员。
		其中成员的位置按分数值递减(从大到小)来排列。
		具有相同分数值的成员按字典序的逆序(reverse lexicographical order)排列。
		除了成员按分数值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。

		从 Redis 版本 6.2.0 开始，此命令被视为已弃用。迁移或编写新代码时，可以用REV替换ZRANGE参数
		返回值：
			指定区间内，带有分数值(可选)的有序集成员的列表。
		基本语法：
			> ZREVRANGE key start stop [WITHSCORES]
				例：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZADD myzset 2 "two"
				(integer) 1
				redis:6379> ZADD myzset 3 "three"
				(integer) 1
				redis:6379> ZREVRANGE myzset 0 -1
				1) "three"
				2) "two"
				3) "one"
				redis:6379> ZREVRANGE myzset 2 3
				1) "one"
				redis:6379> ZREVRANGE myzset -2 -1
				1) "two"
				2) "one"

	6. Zrevrangebyscore 命令   可用版本：>= 2.2.0
	ZREVRANGEBYSCORE key max min [WITHSCORES]  返回有序集中指定分数区间内的成员，分数从高到低排序
		Zrevrangebyscore 返回有序集中指定分数区间内的所有的成员。有序集成员按分数值递减(从大到小)的次序排列。
		具有相同分数值的成员按字典序的逆序(reverse lexicographical order )排列。
		除了成员按分数值递减的次序排列这一点外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一样。

		从 Redis 版本 6.2.0 开始，此命令被视为已弃用。在迁移或编写新代码时，它可以用带有 REV 和 BYSCORE 参数的 ZRANGE 替换。
		返回值：
			指定区间内，带有分数值(可选)的有序集成员的列表。
		基本语法：
			> ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
				例1：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZADD myzset 2 "two"
				(integer) 1
				redis:6379> ZADD myzset 3 "three"
				(integer) 1
				redis:6379> ZREVRANGEBYSCORE myzset +inf -inf
				1) "three"
				2) "two"
				3) "one"
				redis:6379> ZREVRANGEBYSCORE myzset 2 1
				1) "two"
				2) "one"
				redis:6379> ZREVRANGEBYSCORE myzset 2 (1
				1) "two"
				redis:6379> ZREVRANGEBYSCORE myzset (2 (1
				(empty array)

				例2：
				> ZADD salary 10086 jack
				(integer) 1
				> ZADD salary 5000 tom
				(integer) 1
				> ZADD salary 7500 peter
				(integer) 1
				> ZADD salary 3500 joe
				(integer) 1

				> ZREVRANGEBYSCORE salary +inf -inf   # 逆序排列所有成员
				1) "jack"
				2) "peter"
				3) "tom"
				4) "joe"

				> ZREVRANGEBYSCORE salary 10000 2000  # 逆序排列薪水介于 10000 和 2000 之间的成员
				1) "peter"
				2) "tom"
				3) "joe"

	7. Zrevrank 命令  可用版本：>= 2.2.0
	ZREVRANK key member  返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
		Zrevrank 命令返回有序集中成员的排名。其中有序集成员按分数值递减(从大到小)排序。
		排名以 0 为底，也就是说， 分数值最大的成员排名为 0 。
		使用 ZRANK 命令可以获得成员按分数值递增(从小到大)排列的排名。
		返回值：
			如果成员是有序集 key 的成员，返回成员的排名。 如果成员不是有序集 key 的成员，返回 nil 。
		基本语法：
			> ZREVRANK key member
				例1：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZADD myzset 2 "two"
				(integer) 1
				redis:6379> ZADD myzset 3 "three"
				(integer) 1
				redis:6379> ZREVRANK myzset "one"
				(integer) 2
				redis:6379> ZREVRANK myzset "four"
				(nil）
				例2：
				redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
				1) "jack"
				2) "2000"
				3) "peter"
				4) "3500"
				5) "tom"
				6) "5000"

				redis 127.0.0.1:6379> ZREVRANK salary peter     # peter 的工资排第二
				(integer) 1

				redis 127.0.0.1:6379> ZREVRANK salary tom       # tom 的工资最高
				(integer) 0

	8. Zscore 命令   可用版本：>= 1.2.0
	ZSCORE key member   返回有序集中，成员的分数值
		Zscore 命令返回有序集中，成员的分数值。 如果成员元素不是有序集 key 的成员，或 key 不存在，返回 nil 。
		返回值：
			成员的分数值，以字符串形式表示。
		基本语法：
			> ZSCORE key member
				例1：
				redis:6379> ZADD myzset 1 "one"
				(integer) 1
				redis:6379> ZSCORE myzset "one"
				"1"
				例2 ：
				redis 127.0.0.1:6379> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
				1) "tom"
				2) "2000"
				3) "peter"
				4) "3500"
				5) "jack"
				6) "5000"

				redis 127.0.0.1:6379> ZSCORE salary peter         # 注意返回值是字符串
				"3500"