# Redis 常用命令

# 1. 通用命令

#	命令	说明
1	keys	查看所有的 key
2	dbsize	统计键值对的数量
3	exists	判断指定键值对是否存在
4	del	删除指定键值对
5	expire	设置过期自动删除
6	type	查看键值对数据模型类型

keys 命令
```
> keys *
```
遍历所有的 key。keys 命令一般不在生产环境中使用（因为生产环境中键值对极多）
dbsize 命令
```
> dbsize
```
计算 key 的总数。
exists 命令
```
> exists <key>
```
存在则返回 1，不存在返回 0
del 命令
```
> del <key> [ <key> ... ]
```
删除指定的键值对
expire 命令
```
> expire <key> <seconds>
```
key 在 seconds 秒后过期。
```
> ttl <key>
```
查询 key 的剩余过期时间。返回 -1 表示没有过期设置；返回 -2 表示过期删除。
```
> persist key
```
去掉 key 的过期设置
type 命令
```
> type <key>
```
返回 key 的数据模型，即值的类型。

# 2. 字符串命令

Redis 中的键（key）都是字符串，但是值可以有多种类型（常见五种）。

字符串类型的值（Value）最大不能超过 512M（已经足够大了）。

一般情况下，考虑到并发、流量等问题，通常字符串类型的值最大也只是『百K』级别。

主要命令：

命令	语法
get	`get <key>`
set	`set <key> <value>`
del	`del <key>`

# set 命令

set 命令用于新增或更新键值对。具体是新增还是更新，取决于该键值对原本是否存在。

语法：

SET <key> <value>

SET 执行成功时返回 OK 。

# 对不存在的键进行设置
> SET key "value"
OK
    
> GET key
"value"

# 对已存在的键进行设置

> SET key "new-value"
OK
    
> GET key
"new-value"

set 一个『不存在』的 key ，就是『新增』一个键值对；
set 一个『已存在』的 key ，就是『更新』这个键值对。

# 带参数的 set 命令

无论 key 是否存在，都进行设置
```
> set <key> <val>
```
key 不存在，才设置；等同于 setnx <key> <val> 。
```
> set <key> <val> NX
```
这是真正意义上的『新增』操作，因为要求之前是必须没有的。
key 存在，才设置。
```
> set <key> <val> XX
```
这是真正意义上的『更新』操作，因为要求之前是必须有的。

# get

Get 命令用于获取某个键值对的值（String），具体是哪个键值对由参数 key 决定。

如果键值对不存在，则返回 nil 。

如果键值对的值部分并非字符串（String）类型，则返回一个错误。简而言之，redis 在告诉你 get 命令用错地方了。

语法：

get <key>

# 对不存在的 *key* 或字符串类型 *key* 进行 Get
> GET db
(nil)
    
> SET db redis
OK
    
> GET db
"redis"

# 对不是字符串类型的 *key* 进行 GET
> DEL db
(integer) 1
    
# 在 redis 中添加一个 list 类型的键值对
> LPUSH db redis mongodb mysql
(integer) 3
    
> GET db
(error) ERR Operation against a key holding the wrong kind of value

# del 命令

del 命令用于删除某个键值对。

如果 key 代表的键值对不存在，则该操作无任何效果。

实际上 del 命令是一个通用命令，各种类型结构都有这个命令。

语法：

del <key>

del 命令将返回被删除的键值对的数量。

> SET w3ckey redis
OK

# 删除已创建的 *key* 。
> DEL w3ckey
(integer) 1

# 3. 哈希命令

Hash 结构与 String 结构有一定的相似性。

在 Hash 结构中，键值对的值又分为两个部分：field 和 value 。例如：

key：users:1
- field: id ，value: ...
- field: name ，value: ...
- field: age ，value: ...
- field: address ，value: ...
- field: email ，value: ...

Hash 类型的价值在于，在 Redis 中存储了一个对象的信息后，可以单独更新该对象的某个属性的值，而不需要：取出-更新-序列化-存入。

