Set

• redis的set是string類型的無序集合。集合中成員是唯一的，這就意味著集合中不能出現重復的數據。redis中集合是通過哈希表實現的，所以添加，刪除，查找的復雜度都是O(1)。集合中最大的成員數為3^32^ - 1（4294967295，每個集合可以存儲40多億個成員）。
• set類型一般用于贊，踩，標簽，好友關系等。

結構圖

相關命令

命令	說明
sadd key member1 [member2...]	向集合中添加一個或多個成員
smembers key	返回集合中的所有成員
scard key	獲取集合的成員數
srandmember key [count]	返回集合中一個或多個隨機數
sismember key member	判斷member元素是否是集合key的成員
srem key member1 [member2...]	移除集合中一個或多個成員
sdiff key1 [key2]	返回給定所有集合的差集
sdiffstore destination key1 [key2...]	返回給定所有集合的差集并存儲在 destination 中
sinter key1 [key2...]	返回給定所有集合的交集
sinterstore destination key1 [key2...]	返回給定所有集合的交集并存儲在 destination 中
sunion key1 [key2...]	返回所有給定集合的并集
sunionstore destination key1 [key2...]	所有給定集合的并集存儲在 destination 集合中
smove source destination member	將 member 元素從 source 集合移動到 destination 集合
spop key [count]	移除并返回集合中的一個隨機元素
sscan key cursor [MATCH pattern] [COUNT count]	迭代集合中的元素

sdiff key1 [key2]

• sdiff 是 Redis 中的一個命令，它用于執行集合（set）的對稱差集運算。對稱差集是兩個集合的差集的并集，即只屬于第一個集合或只屬于第二個集合的元素組成的集合。

• 具體來說，如果你有兩個集合 key1 和 key2，并且你執行了 SDIFF key1 key2，Redis 將返回那些屬于 key1 但不屬于 key2 的元素，以及那些屬于 key2 但不屬于 key1 的元素。

但是，需要注意的是，Redis 的 SDIFF 命令的語法并不是你給出的 sdiff key1 [key2]。實際的語法是：

SDIFF key1 [key2 ...]

這意味著你可以指定一個或多個額外的鍵（除了 key1），并且 Redis 將返回與 key1 的對稱差集。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 b c d

執行 SDIFF set1 set2 將返回：

1) "a"
2) "d"

因為 “a” 只存在于 set1 中，而 “d” 只存在于 set2 中。

sdiffstore destination key1 [key2...]

• SDIFFSTORE 是 Redis 中的一個命令，它用于執行集合（set）的對稱差集運算，并將結果存儲在一個新的集合中。這與 SDIFF 命令類似，但 SDIFFSTORE 會將結果保存到指定的 destination 鍵中，而不是直接返回結果。

SDIFFSTORE 命令的語法是：

SDIFFSTORE destination key1 [key2 ...]

其中：

• destination：用于存儲對稱差集結果的新集合的鍵名。
• key1：要進行對稱差集運算的第一個集合的鍵名。
• [key2 ...]：可選的，要進行對稱差集運算的其他集合的鍵名。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 b c d

執行 SDIFFSTORE set_result set1 set2 將把 set1 和 set2 的對稱差集結果保存到 set_result 中。結果集合 set_result 將包含元素 “a” 和 “d”，因為 “a” 只存在于 set1 中，而 “d” 只存在于 set2 中。

你可以通過 SMEMBERS 命令來查看 set_result 的內容：

SMEMBERS set_result
1) "a"
2) "d"

sinter key1 [key2...]

是的，SINTER 是 Redis 中的一個命令，用于執行集合（set）的交集運算。它會返回所有指定集合的交集，即同時存在于所有集合中的元素。

SINTER 命令的語法是：

SINTER key1 [key2 ...]

其中：

• key1：第一個集合的鍵名。
• [key2 ...]：可選的，其他集合的鍵名。

如果至少有一個集合是空的，那么 SINTER 將返回一個空集合。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 c e

執行 SINTER set1 set2 set3 將返回：

1) "c"

因為 “c” 是唯一同時存在于 set1、set2 和 set3 中的元素。

sinterstore destination key1 [key2...]

• SINTERSTORE 是 Redis 中用于執行集合（set）的交集運算并將結果存儲在一個新集合的命令。這個命令會計算所有給定集合的交集，并將結果保存在指定的 destination 鍵中。

SINTERSTORE 命令的語法是：

SINTERSTORE destination key1 [key2 ...]

其中：

• destination：新集合的鍵名，用于存儲交集的結果。
• key1：第一個集合的鍵名。
• [key2 ...]：可選的，其他集合的鍵名。

如果至少有一個集合是空的，或者沒有任何集合被指定，那么 SINTERSTORE 命令將在 destination 鍵中存儲一個空集合。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 c e

執行 SINTERSTORE set_intersection set1 set2 set3 將把 set1、set2 和 set3 的交集結果保存到 set_intersection 中。結果集合 set_intersection 將只包含元素 “c”，因為它是唯一同時存在于 set1、set2 和 set3 中的元素。

你可以通過 SMEMBERS 命令來查看 set_intersection 的內容：

SMEMBERS set_intersection
1) "c"

sunion key1 [key2...]

SUNION 是 Redis 中的一個命令，用于執行集合（set）的并集運算。它會返回所有指定集合的并集，即存在于任何一個集合中的元素。

SUNION 命令的語法是：

SUNION key1 [key2 ...]

其中：

• key1：第一個集合的鍵名。
• [key2 ...]：可選的，其他集合的鍵名。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 b c d
SADD set3 e f

