本文首發於公眾號：Hunter後端

原文鏈接：Golang筆記之Redis

這一篇筆記主要介紹 Golang 連接和使用 Redis，以下是本篇筆記目錄：

1. 安裝模塊
2. 連接 Redis
3. 字符串
4. 哈希
5. 列表
6. 集合
7. 有序集合
8. 通用命令

1、安裝模塊

首先需要安裝一下用到的第三方庫：

go get github.com/go-redis/redis/v8

2、連接 Redis

接下來連接 Redis 並測試連接情況，如下是代碼：

package main

import (
    "context"
    "fmt"

    "github.com/go-redis/redis/v8"
)

var ctx = context.Background()
    
func GetRedisClient() *redis.Client {
    redisClient := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })


    pong, err := redisClient.Ping(ctx).Result()
    if err != nil {
        fmt.Println("連接失敗: ", err)
        return nil
    }
    fmt.Println("連接成功: ", pong)
    return redisClient
}

3、字符串

1. 字符串寫入

字符串寫入 Redis 的操作如下：

redisClient.Set(ctx, key, value, expire)

ctx 是 context 上下文，key 和 value 是需要設置的鍵和值，expire 是一個 time.Duration 類型，表示過期時間，如果設為小於等於 0 則表示永不過期。

下面是字符串寫入 Redis 的使用示例：

func SetString(redisClient *redis.Client, ctx context.Context, key, value string, expire time.Duration) error {
    err := redisClient.Set(ctx, key, value, expire).Err()
    if err != nil {
        fmt.Println("設置失敗: ", err)
        return err
    }
    fmt.Println("設置成功")
    return nil
}

func main(){
    redisClient := GetRedisClient()
    defer redisClient.Close()
    ctx := context.Background()
    key := "test_key"
    value := "test_value"
    err := SetString(redisClient, ctx, key, value, 10*time.Second)
    if err != nil {
        fmt.Printf("key:%s set value:%s, error:%v\n", key, value, err)
    }
}

2. 字符串讀取

從 Redis 中讀取字符串的操作如下：

val, err := redisClient.Get(ctx, key).Result()

其中，val 為返回的值，err 表示讀取過程中是否有錯誤。

這裏需要注意下，如果對應的 key 沒有值，也會返回 error，其結果是 redis.Nil，可以做一下單獨的判斷處理。

下面是一個使用示例：

func main(){
    redisClient := GetRedisClient()
    ctx := context.Background()
    key := "test_key"

    val, err := redisClient.Get(ctx, key).Result()
    if err != nil {
        if err == redis.Nil {
            fmt.Printf("key:%s, has no value\n", key)
        } else {
            fmt.Printf("get key:%s, error: %v\n", key, err)
        }
    }
    fmt.Printf("key:%s, value:%s\n", key, val)
}

4、哈希

1. 寫入

1) 單字段寫入

哈希類型的數據單個字段寫入的操作如下：

val, err := redisClient.HSet(ctx, key, field, value).Result()

這裏返回的 val 類型是 int64，值表示設置成功寫入的數量，HSet() 方法這裏介紹的是單字段寫入，後面再介紹多字段寫入。

使用代碼示例如下：

func HSetField(redisClient *redis.Client, ctx context.Context, key, field, value string) {
    val, err := redisClient.HSet(ctx, key, field, value).Result()
    if err != nil {
        fmt.Println("哈希單個字段設置錯誤: ", err)
    } else {
        if val == 1 {
            fmt.Println("哈希單個字段設置成功：", val)
        } else {
            fmt.Println("哈希單個字段更新成功：", val)
        }
    }
}

func main() {
    redisClient := GetRedisClient()
    defer redisClient.Close()

    ctx := context.Background()
    key := "test_hash_key"

    HSetField(redisClient, ctx, key, "field1", "value1")
}

2) 多字段寫入

多字段寫入可以使用 HMSet() 操作，但 HSet() 也支持多字段寫入。

HMSet() 操作是一個已棄用的版本，為了兼容 Redis 3 版本。

而 HSet() 操作只有 Redis 4 及以上才支持多字段的寫入。