注意，与数据库中的列不同，Hash 结构中不强求两个键值对中必须有同样数量/名称的 field 。

# hset 命令

hset 命令用于向某个 HashTable 中添加新的键值对 field - value。至于是哪个哈希表则取决与参数 key 。

注意，这里有两层键值对。

首先，整个 Redis 中的数据内容就是一对一对键值对（ key - hashtable ），其中，每个键值对的值部分都是一个 HashTable（HashTable 是 HashMap 的“高级”版本）
其次，HashTable 中存放的又是一对一对的键值对（ filed - value ）。

如果 哈希表 不存在，这个哈希表会被创建，并添加至 Redis 中，然后再进行 Hset 操作。

如果将要添加进哈希表中的 键值对 已经存在，则该 键值对 的旧值将被覆盖。

语法：

hset key field value

如果 field-value 是哈希表中的一个新建键值对，并且值设置成功，返回 1 。

如果在哈希表中 field - value 字段已经存在，则旧值被新值覆盖，返回 0 。

> HSET myhash field1 "foo"
OK
> HGET myhash field1
"foo"

# 设置一个新域   
> HSET website google "www.g.cn"       
(integer) 1

# 覆盖一个旧域   
>HSET website google "www.google.com" 
(integer) 0

# hsetnx 命令

Hsetnx 命令用于向某个哈希表中添加新的 field - value ，具体是哪个 HashTable 取决于参数 key 。

这里要求 filed - value 原本不存在于该 HashTable 中。

如果 filed - value 不存在，则这个 filed - value 将被添加到 HashTable 中。

如果 filed - value 已经存在于哈希表中，操作无效。

如果 HashTable 不存在，一个新哈希表将被创建，并执行 HSETNX 命令。

语法：

hsetnx <key> <field> <value>

hsetnx 命令设置成功时，返回 1 。如果给定 filed - value 已经存在，则没有操作被执行，返回 0 。

# key 或 field 不存在时，才进行设值操作。
> HSETNX myhash field1 "foo"
(integer) 1 # 不存在，操作成功

> HSETNX myhash field1 "bar"
(integer) 0 # 存在，操作失败

> HGET myhash field1
"foo" # 不会有『覆盖』情况出现

# Hmset 命令

Hmset 命令用于同时将多个 field - value 设置到某个哈希表中，至于具体是哪个哈希表则取决于参数 key 。

如果 field - value 在 HashTable 中已存在，此命令会覆盖其旧值。

如果 HashTable 不存在，会创建一个空HashTable，再执行 Hmset 操作。

语法：

Hmset <key> <field1> <value1> [field2 value2] ...

如果命令执行成功，返回 OK 。

# 一次性设置 2 个 filed-value 。
> HSET myhash field1 "foo" field2 "bar"
OK

# Hdel

Hdel 命令用于从某个 HashTable 中删除一个或多个 filed - value ，具体从哪个HashTable中删除，取决于参数 key ，具体删除那一个/些个 filed - value 取决于参数 filed1 ... 。

不存在的 filed - value 将被忽略。

语法：

HDEL <key> <field1> [ field2 ... ]

HDEL 命令返回被成功删除 field - value 的数量，其中不包括被忽略的 filed - value 。

> HSET myhash field1 "foo"
(integer) 1

> HDEL myhash field1
(integer) 1

> HDEL myhash field2
(integer) 0

# Hexists

Hexists 命令用于查看某个HashTable中是否存在某个 filed - values 。

语法：

Hexists key field

如果哈希表含有给定 field - value ，返回 1 ；果哈希表不含有给定 field - value ，返回 0 。

> HSET myhash field1 "foo"
(integer) 1

> HEXISTS myhash field1
(integer) 1

> HEXISTS myhash field2
(integer) 0

# Hget

Hget 命令用于返回某个哈希表中某个 field - value 的值。

语法：

Hget <key> <field>

返回给定 filed - value 的值。如果给定的 HashTable 或 field - value 不存在，则返回 nil 。