執行 SUNION set1 set2 set3 將返回：

1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"

因為這些都是存在于 set1、set2 或 set3 中的元素。

sunionstore destination key1 [key2...]

• 與 SINTERSTORE 類似，Redis 也提供了一個 SUNIONSTORE 命令，該命令將并集的結果存儲在一個新的集合中，而不是直接返回結果。其語法是：

SUNIONSTORE destination key1 [key2 ...]

使用 SUNIONSTORE 命令，你可以將并集的結果保存到 destination 指定的鍵中。例如：

SUNIONSTORE set_union set1 set2 set3

這會將 set1、set2 和 set3 的并集結果保存到 set_union 鍵中。然后，你可以使用 SMEMBERS 命令來查看 set_union 的內容：

SMEMBERS set_union
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"

smove source destination member

SMOVE 是 Redis 中的一個命令，用于將指定的成員從一個集合（source）移動到另一個集合（destination）。如果成員存在于源集合中，SMOVE 命令將其從源集合中移除，并添加到目標集合中。如果移動成功，命令將返回 1；如果成員不存在于源集合中，命令將返回 0。

SMOVE 命令的語法是：

SMOVE source destination member

其中：

• source：源集合的鍵名。
• destination：目標集合的鍵名。
• member：要移動的成員的值。

例如，假設你有以下集合：

SADD set1 a b c
SADD set2 d e

現在，如果你想要將 set1 中的成員 b 移動到 set2，你可以使用 SMOVE 命令：

SMOVE set1 set2 b

執行上述命令后，set1 的內容將變為 a c，而 set2 的內容將變為 d e b（假設移動成功）。然后，你可以使用 SMEMBERS 命令來查看兩個集合的內容：

SMEMBERS set1
1) "a"
2) "c"SMEMBERS set2
1) "d"
2) "e"
3) "b"

注意：如果 b 不存在于 set1 中，SMOVE 命令將返回 0，并且 set2 的內容不會改變。

spop key [count]

SPOP 是 Redis 中的一個命令，用于移除并返回集合（set）中的一個隨機元素。如果集合是空的，SPOP 命令將返回一個 nil 值或者一個錯誤（取決于 Redis 的配置和使用的客戶端庫）。

SPOP 命令的語法是：

SPOP key [count]

其中：

• key：集合的鍵名。
• [count]：可選參數，指定要移除并返回的元素數量。如果不提供，或者提供的 count 為 1，那么 SPOP 將只移除并返回一個隨機元素。如果 count 大于集合中的元素數量，那么將返回集合中的所有元素。

例如，假設你有以下集合：

SADD myset "one" "two" "three" "four"

執行 SPOP myset 將返回集合 myset 中的一個隨機元素，比如 "two"（注意這里返回的是隨機元素，不一定是 "two"），并且這個元素會從集合中移除。然后，如果你再次查看 myset 的內容，你會看到 "two" 已經不在其中了。

SMEMBERS myset
1) "one"
2) "three"
3) "four"

如果你指定 count 參數，比如 SPOP myset 2，那么將返回兩個隨機元素（如果集合中有足夠的元素），并從集合中移除它們。

需要注意的是，SPOP 命令是原子性的，即在執行期間不會被其他命令打斷。這意味著在并發環境下，你可以安全地使用 SPOP 來處理集合中的元素。

sscan key cursor [MATCH pattern] [COUNT count]

SSCAN 是 Redis 中用于迭代集合（set）中的元素的命令。當集合非常大，無法一次性獲取所有元素時，可以使用 SSCAN 來逐步迭代集合中的元素。

SSCAN 命令的語法是：

SSCAN key cursor [MATCH pattern] [COUNT count]

其中：

• key：集合的鍵名。
• cursor：游標，是一個從 0 開始的整數值。用于標識迭代的起始位置。初始調用時，游標應為 0。在后續的迭代中，應使用前一次迭代返回的游標值。
• MATCH pattern（可選）：用于過濾返回的元素的模式。pattern 是一個 glob 風格的模式串。
• COUNT count（可選）：指定每次迭代返回的元素數量。注意，這是一個提示，Redis 可能會返回更多或更少的元素。

當 SSCAN 命令被調用時，它會返回兩個值：

1. 一個新的游標值，用于下一次迭代。如果返回的游標值為 0，則表示迭代結束。
2. 一個數組，包含匹配模式的元素。

示例：

假設你有一個名為 myset 的集合，包含以下元素：one, two, three, four, five。

如果你想迭代這個集合并只獲取以 t 開頭的元素，你可以這樣做：

# 第一次迭代，游標為 0
SSCAN myset 0 MATCH t*
# 假設返回游標為 123 和元素 ["three"]# 第二次迭代，使用上次返回的游標 123
SSCAN myset 123 MATCH t*
# 如果集合中沒有更多的匹配元素，返回的游標值將為 0，且元素數組為空

注意：SSCAN 命令是非阻塞的，并且可以在不鎖定集合的情況下迭代集合中的元素。這使得 SSCAN 命令在處理大型集合時非常有用。

• 例：SSCAN names 0 MATCH test* COUNT 10 # 每次返回10條以test為前綴的key (name為key名)

Zset

• Redis有序集合和集合一樣也是string類型元素的集合且不允許重復的成員。不同的是每個元素都會關聯一個double類型的分數。redis正是通過分數來為集合中的成員進行從小到大的排序。有序集合的成員是唯一的，但分數(score)卻可以重復。
• 集合是通過哈希表實現的，所以添加，刪除，查找的復雜度都是O(1)。 集合中最大的成員數為2^32^ - 1 (4294967295, 每個集合可存儲40多億個成員)。
• Zset類型一般用于排行榜等。