使用 HMSet() 的代碼的幾種操作如下：

// 操作 1
val, err := redisClient.HMSet(ctx, key, "field1", "value1", "field2", "value2").Result()

// 操作2
field_value_slice := []string{"field1", "value1", "field2", "value2"}
val, err := redisClient.HMSet(ctx, key, field_value_slice).Result()

// 操作3
m := map[string]interface{}{"field1": "value1", "field2": "value2"}
val, err := redisClient.HMSet(ctx, key, m).Result()

這裏支持輸入的操作包括直接使用多個字符串，切片和 map，返回的結果 val 是 bool 類型，表示是否設置成功。

而 HSet() 支持的參數與 HMSet() 完全相同，但是返回的 val 是一個 int64，表示成功寫入的字段數量。

以下是 HSet() 的操作示例：

// 操作 1
val, err := redisClient.HSet(ctx, key, "field1", "value1", "field2", "value2").Result()

// 操作2
field_value_slice := []string{"field1", "value1", "field2", "value2"}
val, err := redisClient.HSet(ctx, key, field_value_slice).Result()

// 操作3
m := map[string]interface{}{"field1": "value1", "field2": "value2"}
val, err := redisClient.HSet(ctx, key, m).Result()

這裏返回的 val 是 int64 類型，表示成功寫入數據的數量，如果更新字段，字段數量不會計入。

2. 讀取

1) 單字段讀取

哈希數據單個字段的讀取用 HGet() 操作：

val, err := redisClient.HGet(ctx, key, field).Result()

獲取的 val 就是對應字段的值。

這裏有兩種特殊情況，一種是 key 不存在，一種是 field 不存在。

key 或者 field 不存在和之前的字符串讀取的 err 的值一樣，是 redis.Nil。

代碼操作示例如下：

func HGetField(redisClient *redis.Client, ctx context.Context, key, field string) {
    val, err := redisClient.HGet(ctx, key, field).Result()
    if err != nil {
        if err == redis.Nil {
            fmt.Println("key 或者 field 不存在")
        } else {
            fmt.Println("哈希單個字段獲取錯誤: ", err)
        }
    } else {
        fmt.Println("哈希單個字段獲取成功：", val)
    }
    fmt.Printf("%T, %v\n", val, val)
}

func main() {
    redisClient := GetRedisClient()
    defer redisClient.Close()

    ctx := context.Background()
    key := "test_hash_key"

    HGetField(redisClient, ctx, key, "field1")
}

2) 多字段讀取

獲取多個字段值

指定多個字段讀取哈希數據用 HMGet() 操作，需要讀取的多個 field 可以直接作為參數加在後面，也可以使用切片傳入：

val, err := redisClient.HMGet(ctx, key, "field1", "field2", "field3", "field4").Result()

fields := []string{"field1", "field2", "field3", "field14"}
val, err := redisClient.HMGet(ctx, key, fields...).Result()

其返回的 val 是一個 []interface 結構，其中每個元素都是對應的 field 的 value，比如上面的操作結果如下：

[value11 value12 value2 <nil>]

對應的 field 沒有 value 的話，其值就是 nil。

在獲取對應的 value 進行處理的時候需要轉一下：

val[0].(string)

獲取全部字段和值

如果想獲取 key 下全部的 field 和對應的 value，可以使用 HGetAll()，其操作如下：

val := redisClient.HGetAll(ctx, key).Val()

返回的 val 類型是 map[string]string：

fmt.Println(val)
// map[field1:value11 field2:value12 field3:value2]

獲取全部字段

獲取哈希數據下全部的 field 的操作如下：

fieldSlice := redisClient.HKeys(ctx, key).Val()

返回的數據是一個字符串切片 []string，如果對應的 key 沒有數據，返回的結果是空的字符串切片。

獲取全部值

獲取哈希數據下全部 field 對應的 value 的操作如下：

valueSlice := redisClient.HVals(ctx, key).Val()

返回的數據是一個字符串切片 []string，如果 key 下沒有數據，返回的結果是空的字符串切片。

獲取字段長度

獲取哈希數據下有多少個 field 的操作如下：