# 字段存在
> HSET site redis redis.com
(integer) 1
    
> HGET site redis
"redis.com"

# 字段不存在
> HGET site mysql
(nil)

# 4. 链表命令

# Lpush 命令

增	删	改	查
lpush	lpop	lset	lrange
linsert	rpop	lindex
	lrem	llen
	ltrim

Lpush 命令将一个或多个值插入到某个列表头部（左侧），具体是哪个链表由参数 key 决定。

如果链表不存在，一个空列表会被创建，而后再执行 Lpush 操作。

当 key 对应的类型不是列表类型时，返回一个错误。

语法：

Lpush <key> <value> [ value ... ]

执行 Lpush 命令后，将返回列表的长度。

> LPUSH 9527 10
(integer) 1

> LPUSH 9527 20
(integer) 2

> LRANGE 9527 0 -1
1) "10"
2) "20"

# Rpush 命令

Rpush 命令用于将一个或多个值插入到某个列表的尾部（最右边），具体是哪个列表由参数 key 决定。

如果列表不存在，一个空列表会被创建，然后再执行 Rpush 操作。

当 key 对应的类型不是列表类型时，返回一个错误。

语法：

Rpush <key> <value> [ value ... ]

执行 Rpush 操作后，将返回列表的长度。

> RPUSH 9528 "hello"
(integer) 1

> RPUSH 9528 "world"
(integer) 2

> RPUSH 9528 "goodbye"
(integer) 3

> LRANGE 9528 0 -1
1) "hello"
2) "world"
3) "goodbye"

# Lindex 命令

Lindex 命令用于通过索引获取某个列表中的元素，具体是哪个列表由参数 key 决定。

索引都是从头向尾（从左到右）的方向算，从 0 开始。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

语法：

Lindex <key> <index>

Lindex 命令返回列表中下标所指定的位置的值。如果指定索引值不在列表的区间范围内，返回 nil 。

> LPUSH list_1 "World"
(integer) 1
    
> LPUSH list_1 "Hello"
(integer) 2
    
> LINDEX list_1 0
"Hello"
    
> LINDEX list_1 -1
"World"
    
> LINDEX list_1 3        # index不在 mylist 的区间范围内
(nil)

# Llen 命令

Llen 命令用于返回某个列表的长度。

如果列表不存在，则返回 0 。

如果 key 对应的不是列表类型，则返回一个错误。

语法：

Llen <key>

Llen 返回列表的长度。

> RPUSH list1 "foo"
(integer) 1

> RPUSH list1 "bar"
(integer) 2

> LLEN list1
(integer) 2

# Lpop 命令

Lpop 命令用于移除，并返回某个列表的第一个元素（最左侧的元素）。

语法：

Lpop <key>

Lpop 将返回列表的第一个元素；当列表不存在时，返回 nil 。

> RPUSH list1 "foo"
(integer) 1

> RPUSH list1 "bar"
(integer) 2

> LPOP list1
"foo"

# Rpop 命令

Rpop 命令用于移除，并返回某个列表的最后一个元素（最右侧的元素）。

语法：

RPOP key

Rpop 命令将会返回列表的最后一个元素；当列表不存在时，返回 nil 。

> RPUSH mylist "hello"
(integer) 1

> RPUSH mylist "hello"
(integer) 2

> RPUSH mylist "foo"
(integer) 3

> RPUSH mylist "bar"
(integer) 4

> RPOP mylist
OK

> LRANGE mylist 0 -1
1) "hello"
2) "hello"
3) "foo"

# Linsert 命令

Linsert 命令用于在某个列表的元素（锚点元素）前或者后插入元素。

当列表不存在时，被视为空列表，不执行任何操作。

如果 key 对应的不是列表类型，返回一个错误。

当指定的锚点元素不存在于列表中时，不执行任何操作。

语法：

Linsert <key> [before | after] <pivot> <value>

如果 Linsert 命令执行成功，返回插入操作完成之后，列表的长度；如果没有找到指定元素，返回 -1；如果类表不存在或为空列表，返回 0 。