結構圖

相關命令

命令語法	說明
zadd key score1 member1 [score2 member2...]	向有序集合添加一個或多個成員，或者更新已存在成員的分數
zcard key	獲取有序集合的成員數
zcount key min max	計算在有序集合中指定區間分數的成員數
zincrby key increment member	有序集合中對指定成員的分數加上增量 increment
zlexcount key min max	在有序集合中計算指定字典區間內成員數量
zrange key start stop [withscores]	通過索引區間返回有序集合指定區間內的成員
zrangebylex key min max [limit offset count]	通過字典區間返回有序集合的成員
zrangebyscore key min max [withscores] [limit offset count]	通過分數返回有序集合指定區間內的成員
zrank key member	返回有序集合中指定成員的索引
zrem key member [member...]	移除有序集合中的一個或多個成員
zremrangebylex key min max	移除有序集合中給定的字典區間的所有成員
zremrangebyrank key start stop	移除有序集合中給定的排名區間的所有成員
zremrangebyscore key min max	移除有序集合中給定的分數區間的所有成員
zrevrange key start stop [withscores]	返回有序集中指定區間內的成員，通過索引，分數從高到低
zrevrangebyscore key max min [withscores]	返回有序集中指定分數區間內的成員，分數從高到低排序
zrevrank key member	返回有序集合中指定成員的排名，有序集成員按分數值遞減(從大到小)排序
zscore key member	返回有序集中，成員的分數值
zinterstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]	計算給定的一個或多個有序集的交集并將結果集存儲在新的有序集合 key 中
zunionstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]	計算給定的一個或多個有序集的并集，并存儲在新的 key 中
zscan key cursor [MATCH pattern] [COUNT count]	迭代有序集合中的元素（包括元素成員和元素分值）

zcount key min max

ZCOUNT key min max 是 Redis 中用于有序集合（sorted set）的命令，用于計算指定分數范圍內的成員數量。以下是關于該命令的詳細解釋：

命令格式

ZCOUNT key min max

參數說明