fieldLength := redisClient.HLen(ctx, key).Val()

返回的結果是一個 int64 類型。

3. 刪除字段

如果要刪除哈希數據下某一個或多個 field，可以使用 HDel() 方法。

// 刪除一個 field
val := redisClient.HDel(ctx, key, "field1").Val()

// 刪除多個 field
val := redisClient.HDel(ctx, key, "field1", "field2", "field3").Val()

// 刪除多個 field
fieldSlice := []string{"field1", "field2"}
val := redisClient.HDel(ctx, key, fieldSlice...).Val()

返回的 val 是 int64 類型，表示刪除了多少個 field。

4. 檢查字段是否存在

HExists() 方法可以用於檢測某個字段是否存在。

val := redisClient.HExists(ctx, key, "field1").Val()

返回的結果是一個 bool 型，表示是否存在。

5、列表

1. 數據寫入

1) RPush-從列表右邊寫入

RPush() 方法支持從列表右邊寫入一個或多個數據，使用示例如下：

// 右邊推入一條數據
res := redisClient.RPush(ctx, key, "a").Val()

// 右邊推入多條數據
res := redisClient.RPush(ctx, key, "a", "b", "c").Val()

// slice 形式推入多條數據
stringSlice := []string{"a", "b", "c"}
res := redisClient.RPush(ctx, key, stringSlice).Val()

返回的結果是一個 int64 類型，表示數據推入列表後，列表當前一共有多少個元素。

如果是從左邊推入，則使用對應的 LPush() 方法。

注意： 這裏需要注意一下從左邊推入和右邊推入的元素順序，比如通用的是 ["a", "b", "c"]，從右邊推入的結果是 ["a", "b", "c"]，但是從左邊推入的結果是 ["c", "b", "a"]

還有個 LPushX 和 RPushX 方法，表示僅當有 key 這個列表的時候可以寫入數據，如果 key 不存在，則不會寫入數據。

2) LInsert-在指定元素位置前後插入

LInsert() 方法支持在指定元素的前後插入一條數據，比如原始的列表數據是 ["a", "b", "c"]，想要元素 b 前面插入一個元素，其操作如下：

res := redisClient.LInsert(ctx, key, "before", "b", "before_b").Val()

插入成功後列表的元素就會變成 ["a", "before_b", "b", "c"]。

LInsert() 方法的第三個參數是可選的，可選值有 before 和 after 分別表示在指定元素的前面還是後面插入。

第四個參數是指定的元素，第五個參數是需要插入的元素。

方法的返回值是個 int64，表示插入成功後當前列表的元素總數。

而如果第四個參數指定的元素不存在，那麼將找不到插入的位置，則會插入失敗，返回的 res 的值就會是 -1，可以通過這個返回值監控是否插入成功。

3) LInsterBefore/LInsterAfter-在指定元素位置前/後插入

LInsterBefore() 和 LInsterAfter() 則是 LInsert() 方法的指定版本，直接在方法層面確認了在指定元素前還是後插入元素。

比如在元素 c 前插入元素：

res := redisClient.LInsertBefore(ctx, key, "c", "before_c").Val()

返回的 res 是 int64，表示插入後當前列表的元素總和。

而如果指定的元素不存在，則會返回 -1。

2. 數據查看

1) LRange-指定範圍查看數據

可以通過 LRange() 方法指定索引的範圍來查看列表數據：

valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()

輸入的參數後兩個為開始和結束索引，上面這個示例表示獲取從 0 到 1 的閉區間列表數據。

返回兩個值，valueSlice 是一個字符串切片，err 表示返回的錯誤

下面是使用示例：

valueSlice, err := redisClient.LRange(ctx, key, 0, 1).Result()
if err != nil {
    fmt.Println("error: ", err)
} else {
    fmt.Printf("%T, %v\n", valueSlice, valueSlice)
}

與之前的獲取邏輯不太一樣的地方是，如果 key 對應的列表數據不存在，err 值還是為 nil，只是返回的 valueSlice 是一個長度為 0 的字符串切片。

如果結束位置的索引大於列表的長度，也不會報錯，而是會返回全部的列表數據。