> RPUSH list1 "foo"
(integer) 1

> RPUSH list1 "bar"
(integer) 2

> LINSERT list1 BEFORE "bar" "Yes"
(integer) 3

> LRANGE mylist 0 -1
1) "foo"
2) "Yes"
3) "bar"

# Lrange 命令

Lrange 返回某个列表中指定区间内的元素，区间以参数 start 和 end 指定。其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。

你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

语法：

Lrange <key> <start> <end>

Lrange 命令返回一个列表，包含指定区间内的元素。

> LPUSH list1 "foo"
(integer) 1

> LPUSH list1 "bar"
(integer) 2

> LPUSHX list1 "bar"
(integer) 0

> LRANGE list1 0 -1
1) "foo"
2) "bar"
3) "bar"

# Lrem 命令

Lrem 根据参数 count 的值，移除某个列表中与参数 value 相等的元素。

count 的值可以是以下几种：

count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 count 。
count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 count 的绝对值。
count = 0 : 移除表中所有与 VALUE 相等的值。

语法：

Lrem <key> <count> <value>

Lrem 命令返回被移除元素的数量。列表不存在时返回 0 。

> RPUSH mylist "hello"
(integer) 1

> RPUSH mylist "hello"
(integer) 2

> RPUSH mylist "foo"
(integer) 3

> RPUSH mylist "hello"
(integer) 4

> LREM mylist -2 "hello"
(integer) 2

# 5. 集合（Set）命令

特点：

无序
无重复
集合间操作

集合内 API	集合间 API
sadd	sdiff
srem	sinter
scard	sunion
sismember
srandmember
smembers
spop

# Sadd 命令

Sadd 命令将一个或多个成员元素加入到某个集合中，已经存在于集合的成员元素将被忽略。

假如集合不存在，则创建一个新的集合，而后再执行 Sadd 操作。

当 key 对应的并非集合类型时，返回一个错误。

语法：

Sadd <key> <value> [ value ... ]

Sadd 命令将被添加到集合中的新元素的数量，不包括被忽略的元素。

> SADD myset "hello"
(integer) 1

> SADD myset "foo"
(integer) 1

> SADD myset "hello"
(integer) 0

> SMEMBERS myset
1) "hello"
2) "foo"

# Scard 命令

Scard 命令返回某个集合中元素的数量。

语法：

SCARD <key>

Scard 命令将返回集合中元素的数量；当集合 key 不存在时，返回 0 。

> SADD myset "hello"
(integer) 1

> SADD myset "foo"
(integer) 1

> SADD myset "hello"
(integer) 0

> SCARD myset
(integer) 2

# Sismember 命令

Sismember 命令判断成员元素是否是某个集合的成员。

语法：

Sismember <key> <value>

如果成员元素是集合的成员，Sismsmber 将返回 1 ；如果成员元素不是集合的成员，或集合不存在，返回 0 。

> SADD myset1 "hello"
(integer) 1

> SISMEMBER myset1 "hello"
(integer) 1

> SISMEMBER myset1 "world"
(integer) 0

# Smembers 命令

Smembers 命令返回某个集合中的所有的成员。

如果集合不存在，则视其为一个空集合。

语法：

Smembers <key>

Smembers 命令将返回集合中的所有成员。

> SADD myset1 "hello"
(integer) 1

> SADD myset1 "world"
(integer) 1

> SMEMBERS myset1
1) "World"
2) "Hello"

# Srandmember 命令

Srandmember 命令用于从某个集合中返回一个或多个随机元素。

从 Redis 2.6 版本开始， Srandmember 命令接受可选的 count 参数：

如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。

如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

返回的元素并不会从集合中移除。

语法：

Srandmember <key> [ count ]

如果没有 count 参数，Srandmember 将返回一个元素；如果提供了 count 参数，那么返回一个数组；如果集合为空，返回空数组；如果集合为空，返回 nil 。

> SADD myset1 "hello"
(integer) 1

> SADD myset1 "world"
(integer) 1