• key：有序集合的名稱。
• min 和 max：指定分數范圍的最小值和最大值。這兩個參數支持以下用法：
  • 使用正數表示具體的分數值。
  • 使用 -inf 表示無限小，即包括所有小于 max 的分數。
  • 使用 +inf 表示無限大，即包括所有大于 min 的分數。
  • 在數字前加 ( 表示不包含該數字本身（開區間）。
  • 在數字前加 [ 表示包含該數字本身（閉區間，但默認就是閉區間，所以通常省略）。

返回值

返回一個整數，表示在有序集合 key 中，分數值在 min 和 max 之間（包括等于 min 或 max）的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些員工和他們的薪水（作為分數）：

redis> ZADD myzset 2000 jack
redis> ZADD myzset 3500 peter
redis> ZADD myzset 5000 tom

現在，我們想要計算薪水在 2000 到 5000 之間（包括 2000 和 5000）的員工數量：

redis> ZCOUNT myzset 2000 5000
(integer) 3

這個命令將返回 3，因為有三名員工的薪水在這個范圍內。

注意事項

• 如果 key 不存在，或者 key 不是一個有序集合，那么 ZCOUNT 命令將返回一個錯誤。
• ZCOUNT 命令的時間復雜度為 O(log(N))，因為它使用元素的排名來獲取范圍的概念，因此不需要做與范圍大小成比例的工作。

zincrby key increment member

ZINCRBY 是 Redis 中用于有序集合（sorted set）的命令，用于對有序集合中指定成員的分數進行增加。這個命令會找到指定成員，并將其分數增加指定的增量值。

命令格式

ZINCRBY key increment member

參數說明

• key：有序集合的名稱。
• increment：增加的分數值，可以為正數或負數。
• member：有序集合中的成員。

返回值

返回增加后的成員的分數值。如果成員不存在，那么 ZINCRBY 命令將用 0 作為起始分數，然后加上 increment。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些員工和他們的薪水（作為分數）：

redis> ZADD myzset 2000 jack
redis> ZADD myzset 3500 peter
redis> ZADD myzset 5000 tom

現在，我們想要給 jack 的薪水增加 500：

redis> ZINCRBY myzset 500 jack
"2500"

在這個例子中，jack 的薪水從 2000 增加到了 2500，所以命令返回了 2500。

如果我們給一個不存在的成員（比如 jane）增加薪水，Redis 會用 0 作為起始分數：

redis> ZINCRBY myzset 1000 jane
"1000"

在這個例子中，因為 jane 原先不存在于有序集合中，所以 Redis 用 0 作為起始分數，并增加了 1000，最終返回了 1000。

zlexcount key min max

• ZLEXCOUNT 是 Redis 中用于有序集合（sorted set）的命令，但它不是按照分數（score）來計算成員數量的，而是根據成員自身的字符串值（lexicographically，即按字典順序）來計算在指定范圍內的成員數量。這個命令特別適用于那些將字符串作為成員值，并希望按照這些字符串的字典順序來處理的有序集合。

命令格式

ZLEXCOUNT key min max

參數說明

• key：有序集合的名稱。
• min 和 max：指定范圍的最小值和最大值，這兩個值都是字符串，并且是按照字典順序來比較的。這兩個參數支持以下用法：
  • 使用 + 表示無限大，即包括所有大于 min 的字符串。
  • 使用 - 表示無限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含該字符串本身（閉區間）。
  • 使用 ( 表示不包含該字符串本身（開區間）。如果省略了方括號或圓括號，則默認為閉區間。

返回值

返回一個整數，表示在有序集合 key 中，成員值在 min 和 max 之間（包括等于 min 或 max）的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些字符串成員和它們的分數：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d

現在，我們想要計算成員值在 “b” 和 “d” 之間（包括 “b” 和 “d”）的成員數量：

redis> ZLEXCOUNT myzset "[b" "[d"
(integer) 3

這個命令將返回 3，因為成員 “b”、“c” 和 “d” 的值都在指定的范圍內。注意這里我們使用了閉區間，并且由于 Redis 的字符串比較是區分大小寫的，所以即使分數相同，成員值也會按照它們的字典順序來排列和比較。

zrange key start stop [withscores]

ZRANGE 是 Redis 中用于有序集合（sorted set）的命令，用于獲取指定范圍內的成員列表。這些成員是根據它們的分數（score）來排序的。

命令格式

ZRANGE key start stop [WITHSCORES]

參數說明

• key：有序集合的名稱。
• start 和 stop：返回的有序集合成員的索引位置（基于 0 的索引）。start 和 stop 都可以是負數，表示從尾部開始計算索引。例如，-1 表示最后一個元素，-2 表示倒數第二個元素，以此類推。
• [WITHSCORES]：可選參數。如果包含這個參數，那么返回的每個成員后面都會跟著它的分數。

返回值

• 如果沒有 [WITHSCORES] 參數，則返回一個包含指定范圍內的成員的列表。
• 如果有 [WITHSCORES] 參數，則返回一個包含指定范圍內的成員及其對應分數的列表。每個成員和分數都作為列表的一個元素，并且成員和分數是成對出現的。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

現在，我們想要獲取索引位置從 0 到 1（包括這兩個位置）的成員：

redis> ZRANGE myzset 0 1
1) "a"
2) "b"

如果我們還想要獲取這些成員的分數，我們可以使用 [WITHSCORES] 參數：

redis> ZRANGE myzset 0 1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"

注意：在 Redis 中，有序集合成員的分數是唯一的，但是成員本身的值（即字符串值）可以重復。如果有多個成員具有相同的分數，那么它們的相對順序是根據它們被添加到有序集合中的順序來確定的。在上面的例子中，我們假設沒有成員具有相同的分數，但在實際情況中，這是可能發生的。

zrangebylex key min max [limit offset count]

ZRANGEBYLEX 是 Redis 中用于有序集合（sorted set）的命令，用于根據成員的字典順序（lexicographically）來獲取指定范圍內的成員列表。這個命令特別適用于當有序集合被用作字符串集合，并且成員值（而非分數）具有重要性時。

命令格式

ZRANGEBYLEX key min max [LIMIT offset count]

參數說明

• key：有序集合的名稱。
• min 和 max：指定范圍的最小值和最大值，這兩個值都是字符串，并且是按照字典順序來比較的。這兩個參數支持以下用法：
  • 使用 + 表示無限大，即包括所有大于 min 的字符串。
  • 使用 - 表示無限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含該字符串本身（閉區間）。
  • 使用 ( 表示不包含該字符串本身（開區間）。如果省略了方括號或圓括號，則默認為閉區間。
• [LIMIT offset count]：可選參數，用于限制返回結果的數量和起始位置。offset 是返回列表的起始位置（基于 0 的索引），count 是返回的最大元素數量。

返回值

返回一個包含指定范圍內的成員的列表。如果使用了 [LIMIT offset count] 參數，則只返回指定范圍內的部分成員。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些字符串成員：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d

現在，我們想要獲取字典順序在 “b” 和 “d” 之間（包括 “b” 和 “d”）的成員：

redis> ZRANGEBYLEX myzset "[b" "[d"
1) "b"
2) "c"
3) "d"

如果我們還想要限制返回結果的數量，比如只返回前兩個成員，我們可以使用 [LIMIT 0 2] 參數：

redis> ZRANGEBYLEX myzset "[b" "[d" LIMIT 0 2
1) "b"
2) "c"

在這個例子中，我們指定了偏移量為 0（即返回列表的起始位置），并指定了最大元素數量為 2，所以只返回了 “b” 和 “c” 這兩個成員。

zrangebyscore key min max [withscores] [limit offset count]

ZRANGEBYSCORE 是 Redis 中用于有序集合（sorted set）的命令，用于獲取指定分數范圍內的成員列表。這些成員是根據它們的分數（score）來排序的。

命令格式

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

參數說明

• key：有序集合的名稱。
• min 和 max：指定分數范圍的最小值和最大值。這兩個參數支持以下用法：
  • 使用正數表示具體的分數值。
  • 使用 -inf 表示無限小，即包括所有小于 max 的分數。
  • 使用 +inf 表示無限大，即包括所有大于 min 的分數。
  • 在數字前加 ( 表示不包含該分數值本身（開區間）。
  • 在數字前加 [ 表示包含該分數值本身（閉區間，但默認就是閉區間，所以通常省略）。
• [WITHSCORES]：可選參數。如果包含這個參數，那么返回的每個成員后面都會跟著它的分數。
• [LIMIT offset count]：可選參數，用于限制返回結果的數量和起始位置。offset 是返回列表的起始位置（基于 0 的索引），count 是返回的最大元素數量。

返回值

• 返回一個包含指定分數范圍內的成員的列表。
• 如果使用了 [WITHSCORES] 參數，則返回的列表中的每個成員后面都會跟著它的分數。
• 如果使用了 [LIMIT offset count] 參數，則只返回指定范圍內的部分成員。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

現在，我們想要獲取分數在 2 到 4 之間（包括 2 和 4）的成員：

redis> ZRANGEBYSCORE myzset 2 4
1) "b"
2) "c"
3) "d"