而如果我們直接想獲取全部的列表數據，可以把結束位置的索引值變成 -1：

valueSlice, err := redisClient.LRange(ctx, key, 0, -1).Result()

2) LIndex-指定索引查看數據

使用示例如下：

value, err := redisClient.LIndex(ctx, key, 1).Result()

返回的結果 value 為指定位置的元素。

LIndex() 方法支持負數索引，比如想獲取倒數第二個元素可以如下操作：

value, err := redisClient.LIndex(ctx, key, -1).Result()

而如果指定的索引位置超出了列表的長度，則 err 信息會是 redis.Nil，下面是操作示例：

value, err := redisClient.LIndex(ctx, key, 8).Result()
if err != nil {
    if err == redis.Nil {
        fmt.Println("索引位置的結果不存在")
    } else {
        fmt.Println("error: ", err)
    }
} else {
    fmt.Printf("%T, %v\n", value, value)
}

3) LLen-查看列表長度

使用示例如下：

value := redisClient.LLen(ctx, key).Val()

返回的結果是一個 int64，表示列表長度，而過 key 不存在，則會返回 0。

3. 數據刪除與修改

1) LPop-彈出最左邊的元素

LPop() 方法的作用是彈出最左邊的元素，操作示例如下：

val, err := redisClient.LPop(ctx, key).Result()

其中 val 是彈出的元素，是 string 類型。

如果列表已經為空，err 的值就是 redis.Nil。

同理，如果是想彈出最右邊的元素，可以使用 RPop() 方法。

2) LPopCount-從左邊彈出指定數量的元素

使用示例如下：

val, err := redisClient.LPopCount(ctx, key, 5).Result()

返回的 val 是一個 []string，如果指定的 count，也就是第三個參數大於列表中的元素個數，則會將元素全部彈出。

如果列表中已經沒有元素可以彈出了，err 的值是 redis.Nil。

3) LRem-遍歷刪除指定個數的指定元素

其操作方法如下：

val, err := redisClient.LRem(ctx, key, 2, "c").Result()

上面的操作表示從列表左邊開始刪除 key 對應的列表中兩個元素為 c 的元素，返回的 val 表示實際刪除的個數。

如果我們想刪除全部指定元素，可以將第三個參數設置為 0：

val, err := redisClient.LRem(ctx, key, 0, "c").Result()

上面的操作表示刪除列表中全部元素為 c 的數據。

4) LTrim-按照索引範圍修剪列表

操作代碼如下：

val, err := redisClient.LTrim(ctx, key, 0, 2).Result()

上面的操作表示只保留列表中 0 到 2 的索引的三個元素，返回的 val 是 string 類型，內容為 OK 表示修剪成功。

5) LSet-指定位置修改元素

LSet() 方法表示修改指定位置的元素內容，比如需要修改索引為 1 的元素內容：

val, err := redisClient.LSet(ctx, key, 1, "index_1_change").Result()

返回的 val 是個字符串，內容 OK 表示修改成功，如果指定的索引超出了原有列表的範圍，則會返回 err。

6、集合

1. 寫入數據

往一個集合中寫入的方法是 SAdd()，可以往裏面寫入單個或者多個元素：

// 寫入單個元素
val := redisClient.SAdd(ctx, key, "a").Val()

// 寫入多個元素
stringSlice := []string{"d", "e"}
val := redisClient.SAdd(ctx, key, stringSlice).Val()

返回的結果 val 是 int64，表示寫入的元素個數，如果元素之前已經在集合，則不會計入其中。

2. 讀取數據

1) SMembers-獲取集合全部元素

使用代碼如下：

res, err := redisClient.SMembers(ctx, key).Result()

返回的 res 是一個 []string，內容為集合的全部元素。

如果 key 對應的集合不存在，返回的 res 為空切片。

2) SCard-獲取集合元素總數

使用代碼如下：

res, err := redisClient.SCard(ctx, key).Result()

返回的 res 類型是 int64，內容是 key 對應的集合的元素總數。

如果 key 對應的集合不存在，返回的 res 結果是 0。