> SADD myset1 "bar"
(integer) 1

> SRANDMEMBER myset1
"bar"

> SRANDMEMBER myset1 2
1) "Hello"
2) "world"

# Smove 命令

Smove 命令将指定成员 member 元素从 source 集合移动到 destination 集合。

SMOVE 是原子性操作。

如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。

否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。

当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。

当 source 或 destination 不是集合类型时，返回一个错误。

语法：

SMOVE <source> <destination> <member>

如果成员元素被成功移除，SMOVE 返回 1 。

如果成员元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。

> SADD myset1 "hello"
(integer) 1

> SADD myset1 "world"
(integer) 1

> SADD myset1 "bar"
(integer) 1

> SADD myset2 "foo"
(integer) 1

> SMOVE myset1 myset2 "bar"
integer) 1

> SMEMBERS myset1
1) "World"
2) "Hello"

> SMEMBERS myset2
1) "foo"
2) "bar"

# Spop 命令

Spop 命令用于『随机』移除，并返回集合中的一个元素。

语法：

Spop key

被移除的随机元素。当集合不存在或是空集时，返回 nil 。

> SADD myset1 "hello"
(integer) 1

> SADD myset1 "world"
(integer) 1

> SADD myset1 "bar"
(integer) 1

> SPOP myset1
"bar"

> SMEMBERS myset1
1) "Hello"
2) "world"

# Srem 命令

Srem 命令用于移除集合中的一个或多个成员元素，不存在的成员元素会被忽略。

当 key 对应的不是集合类型时，返回一个错误。

语法：

Srem <key> <member> [ member ... ]

Srem 返回被成功、实际移除的元素的数量，不包括被忽略的元素。

> SADD myset1 "hello"
(integer) 1

> SADD myset1 "world"
(integer) 1

> SADD myset1 "bar"
(integer) 1
> SREM myset1 "hello"
(integer) 1

> SREM myset1 "foo"
(integer) 0

> SMEMBERS myset1
1) "bar"
2) "world"

# 6. 有序集合命令

和『哈希』有点类似，有序集合中的键值对的值中，也是有两个部分：score 和 value 。

score 的值决定了与之对应的 value 的顺序

zadd
zrem
zscore
zincrby
zcard
zrange
zrangebyscore
zcount
zremrangebyrank
zremrangebyscore

# Zadd 命令

Zadd 命令用于将一个或多个成员元素及其分数值加入到某个有序集当中。

如果某个成员已经是有序集的成员，那么更新这个成员的分数值。有序集合内部会重新调整成员元素的位置，来保证这个集合的有序性。

分数值可以是整数值或双精度浮点数。通常使用整数值。

如果有序集合不存在，则创建一个空的有序集并执行 Zadd 操作。

当 key 所对应的并非有序集类型时，返回一个错误。

语法：

Zadd <key> <score> <value> [scoren value ... ]

Zadd 命令将被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

> ZADD set1 1 "hello"
(integer) 1
> ZADD set1 1 "foo"
(integer) 1
> ZADD set1 2 "world" 3 "bar"
(integer) 2
    
> ZRANGE set1 0 -1 WITHSCORES
1) "hello"
2) "1"
3) "foo"
4) "1"
5) "world"
6) "2"
7) "bar"
8) "3"

# Zcard 命令

Zcard 命令用于计算某个集合中元素的数量。

语法：

Zcard <key>

当集合存在时，Zcard 返回有序集的基数；当集合不存在时，返回 0 。

> ZADD myset 1 "hello"
(integer) 1

> ZADD myset 1 "foo"
(integer) 1

> ZADD myset 2 "world" 3 "bar"
(integer) 2

> ZCARD myzset
(integer) 4

# Zcount 命令

Zcount 命令用于计算某有序集合中指定分数区间的成员数量。

语法：

Zcount <key> <min> <max>

Zcount 返回分数值在 min 和 max 之间的成员的数量。

> ZADD myzset 1 "hello"
(integer) 1