如果我們還想要獲取這些成員的分數，我們可以使用 [WITHSCORES] 參數：

redis> ZRANGEBYSCORE myzset 2 4 WITHSCORES
1) "b"
2) "2"
3) "c"
4) "3"
5) "d"
6) "4"

如果我們只想獲取前兩個成員，我們可以使用 [LIMIT 0 2] 參數：

redis> ZRANGEBYSCORE myzset 2 4 LIMIT 0 2
1) "b"
2) "c"

zrank key member

ZRANK 是 Redis 中用于有序集合（sorted set）的命令，它返回指定成員在有序集合中的排名。排名是根據成員的分數（score）來確定的，分數最小的成員排名為 0。

命令格式

ZRANK key member

參數說明

• key：有序集合的名稱。
• member：需要獲取排名的成員。

返回值

• 如果成員存在于有序集合中，則返回該成員的排名（基于 0 的索引）。
• 如果成員不存在于有序集合中，則返回 nil 或 None（取決于 Redis 客戶端或庫的返回方式）。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

現在，我們想要獲取成員 b 的排名：

redis> ZRANK myzset b
(integer) 1

因為成員 b 的分數是 2，它在有序集合中的排名是 1（基于 0 的索引）。注意，即使有兩個或更多的成員具有相同的分數，它們的排名也是根據它們被添加到有序集合中的順序來確定的。在上面的例子中，如果我們添加了一個分數也為 2 的成員 e，那么 e 的排名將會在 b 之后（假設 e 是在 b 之后添加的）。

zrem key member [member...]

ZREM 是 Redis 中用于有序集合（sorted set）的命令，用于移除有序集合中的一個或多個成員。

命令格式

ZREM key member [member ...]

參數說明

• key：有序集合的名稱。
• member [member ...]：一個或多個需要被移除的成員。

返回值

• 被成功移除的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d

現在，我們想要移除成員 b 和 d：

redis> ZREM myzset b d
(integer) 2

因為成功移除了兩個成員，所以返回了 2。如果我們再次檢查 myzset 的內容，會發現成員 b 和 d 已經不存在了：

redis> ZRANGE myzset 0 -1
1) "a"
2) "c"

在這個例子中，ZRANGE myzset 0 -1 命令用于獲取有序集合 myzset 中的所有成員，結果只包含了 a 和 c，說明 b 和 d 已經被成功移除。

zremrangebylex key min max

ZREMRANGEBYLEX 是 Redis 中用于有序集合（sorted set）的命令，它根據成員的字典順序（lexicographically）來移除指定范圍內的成員。這個命令特別適用于當有序集合被用作字符串集合，并且成員值（即字符串值）具有重要性時。

命令格式

ZREMRANGEBYLEX key min max

參數說明

• key：有序集合的名稱。
• min 和 max：指定范圍的最小值和最大值，這兩個值都是字符串，并且是按照字典順序來比較的。這兩個參數支持以下用法：
  • 使用 + 表示無限大，即包括所有大于 min 的字符串。
  • 使用 - 表示無限小，即包括所有小于 max 的字符串。
  • 使用 [ 表示包含該字符串本身（閉區間）。
  • 使用 ( 表示不包含該字符串本身（開區間）。如果省略了方括號或圓括號，則默認為閉區間。

返回值

• 被成功移除的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些字符串成員：

redis> ZADD myzset 0 a
redis> ZADD myzset 0 b
redis> ZADD myzset 0 c
redis> ZADD myzset 0 d
redis> ZADD myzset 0 e

現在，我們想要移除字典順序在 “b” 和 “d” 之間（包括 “b” 但不包括 “d”）的成員：

redis> ZREMRANGEBYLEX myzset "[b" "(d"
(integer) 2

這個命令移除了成員 “b” 和 “c”，并返回了 2，表示成功移除了兩個成員。如果我們再次檢查 myzset 的內容，會發現成員 “b” 和 “c” 已經不存在了：

redis> ZRANGE myzset 0 -1
1) "a"
2) "d"
3) "e"

在這個例子中，ZRANGE myzset 0 -1 命令用于獲取有序集合 myzset 中的所有成員，結果只包含了 “a”、“d” 和 “e”，說明 “b” 和 “c” 已經被成功移除。

zremrangebyrank key start stop

ZREMRANGEBYRANK 是 Redis 中用于有序集合（sorted set）的命令，它根據成員的排名（rank）來移除指定范圍內的成員。排名是根據成員的分數（score）來確定的，分數最低的成員排名為 0，次低的為 1，依此類推。如果成員的分數相同，則它們的排名是連續的，但 Redis 會根據成員在集合中的插入順序來決定它們的相對排名。

命令格式

ZREMRANGEBYRANK key start stop

參數說明

• key：有序集合的名稱。
• start 和 stop：指定范圍的開始和結束排名（包含 start，但不包含 stop）。排名是從 0 開始的。

返回值

• 被成功移除的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要移除排名在 1 到 3 之間（包括排名 1，但不包括排名 3）的成員：

redis> ZREMRANGEBYRANK myzset 1 3
(integer) 2