3) SRandMember-隨機取出集合中元素

使用代碼如下：

res, err := redisClient.SRandMember(ctx, key).Result()
if err == redis.Nil {
    fmt.Printf("key:%s 對應的集合不存在\n", key)
}

返回的 res 是集合中隨機一個元素。

如果 key 對應的集合不存在，返回 err 的值是 redis.Nil。

4) SRandMemberN-隨機取出集合中 N 個元素

使用代碼如下：

res, err := redisClient.SRandMemberN(ctx, key, 3).Result()

上面的代碼表示從集合中隨機取出 3 個元素，返回的 res 是 []string。

如果 key 對應的集合不存在，返回的是一個空切片，err 為 nil。

如果指定返回的元素個數大於集合總個數，則會返回全部集合元素。

3. 刪除元素

1) SRem-移除指定元素

SRem() 方法可以用於移除指定的一個多個元素，使用示例如下：

// 刪除一個指定元素
res, err := redisClient.SRem(ctx, key, "a").Result()

// 刪除多個指定元素
res, err := redisClient.SRem(ctx, key, "a", "b").Result()

stringSlice := []string{"a", "b"}
res, err := redisClient.SRem(ctx, key, stringSlice).Result()

返回的結果 res 是一個 int64，表示移除的元素個數。

2) SPop-移除隨機元素

SPop() 方法用於隨機移除集合中的元素。

res, err := redisClient.SPop(ctx, key).Result()

res 是返回的移除的元素。

而 SPopN() 用於移除 N 個隨機元素：

res, err := redisClient.SPopN(ctx, key, 2).Result()

返回的 res 是一個 []string。

4. 集合間操作

1) SDiff-集合差集

SDiff() 方法用於求取集合之間的差集，使用示例如下：

redisClient.SAdd(ctx, "s1", "a", "b", "c")
redisClient.SAdd(ctx, "s2", "a")

res, err := redisClient.SDiff(ctx, "s1", "s2").Result()

返回的 res 是一個 []string，是集合之間的差集。

SDiffStore() 可以將集合間的差集存儲到一個新的 key 中，使用方法如下：

redisClient.SDiffStore(ctx, "s3", "s1", "s2")

上面的操作表示將 s1 和 s2 之間的差集存儲到 s3 中。

2) SInter-集合交集

SInter() 方法用於求取集合之間的交集，使用示例如下：

redisClient.SAdd(ctx, "s1", "a", "b", "c")
redisClient.SAdd(ctx, "s2", "a")

res, err := redisClient.SInter(ctx, "s1", "s2").Result()

返回的 res 是一個 []string，是集合之間的交集。

SInterStore() 可以將集合間的交集存儲到一個新的 key 中，使用方法如下：

redisClient.SInterStore(ctx, "s3", "s1", "s2")

上面的操作表示將 s1 和 s2 之間的交集存儲到 s3 中。

3) SUnion-集合並集

SUnion() 方法用於求取集合之間的並集，使用示例如下：

redisClient.SAdd(ctx, "s1", "a", "b", "c")
redisClient.SAdd(ctx, "s2", "a", "e")

res, err := redisClient.SUnion(ctx, "s1", "s2").Result()

返回的 res 是一個 []string，是集合之間的並集。

SUnionStore() 可以將集合間的並集存儲到一個新的 key 中，使用方法如下：

redisClient.SUnionStore(ctx, "s3", "s1", "s2")

上面的操作表示將 s1 和 s2 之間的並集存儲到 s3 中。

7、有序集合

1. 數據寫入

有序集合數據的寫入可以使用 ZAdd()，使用的示例如下：

res, err := redisClient.ZAdd(ctx, key, &redis.Z{Score: 100, Member: "Golang"}).Result()

輸入的第三個參數是 redis.Z 類型，其結構如下：

type Z struct {
    Score  float64
    Member interface{}
}

Score 是元素用於排序的分數，Member 是有序集合的元素。

除了單個元素，還可以寫入多個元素：

zList := []*redis.Z{
    {Score: 101, Member: "Golang"},
    {Score: 221, Member: "Python"},
    {Score: 445, Member: "Java"},
}
res, err := redisClient.ZAdd(ctx, key, zList...)