> ZADD myzset 1 "foo"
(integer) 1

> ZADD myzset 2 "world" 3 "bar"
(integer) 2

> ZCOUNT myzset 1 3
(integer) 4

# Zincrby 命令

Zincrby 命令对某有序集合中指定成员的分数加上增量 increment

可以通过传递一个负数值 increment ，让分数减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。

当有序集合不存在，或有序集合中不存在指定分数时， Zincrby 等同于 Zadd 。

当 key 对应的不是有序集时，返回一个错误。

分数值可以是整数值或双精度浮点数。

语法：

Zincrby <key> <increment> <member>

Zincrby 命令返回参数 member 的新的分数值（以字符串形式表示）。

> ZADD myzset 1 "hello"
(integer) 1

> ZADD myzset 1 "foo"
(integer) 1

> ZINCRBY myzset 2 "hello"
(integer) 3

> ZRANGE myzset 0 -1 WITHSCORES
1) "foo"
2) "2"
3) "hello"
4) "3"

# Zrem 命令

Zrem 命令用于移除某个有序集中的一个或多个成员，不存在的成员将被忽略。

如果 key 对应的并非是有序集类型，则返回一个错误。

语法：

Zrem <key> <member>

# 基本示例
> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

# 移除单个元素
> ZREM page_rank google.com
(integer) 1
    
> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"

# 移除多个元素
> ZREM page_rank baidu.com bing.com
(integer) 2

> ZRANGE page_rank 0 -1 WITHSCORES
(empty list or set)


# 移除不存在元素
> ZREM page_rank non-exists-element
(integer) 0

# Zrange 命令

Zrange 返回某有序集中，指定区间内的成员。

如果需要逆序显示，请使用 Zrevrange 命令。

语法：

Zrange <key> <start> <stop> [ WITHSCORES ]

Zrange 命令将指定区间内，带有分数值（可选）的有序集成员的列表。

# 显示整个有序集成员
> ZRANGE salary 0 -1 WITHSCORES
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

# 显示有序集下标区间 1 至 2 的成员
> ZRANGE salary 1 2 WITHSCORES
1) "tom"
2) "5000"
3) "boss"
4) "10086"

# 测试 end 下标超出最大下标时的情况
> ZRANGE salary 0 200000 WITHSCORES
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

# 测试当给定区间不存在于有序集时的情况
> ZRANGE salary 200000 3000000 WITHSCORES
(empty list or set)

# Zrank 命令

Zrank 返回有序集中指定成员的排名。其中有序集成员按分数值递增（从小到大）顺序排列。

语法：

ZRANK <key> <member>

如果成员是有序集的成员，ZRANK 返回 member 的排名；如果成员不是有序集的成员，返回 nil 。

# 显示所有成员及其 score 值
> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

# 显示 tom 的薪水排名，第二
> ZRANK salary tom
(integer) 1

# Zrevrank 命令

Zrevrank 命令返回有序集中成员的排名。其中有序集成员按分数值降序排序。

使用 Zrank 命令可以获得成员按分数值升序排序。

语法：

Zrevrank <key> <member>

如果成员是有序集的成员，Zrevrank 返回成员的排名；如果成员不是有序集的成员，返回 nil 。

> ZRANGE salary 0 -1 WITHSCORES     # 测试数据
1) "jack"
2) "2000"
3) "peter"
4) "3500"
5) "tom"
6) "5000"
    
> ZREVRANK salary peter     # peter 的工资排第二
(integer) 1

> ZREVRANK salary tom       # tom 的工资最高
(integer) 0

# Zscore 命令

Zscore 命令返回有序集中，成员的分数值。

如果成员元素不是有序集的成员，或有序集合不存在，返回 nil 。

语法：

Zscore <key> <member>

Zscore 返回成员的分数值（以字符串形式表示）。

> ZRANGE salary 0 -1 WITHSCORES    # 测试数据
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"
    
> ZSCORE salary peter              # 注意返回值是字符串
"3500"

← Redis 简介 SpringBoot 中使用 Redis →