這個命令移除了排名為 1 和 2 的成員，即 “b” 和 “c”，并返回了 2，表示成功移除了兩個成員。如果我們再次檢查 myzset 的內容，會發現成員 “b” 和 “c” 已經不存在了：

redis> ZRANGE myzset 0 -1 WITHSCORES
1) "a"
2) "1"
3) "d"
4) "4"
5) "e"
6) "5"

在這個例子中，ZRANGE myzset 0 -1 WITHSCORES 命令用于獲取有序集合 myzset 中的所有成員及其分數，結果只包含了 “a”、“d” 和 “e”，說明 “b” 和 “c” 已經被成功移除。

zremrangebyscore key min max

ZREMRANGEBYSCORE 是 Redis 中用于有序集合（sorted set）的命令，它根據成員的分數（score）來移除指定范圍內的成員。這個命令特別適用于當你想要基于分數來批量刪除有序集合中的成員時。

命令格式

ZREMRANGEBYSCORE key min max

參數說明

• key：有序集合的名稱。
• min 和 max：指定分數范圍的最小值和最大值。這兩個參數支持以下用法：
  • 使用正數表示具體的分數值。
  • 使用 -inf 表示無限小，即包括所有小于 max 的分數。
  • 使用 +inf 表示無限大，即包括所有大于 min 的分數。
  • 在數字前加 ( 表示不包含該分數值本身（開區間）。
  • 在數字前加 [ 表示包含該分數值本身（閉區間，但默認就是閉區間，所以通常省略）。

返回值

• 被成功移除的成員數量。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要移除分數在 2 到 4 之間（包括 2 和 4）的成員：

redis> ZREMRANGEBYSCORE myzset 2 4
(integer) 3

這個命令移除了分數為 2、3 和 4 的成員，即 “b”、“c” 和 “d”，并返回了 3，表示成功移除了三個成員。如果我們再次檢查 myzset 的內容，會發現成員 “b”、“c” 和 “d” 已經不存在了：

redis> ZRANGE myzset 0 -1 WITHSCORES
1) "a"
2) "1"
3) "e"
4) "5"

在這個例子中，ZRANGE myzset 0 -1 WITHSCORES 命令用于獲取有序集合 myzset 中的所有成員及其分數，結果只包含了 “a” 和 “e”，說明 “b”、“c” 和 “d” 已經被成功移除。

zrevrange key start stop [withscores]

ZREVRANGE 是 Redis 中用于有序集合（sorted set）的命令，它返回指定有序集合中成員按分數從高到低排序后的一個子集。與 ZRANGE 命令相反，ZREVRANGE 是按降序排列的。

命令格式

ZREVRANGE key start stop [WITHSCORES]

參數說明

• key：有序集合的名稱。
• start 和 stop：指定返回成員的索引范圍。索引是基于 0 的，其中 0 是最高分的成員（第一個），-1 是最低分的成員（最后一個），-2 是次低分的成員，依此類推。start 和 stop 都是包含邊界的，除非指定了開區間（即使用了 (）。
• [WITHSCORES]：一個可選參數，如果指定了這個選項，返回的成員會和它們的分數一起被返回。

返回值

• 一個包含指定范圍內成員的列表。如果指定了 WITHSCORES 選項，則返回每個成員后跟其分數的列表。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要獲取分數從高到低排序的前兩個成員及其分數：

redis> ZREVRANGE myzset 0 1 WITHSCORES
1) "e"
2) "5"
3) "d"
4) "4"

在這個例子中，我們指定了 start 為 0（即最高分的成員）和 stop 為 1（即次高分的成員），并且使用了 WITHSCORES 選項來同時獲取成員和它們的分數。返回的結果包含了成員 “e” 和 “d” 以及它們的分數 “5” 和 “4”。

如果我們只想要獲取成員而不帶分數，可以省略 WITHSCORES 選項：

redis> ZREVRANGE myzset 0 1
1) "e"
2) "d"

這樣，返回的結果就只包含了成員 “e” 和 “d”。

zrevrangebyscore key max min [withscores]

在 Redis 中，ZREVRANGEBYSCORE 命令用于從有序集合（sorted set）中獲取分數在指定范圍內的成員，并且這些成員是按分數從高到低排序的。這與 ZRANGEBYSCORE 命令相反，后者是按分數從低到高排序的。

命令格式

ZREVRANGEBYSCORE key max min [WITHSCORES]

注意這里的 max 和 min 是按分數從高到低的順序排列的，所以 max 應該是分數較高的邊界，而 min 是分數較低的邊界。

參數說明

• key：有序集合的名稱。
• max 和 min：指定分數范圍的最大值和最小值。這兩個參數支持以下用法：
  • 使用正數表示具體的分數值。
  • 使用 +inf 表示無限大，即包括所有大于 min 的分數。
  • 使用 -inf 表示無限小，即包括所有小于 max 的分數。
  • 在數字前加 ( 表示不包含該分數值本身（開區間）。
  • 在數字前加 [ 表示包含該分數值本身（閉區間，但默認就是閉區間，所以通常省略）。
• [WITHSCORES]：一個可選參數，如果指定了這個選項，返回的成員會和它們的分數一起被返回。

返回值

• 一個包含指定分數范圍內成員的列表。如果指定了 WITHSCORES 選項，則返回每個成員后跟其分數的列表。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要獲取分數在 3 到 1 之間（包括 3 但不包括 1）的成員及其分數：

redis> ZREVRANGEBYSCORE myzset 3 1 WITHSCORES
1) "c"
2) "3"
2) "b"
3) "2"