返回的 res 類型是 int64，表示插入數據的個數。

2. 數據查詢

1) ZRangeWithScores-返回指定排序範圍的分值和元素

ZRangeWithScores() 方法用於返回指定排序範圍的分值和元素，比如需要返回前三位的數據，使用示例如下：

res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()
for _, item := range res1 {
    fmt.Printf("score:%f, member:%s\n", item.Score, item.Member)
}

其返回的 res1 類型是 []Z，數據按照 score 從小到大排列。

如果想要獲取有序集合中全部元素，可以將指定的範圍寫成 0 和 -1：

res1, err := redisClient.ZRangeWithScores(ctx, key, 0, -1).Result()

通過，有一個逆序方法 ZRevRangeWithScores()，比如獲取從最後往前三位的數據：

res1, err := redisClient.ZRangeWithScores(ctx, key, 0, 2).Result()

2) ZRange-返回指定排序範圍的元素

ZRange() 方法用於返回指定排序範圍的元素，，比如需要返回前三位的數據，使用示例如下：

res1, err := redisClient.ZRange(ctx, key, 0, 2).Result()

返回的 res1 類型是 []string，元素是有序集合的元素，按照 score 從小到大排列。

如果想要獲取有序集合中全部元素，可以將指定的範圍寫成 0 和 -1。

同理，有一個逆序的獲取方法 ZRevRange()，比如獲取從最後往前三位的數據，操作如下：

res1, err := redisClient.ZRevRange(ctx, key, 0, 2).Result()

3) ZRangeByScore-返回指定 score 分值範圍排序的元素

ZRangeByScore 傳入的參數是 redis.ZRangeBy，其數據結構如下：

type ZRangeBy struct {
    Min, Max      string
    Offset, Count int64
}

Min 和 Max 表示 score 分值的範圍，如果想獲取這個範圍內的全部元素，Offset 和 Count 參數置為 0 即可。

如果想要獲取類似分頁的操作，可以對 Offset 和 Count 進行賦值，Count 表示需要獲取的總數，Offset 表示從 Min 開始的偏移量。

使用示例如下：

zRangeBy := &redis.ZRangeBy{
    Min: "1",
    Max: "500",
}
res1, err := redisClient.ZRangeByScore(ctx, key, zRangeBy).Result()

上面的示例表示獲取 key 對應的有序集合 score 從 1 到 500 之間的全部元素，返回的 res1 類型是 []string。

其對應的逆序獲取方法為 ZRevRangeByScore()，操作示例如下：

res1, err := redisClient.ZRevRangeByScore(ctx, key, zRangeBy).Result()

4) ZScore-返回指定元素的 score

使用示例如下：

elementName := "Golang"
res1, err := redisClient.ZScore(ctx, key, elementName).Result()
if err != nil {
    if err == redis.Nil {
        fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName)
    } else {
        fmt.Println("err: ", err)
    }
} else {
    fmt.Printf("key:%s, 元素:%s 的分值是%f\n", key, elementName, res1)
}

返回的 res1 類型是 float64，表示指定元素的 score，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。

另一個方法 ZMScore() 可以獲取多個指定元素的 score：

elementSlice := []string{"Golang", "Python"}
res1, err := redisClient.ZMScore(ctx, key, elementSlice...).Result()

返回的 res1 是一個 []float64，返回的是對應的 elementSlice 對應位置元素的 score。

如果元素不存在，則對應的位置會返回 0。

5) ZRank-返回指定元素的排序數

使用代碼示例如下：

elementName := "Golang"
res1, err := redisClient.ZRank(ctx, key, elementName).Result()
if err != nil {
    if err == redis.Nil {
        fmt.Printf("key:%s 或者元素: %s 不存在\n", key, elementName)
    } else {
        fmt.Println("err: ", err)
    }
} else {
    fmt.Printf("key:%s, 元素:%s 的排序是%d\n", key, elementName, res1)
}

返回的 res1 類型是 int64，表示指定元素的排序數，排序數從 0 開始，如果 key 或者指定的元素不存在，err 的值是 redis.Nil。

