Golang筆記之Redis

本文首發于公眾號：Hunter后端

原文鏈接：Golang筆記之Redis

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

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

安裝模塊
連接 Redis
字符串
哈希
列表
集合
有序集合
通用命令

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)
}

posted @ 2025-08-06 21:28 XHunter 閱讀(485) 評論(0) 收藏舉報

刷新頁面返回頂部

hunterxiong

Golang筆記之Redis

1、安裝模塊

2、連接 Redis

3、字符串

1. 字符串寫入

2. 字符串讀取

4、哈希

1. 寫入

1) 單字段寫入

2) 多字段寫入

2. 讀取

1) 單字段讀取

2) 多字段讀取

3. 刪除字段

4. 檢查字段是否存在

5、列表

1. 數據寫入

1) RPush-從列表右邊寫入

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

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

2. 數據查看

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

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

3) LLen-查看列表長度

3. 數據刪除與修改

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

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

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

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

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

6、集合

1. 寫入數據

2. 讀取數據

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

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

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

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

3. 刪除元素

1) SRem-移除指定元素

2) SPop-移除隨機元素

4. 集合間操作

1) SDiff-集合差集

2) SInter-集合交集

3) SUnion-集合并集

7、有序集合

1. 數據寫入

2. 數據查詢

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

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

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

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

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

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

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

3. 刪除操作

1) ZRem-指定元素刪除

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

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

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

8、 通用命令

1. Exists-判斷 key 是否存在

2. Expire-設置過期時間

3. Del-刪除 key

4. TTL-查看過期時間

公告

8、通用命令