注意：在這個例子中，由于我們想要的是降序排列（分數從高到低），所以 max 是 3 而 min 是 1。返回的結果包含了成員 “c” 和 “b” 以及它們的分數 “3” 和 “2”。

如果我們只想要獲取成員而不帶分數，可以省略 WITHSCORES 選項：

redis> ZREVRANGEBYSCORE myzset 3 1
1) "c"
2) "b"

這樣，返回的結果就只包含了成員 “c” 和 “b”。

zrevrank key member

在 Redis 中，ZREVRANK 命令用于獲取有序集合（sorted set）中指定成員的排名，但是該排名是基于分數從高到低排序的。與 ZRANK 命令相反，ZRANK 是基于分數從低到高排序的。

命令格式

ZREVRANK key member

參數說明

• key：有序集合的名稱。
• member：要獲取排名的成員。

返回值

• 如果成員存在于有序集合中，則返回該成員的排名（從 0 開始，其中 0 是最高分的成員）。
• 如果成員不存在于有序集合中，則返回 nil 或 -1（具體取決于 Redis 的版本和配置）。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要獲取成員 “c” 的排名（基于分數從高到低）：

redis> ZREVRANK myzset c
(integer) 2

在這個例子中，成員 “c” 的分數是 3，它在有序集合 myzset 中的排名（從高到低）是 2（因為 “e” 和 “d” 的分數更高）。

如果我們嘗試獲取一個不存在的成員的排名：

redis> ZREVRANK myzset f
(nil)

或者在某些 Redis 版本中，可能會返回 -1 表示成員不存在：

redis> ZREVRANK myzset f
(integer) -1

zscore key member

在 Redis 中，ZSCORE 命令用于獲取有序集合（sorted set）中指定成員的分數。如果成員存在于有序集合中，該命令將返回其分數；如果成員不存在，則返回 nil 或空值。

命令格式

ZSCORE key member

參數說明

• key：有序集合的名稱。
• member：要獲取分數的成員。

返回值

• 如果成員存在于有序集合中，則返回該成員的分數。
• 如果成員不存在于有序集合中，則返回 nil 或空值。

示例

假設我們有一個名為 myzset 的有序集合，其中存儲了一些成員和它們的分數：

redis> ZADD myzset 1 a
redis> ZADD myzset 2 b
redis> ZADD myzset 3 c
redis> ZADD myzset 4 d
redis> ZADD myzset 5 e

現在，我們想要獲取成員 “c” 的分數：

redis> ZSCORE myzset c
"3"

在這個例子中，成員 “c” 的分數是 3，所以 ZSCORE 命令返回了 "3"。

如果我們嘗試獲取一個不存在的成員的分數：

redis> ZSCORE myzset f
(nil)

命令返回了 (nil)，表示成員 “f” 不存在于有序集合 myzset 中。

zinterstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

在 Redis 中，ZINTERSTORE 命令用于計算多個有序集合（sorted sets）的交集，并將結果存儲在另一個有序集合中。這個命令在處理多個有序集合的交集運算時非常有用。

命令格式

ZINTERSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

參數說明

• destination：結果集的目標鍵名，用于存儲交集結果。
• numkeys：接下來要指定的有序集合的數量。
• key1 [key2 ...]：一個或多個有序集合的鍵名，用于計算交集。
• WEIGHTS weight1 [weight2 ...]（可選）：每個有序集合的權重，用于計算帶權重的交集。如果沒有指定權重，則所有有序集合的權重默認為 1。
• AGGREGATE SUM|MIN|MAX（可選）：交集成員分數的聚合方式。默認為 SUM。
  • SUM：交集成員的分數為它們在所有輸入有序集合中的分數之和。
  • MIN：交集成員的分數為它們在所有輸入有序集合中的分數的最小值。
  • MAX：交集成員的分數為它們在所有輸入有序集合中的分數的最大值。

返回值

• 交集結果集中元素的數量。

示例

假設我們有三個有序集合 zset1、zset2 和 zset3：

redis> ZADD zset1 1 a 2 b 3 c
redis> ZADD zset2 2 b 3 c 4 d
redis> ZADD zset3 3 c 4 d 5 e

現在，我們想要計算 zset1 和 zset2 的交集，并將結果存儲在 zset_intersection 中：

redis> ZINTERSTORE zset_intersection 2 zset1 zset2
(integer) 2
redis> ZRANGE zset_intersection 0 -1 WITHSCORES
1) "b"
2) "2"
3) "c"
4) "3"

如果我們想要計算帶權重的交集（比如，我們想要 zset1 的分數乘以 2，zset2 的分數乘以 3），并將結果存儲在 zset_weighted_intersection 中：

redis> ZINTERSTORE zset_weighted_intersection 2 zset1 zset2 WEIGHTS 2 3
(integer) 2
redis> ZRANGE zset_weighted_intersection 0 -1 WITHSCORES
1) "b"
2) "10"  # 2 * 2 + 3 * 2
3) "c"
4) "15"  # 3 * 2 + 3 * 3

最后，如果我們想要改變聚合方式，比如使用 MIN 而不是 SUM，我們可以這樣做：

redis> ZINTERSTORE zset_min_intersection 2 zset1 zset2 AGGREGATE MIN
(integer) 2
redis> ZRANGE zset_min_intersection 0 -1 WITHSCORES
1) "b"
2) "2"  # 最小值 2
3) "c"
4) "3"  # 最小值 3