ZRevRank() 方法表示逆序獲取，使用方法和 ZRank() 方法一致：

res1, err := redisClient.ZRevRank(ctx, key, elementName).Result()

6) ZCard-返回指定 key 的元素總數

使用示例如下：

res1, err := redisClient.ZCard(ctx, key).Result()

ZCard() 方法返回指定 key 的元素總數，res1 類型是 int64，表示指定 key 的元素總數。

如果對應的 key 不存在，結果為 0，err 為 nil。

7) ZCount-返回 key 指定 score 範圍的元素總數

使用示例如下：

res1, err := redisClient.ZCount(ctx, key, "1", "4").Result()

ZCount() 方法輸入的第三、四個參數是 score 分值的最小和最大值，類型是字符串。

返回的 res1 類型是 int64，如果 key 不存在，結果為 0。

3. 刪除操作

1) ZRem-指定元素刪除

ZRem() 方法用於有序集合指定元素刪除操作，可以刪除一個或多個元素：

res1, err := redisClient.ZRem(ctx, key, []string{"Java", "Golang"}).Result()

返回的 res1 類型是 int64，表示刪除的元素個數。

2) ZRemRangeByScore-刪除指定 score 範圍內的元素

ZRemRangeByScore() 方法用於刪除指定 score 範圍內的元素，第三、四個參數是有序集合的 score 的最小值和最大值，類型是 string，使用示例如下：

res1, err := redisClient.ZRemRangeByScore(ctx, key, "0", "23").Result()

上述示例表示刪除指定 key 的 score 在 0 到 23 之間的閉區間的元素，res1 類型是 int64，表示刪除的元素個數。

3) ZRemRangeByRank-刪除指定排序範圍內的元素

ZRemRangeByRank() 方法用於刪除指定排序範圍內的元素，第三、四個參數是有序集合的排序位的範圍，類型是 int64，比如向刪除有序集合排在前兩位的數據，操作如下：

res1, err := redisClient.ZRemRangeByRank(ctx, key, 0, 1).Result()

返回的 res1 類型是 int64，表示刪除的元素個數。

4) ZPopMin-按照 score 從有序集合中彈出指定個數的元素

如果想按照 score 從小到大排列，彈出某個有序集合中排在前兩位的元素，操作如下：

res1, err := redisClient.ZPopMin(ctx, key, 2).Result()
for _, item := range res1 {
    fmt.Println(item.Score, item.Member)
}

返回的 res1 類型是 []Z。

而如果想按照 score 從大到小排列並彈出指定個數的元素，可以使用 ZPopMax() 方法，使用方式與 ZPopMin() 方法一致。

8、 通用命令

1. Exists-判斷 key 是否存在

Exists() 方法用於判斷指定 key 是否存在，使用示例如下：

res, err := redisClient.Exists(ctx, "a").Result()

返回的 res 類型是 int64，如果指定 key 存在，則 res 為 1，否則為 0。

2. Expire-設置過期時間

Expire() 方法用於給指定 key 設置過期時間，使用示例如下：

res1, err := redisClient.Expire(ctx, key, 20*time.Minute).Result()

返回的 res1 類型是 bool，如果 key 存在且設置過期時間成功，返回的 res1 為 true，否則為 false。

3. Del-刪除 key

Del() 方法用於刪除一個或多個 key，使用示例如下：

// 刪除一個 key
res1, err := redisClient.Del(ctx, "d").Result()

// 刪除多個 key
res1, err := redisClient.Del(ctx, []string{"a", "b", "c"}...).Result()

返回的 res1 類型是 int64，表示刪除的 key 的個數。

4. TTL-查看過期時間

TTL() 方法用於查看指定 key 的過期時間，使用示例如下：

res1, err := redisClient.TTL(ctx, "a").Result()
if err != nil {
    fmt.Println("error: ", err)
    return
}
if res1 == -1 {
    fmt.Println("指定 key 永不過期")
} else if res1 == -2 {
    fmt.Println("指定 key 不存在")
} else {
    fmt.Println("key 在指定時間後過期: ", res1)
}