zunionstore destination numkeys key1 [key2...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

在 Redis 中，ZUNIONSTORE 命令用于計算多個有序集合（sorted sets）的并集，并將結果存儲在另一個有序集合中。這個命令在處理多個有序集合的并集運算時非常有用。

命令格式

ZUNIONSTORE destination numkeys key1 [key2 ...] [WEIGHTS weight1 [weight2 ...]] [AGGREGATE SUM|MIN|MAX]

參數說明

• destination：結果集的目標鍵名，用于存儲并集結果。
• numkeys：接下來要指定的有序集合的數量。
• key1 [key2 ...]：一個或多個有序集合的鍵名，用于計算并集。
• WEIGHTS weight1 [weight2 ...]（可選）：每個有序集合的權重，用于計算帶權重的并集。如果沒有指定權重，則所有有序集合的權重默認為 1。
• AGGREGATE SUM|MIN|MAX（可選）：并集成員分數的聚合方式。默認為 SUM。
  • SUM：并集成員的分數為它們在所有輸入有序集合中的分數之和（如果成員只存在于一個集合中，則直接使用該集合的分數）。
  • MIN：并集成員的分數為它們在所有輸入有序集合中的分數的最小值。
  • MAX：并集成員的分數為它們在所有輸入有序集合中的分數的最大值。

返回值

• 并集結果集中元素的數量。

示例

假設我們有三個有序集合 zset1、zset2 和 zset3：

redis> ZADD zset1 1 a 2 b 3 c
redis> ZADD zset2 2 b 3 c 4 d
redis> ZADD zset3 3 c 4 d 5 e

現在，我們想要計算 zset1、zset2 和 zset3 的并集，并將結果存儲在 zset_union 中：

redis> ZUNIONSTORE zset_union 3 zset1 zset2 zset3
(integer) 5
redis> ZRANGE zset_union 0 -1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
7) "d"
8) "4"
9) "e"
10) "5"

如果我們想要計算帶權重的并集（比如，我們想要 zset1 的分數乘以 2，zset2 的分數乘以 3，zset3 的分數乘以 4），并將結果存儲在 zset_weighted_union 中：

redis> ZUNIONSTORE zset_weighted_union 3 zset1 zset2 zset3 WEIGHTS 2 3 4
(integer) 5
redis> ZRANGE zset_weighted_union 0 -1 WITHSCORES
1) "a"
2) "2"  # 1 * 2
3) "b"
4) "10"  # 2 * 2 + 2 * 3
5) "c"
6) "23"  # 3 * 2 + 3 * 3 + 3 * 4
7) "d"
8) "22"  # 4 * 3 + 4 * 4
9) "e"
10) "20"  # 5 * 4

最后，如果我們想要改變聚合方式，比如使用 MAX 而不是 SUM，我們可以這樣做：

redis> ZUNIONSTORE zset_max_union 3 zset1 zset2 zset3 AGGREGATE MAX
(integer) 5
redis> ZRANGE zset_max_union 0 -1 WITHSCORES
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
7) "d"
8) "4"
9) "e"
10) "5"

注意，在使用 MAX 或 MIN 聚合方式時，結果集中的分數是基于所有輸入有序集合中該成員的最大或最小分數。由于成員 “a” 只存在于 zset1 中，所以它的分數在 zset_max_union 中仍然是 1。同樣地，“b” 的分數是 2（因為 “b” 在 `zset1

zscan key cursor [MATCH pattern] [COUNT count]

ZSCAN 是 Redis 中的一個命令，用于迭代有序集合（sorted set）中的元素及其分數。與 KEYS 命令不同，ZSCAN 提供了一個基于游標的迭代器，可以在不阻塞 Redis 服務器的情況下安全地迭代大型數據集。

命令格式

ZSCAN key cursor [MATCH pattern] [COUNT count]

參數說明

• key：要掃描的有序集合的名稱。
• cursor：游標，用于迭代。初始值為 0，每次調用 ZSCAN 時都會返回一個新的游標，直到游標返回 0 表示迭代完成。
• MATCH pattern（可選）：用于過濾返回的元素。只有符合給定模式的元素才會被返回。
• COUNT count（可選）：指定每次迭代返回的元素數量。這是一個提示，Redis 可能會返回更少或更多的元素。

返回值

• 一個包含兩個元素的數組：
  1. 新的游標。
  2. 一個數組，其中每個元素都是一個包含兩個元素的數組，表示有序集合中的一個成員及其分數。

示例

假設我們有一個名為 myzset 的有序集合：

redis> ZADD myzset 1 a 2 b 3 c 4 d 5 e

我們可以使用 ZSCAN 來迭代這個有序集合：

redis> ZSCAN myzset 0
1) "0"
2) 1) "a"2) "1"3) "b"4) "2"5) "c"6) "3"7) "d"8) "4"9) "e"10) "5"

在這個例子中，由于有序集合很小，所以一次性返回了所有元素。但在大型有序集合中，你可能需要多次調用 ZSCAN 并使用返回的游標來繼續迭代。

我們還可以使用 MATCH 參數來過濾結果：

redis> ZSCAN myzset 0 MATCH b*
1) "0"
2) 1) "b"2) "2"3) "c"4) "3"

在這個例子中，只有以 “b” 開頭的成員（即 “b” 和 “c”）被返回。注意，雖然 “c” 不以 “b” 開頭，但由于 Redis 的內部實現，它可能作為匹配 “b*” 的結果的一部分被返回。

你還可以使用 COUNT 參數來指定每次迭代返回的元素數量，但請注意這是一個提示，Redis 可能會返回不同數量的元素。