Golang 操作 Redis：List列表数据类型操作用法 - go-redis 使用指南

 2024-08-01  |  15 分钟  |  7407 字  |  - 阅读  |  - 评论
文章目录

在本系列上一篇文章《Golang 操作 Redis：为 Hash 中的字段设置过期时间 - go-redis 使用指南》中，我们介绍了如何设置 Redis Hash 哈希数据类型的单个字段设置过期时间。本篇文章我们将深入探讨 Redis 的 List 数据结构，并介绍如何使用 go-redis 库对其进行操作。

👉 点击查看 go-redis 使用指南目录

在《go-redis 使用指南》系列文章中，我们将详细介绍如何在 Golang 项目中使用 redis/go-redis 库与 Redis 进行交互。以下是该系列文章的全部内容：

  1. Golang 操作 Redis：快速上手 - go-redis 使用指南
  2. Golang 操作 Redis：连接设置与参数详解 - go-redis 使用指南
  3. Golang 操作 Redis：基础的字符串键值操作 - go-redis 使用指南
  4. Golang 操作 Redis：如何设置 key 的过期时间 - go-redis 使用指南
  5. Golang 操作 Redis：Hash 哈希数据类型操作用法 - go-redis 使用指南
  6. Golang 操作 Redis：Set 集合数据类型操作用法 - go-redis 使用指南
  7. Golang 操作 Redis：为 Hash 中的字段设置过期时间 - go-redis 使用指南
  8. Golang 操作 Redis：List 列表数据类型操作用法 - go-redis 使用指南
  9. Golang 操作 Redis：SortedSet 有序集合数据类型操作用法 - go-redis 使用指南
  10. Golang 操作 Redis：bitmap 数据类型操作用法 - go-redis 使用指南
  11. Golang 操作 Redis：事务处理操作用法 - go-redis 使用指南
  12. Golang 操作 Redis：地理空间数据类型操作用法 - go-redis 使用指南
  13. Golang 操作 Redis：HyperLogLog 操作用法 - go-redis 使用指南
  14. Golang 操作 Redis：Pipeline 操作用法 - go-redis 使用指南
  15. Golang 操作 Redis：PubSub发布订阅用法 - go-redis 使用指南
  16. Golang 操作 Redis：布隆过滤器（Bloom Filter）操作用法 - go-redis 使用指南
  17. Golang 操作 Redis：Cuckoo Filter操作用法 - go-redis 使用指南
  18. Golang 操作 Redis：Stream操作用法 - go-redis 使用指南
golang redis go-redis

Redis List 数据结构简介

Redis 的 List 数据结构是一种简单的链表数据结构，可以在头部和尾部进行高效的插入和删除操作。它的元素是有序的，可以重复，支持对元素进行任意位置的操作。Redis List 的常见使用场景包括消息队列、任务队列、实时数据流等。

常见使用场景：

  1. 消息队列：通过在 List 的尾部添加消息，并从头部弹出消息来实现先进先出的消息队列。
  2. 任务队列：将待处理任务添加到 List 中，并从 List 中弹出任务进行处理。
  3. 实时数据流：实时记录数据流的日志或事件，方便后续查询和处理。

go-redis 中 List 操作的方法

go-redis 库提供了以下方法用于操作 Redis List 数据结构：

  • BLPop - 阻塞地从一个或多个列表中弹出元素
  • BLMPop - 从一个或多个列表中弹出元素并返回（Redis 6.0+）
  • BRPop - 阻塞地从一个或多个列表中弹出元素
  • BRPopLPush - 从源列表中弹出元素并推送到目标列表（支持阻塞操作）
  • LIndex - 获取列表中指定位置的元素
  • LInsert - 在列表中插入元素（支持在指定元素前或后插入）
  • LLen - 获取列表的长度
  • LMPop - 从一个或多个列表中弹出多个元素并返回（Redis 6.0+）
  • LPop - 从列表的头部弹出一个元素
  • LPopCount - 从列表的头部弹出指定数量的元素（Redis 6.2+）
  • LPos - 查找列表中指定值的位置
  • LPosCount - 查找列表中指定值的位置并限制返回数量
  • LPush - 将一个或多个元素插入到列表的头部
  • LPushX - 将一个或多个元素插入到列表的头部（当列表存在时）
  • LRange - 获取列表中指定范围的元素
  • LRem - 移除列表中指定数量的元素
  • LSet - 设置列表中指定位置的元素
  • LTrim - 修剪列表，使其只保留指定范围的元素
  • RPop - 从列表的尾部弹出一个元素
  • RPopCount - 从列表的尾部弹出指定数量的元素
  • RPopLPush - 从源列表中弹出元素并推送到目标列表的头部
  • RPush - 将一个或多个元素插入到列表的尾部
  • RPushX - 将一个或多个元素插入到列表的尾部（当列表存在时）
  • LMove - 从一个列表移动元素到另一个列表（支持源位置和目标位置指定）
  • BLMove - 阻塞地从一个列表移动元素到另一个列表（支持源位置和目标位置指定）（Redis 6.2+）

⚠️ 注意：如果使用以上方法返回错误可能是 Redis 版本还不支持对应的命令。

go-redis List 操作方法详细讲解及示例代码

BLPop：阻塞地从一个或多个列表中弹出元素，直到有元素可用或超时。

方法签名：

BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd

参数说明：

  • ctx：上下文
  • timeout：阻塞时间，超时则返回空
  • keys：一个或多个列表的键

返回结果说明：返回一个 *StringSliceCmd，其中包含了被弹出的元素及其列表键。

示例代码：

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 阻塞地从列表 "list1" 中弹出元素
    result, err := client.BLPop(ctx, 5*time.Second, "list1").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

BLMPop：从一个或多个列表中弹出多个元素并返回，支持从头部或尾部弹出，Redis 6.0+ 支持。

方法签名：

BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd

参数说明：

  • ctx：上下文
  • timeout：阻塞时间，超时则返回空
  • direction：弹出方向（“left” 或 “right”）
  • count：弹出数量
  • keys：一个或多个列表的键

返回结果说明：返回一个 *KeyValuesCmd，包含弹出的元素及其列表键。

示例代码：

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list1" 中阻塞地弹出 2 个元素
    result, err := client.BLMPop(ctx, 5*time.Second, "left", 2, "list1").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

BRPop：阻塞地从一个或多个列表中弹出元素，直到有元素可用或超时。

方法签名：

BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd

参数说明：

  • ctx：上下文
  • timeout：阻塞时间，超时则返回空
  • keys：一个或多个列表的键

返回结果说明：返回一个 *StringSliceCmd，其中包含了被弹出的元素及其列表键。

示例代码：

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 阻塞地从列表 "list2" 中弹出元素
    result, err := client.BRPop(ctx, 5*time.Second, "list2").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

BRPopLPush：从源列表中弹出一个元素并推送到目标列表的头部，支持阻塞操作。

方法签名：

BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd

参数说明：

  • ctx：上下文
  • source：源列表的键
  • destination：目标列表的键
  • timeout：阻塞时间，超时则返回空

返回结果说明：返回一个 *StringCmd，包含弹出的元素。

示例代码：

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "sourceList" 中弹出一个元素并推送到列表 "destinationList" 的头部
    result, err := client.BRPopLPush(ctx, "sourceList", "destinationList", 5*time.Second).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("移动的元素:", result)
}

LIndex：获取列表中指定位置的元素。

方法签名：

LIndex(ctx context.Context, key string, index int64) *StringCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • index：元素的位置（负数表示从列表尾部开始计算）

返回结果说明：返回一个 *StringCmd，其中包含了指定位置的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 获取列表 "list3" 中位置为 0 的元素
    result, err := client.LIndex(ctx, "list3", 0).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("位置为 0 的元素:", result)
}

LInsert：在列表中插入元素，可以指定插入的位置（元素前或后）。

方法签名：

LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • op：插入操作（“before” 或 “after”）
  • pivot：参考元素
  • value：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 在列表 "list4" 中元素 "a" 前插入元素 "b"
    result, err := client.LInsert(ctx, "list4", "before", "a", "b").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LInsertBefore：在列表中指定元素前插入新元素。

方法签名：

LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • pivot：参考元素
  • value：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 在列表 "list1" 中元素 "a" 前插入元素 "b"
    result, err := client.LInsertBefore(ctx, "list1", "a", "b").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LInsertAfter：在列表中指定元素后插入新元素。

方法签名：

LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • pivot：参考元素
  • value：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 在列表 "list1" 中元素 "a" 后插入元素 "b"
    result, err := client.LInsertAfter(ctx, "list1", "a", "b").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LLen：获取列表的长度。

方法签名：

LLen(ctx context.Context, key string) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键

返回结果说明：返回一个 *IntCmd，表示列表的长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 获取列表 "list5" 的长度
    result, err := client.LLen(ctx, "list5").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("列表长度:", result)
}

LPop：从列表的头部弹出一个元素。

方法签名：

LPop(ctx context.Context, key string) *StringCmd

参数说明：

  • ctx：上下文
  • key：列表的键

返回结果说明：返回一个 *StringCmd，包含弹出的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list6" 的头部弹出一个元素
    result, err := client.LPop(ctx, "list6").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

LMPop：从一个或多个列表中弹出多个元素并返回，Redis 6.0+ 支持。

方法签名：

LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd

参数说明：

  • ctx：上下文
  • direction：弹出方向（“left” 或 “right”）
  • count：弹出数量
  • keys：一个或多个列表的键

返回结果说明：返回一个 *KeyValuesCmd，包含弹出的元素及其列表键。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list1" 中弹出 2 个元素
    result, err := client.LMPop(ctx, "left", 2, "list1").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

LPopCount：从列表的头部弹出指定数量的元素。

方法签名：

LPopCount(ctx context.Context, key string, count int) *StringSliceCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • count：弹出的元素数量

返回结果说明：返回一个 *StringSliceCmd，包含弹出的元素列表。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list1" 的头部弹出 3 个元素
    result, err := client.LPopCount(ctx, "list1", 3).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

LPos：查找列表中指定值的位置。

方法签名：

LPos(ctx context.Context, key string, value string, args LPosArgs) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • value：待查找的值
  • args：查询参数（如开始位置、结束位置等）

返回结果说明：返回一个 *IntCmd，包含指定值的位置。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 查找列表 "list1" 中元素 "a" 的位置
    result, err := client.LPos(ctx, "list1", "a", redis.LPosArgs{}).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("元素 'a' 的位置:", result)
}

LPosCount：查找列表中指定值的位置，并限制返回数量。

方法签名：

LPosCount(ctx context.Context, key string, value string, count int64, args LPosArgs) *IntSliceCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • value：待查找的值
  • count：返回的最大数量
  • args：查询参数（如开始位置、结束位置等）

返回结果说明：返回一个 *IntSliceCmd，包含指定值的位置列表。

示例代码：

package

 main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 查找列表 "list1" 中元素 "a" 的前 2 个位置
    result, err := client.LPosCount(ctx, "list1", "a", 2, redis.LPosArgs{}).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("元素 'a' 的位置列表:", result)
}

LPush：将一个或多个元素插入到列表的头部。

方法签名：

LPush(ctx context.Context, key string, values ...interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • values：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 向列表 "list7" 的头部插入元素 "x" 和 "y"
    result, err := client.LPush(ctx, "list7", "x", "y").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LPushX：将一个或多个元素插入到列表的头部，仅在列表存在时生效。

方法签名：

LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • values：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 向已存在的列表 "list1" 的头部插入元素 "x"
    result, err := client.LPushX(ctx, "list1", "x").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LRange：获取列表中指定范围的元素。

方法签名：

LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • start：起始索引
  • stop：结束索引

返回结果说明：返回一个 *StringSliceCmd，包含指定范围的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 获取列表 "list1" 从索引 0 到 2 的元素
    result, err := client.LRange(ctx, "list1", 0, 2).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("指定范围的元素:", result)
}

LRem：从列表中移除指定数量的某个元素。

方法签名：

LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • count：要移除的数量（正数从头部开始移除，负数从尾部开始移除）
  • value：待移除的元素

返回结果说明：返回一个 *IntCmd，表示移除的数量。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list1" 中移除 2 个元素 "a"
    result, err := client.LRem(ctx, "list1", 2, "a").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("移除的元素数量:", result)
}

LSet：设置列表中指定位置的元素。

方法签名：

LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • index：列表中的位置索引
  • value：待设置的元素

返回结果说明：返回一个 *StatusCmd，表示操作状态。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 将列表 "list1" 中索引为 1 的元素设置为 "newValue"
    _, err := client.LSet(ctx, "list1", 1, "newValue").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("元素已更新")
}

LTrim：对列表进行修剪，保留指定范围内的元素。

方法签名：

LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • start：起始索引
  • stop：结束索引

返回结果说明：返回一个 *StatusCmd，表示操作状态。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 修剪列表 "list1"，保留索引 0 到 2 的元素
    _, err := client.LTrim(ctx, "list1", 0, 2).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("列表已修剪")
}

RPop：从列表的尾部弹出一个元素。

方法签名：

RPop(ctx context.Context, key string) *StringCmd

参数说明：

  • ctx：上下文
  • key：列表的键

返回结果说明：返回一个 *StringCmd，包含弹出的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list8" 的尾部弹出一个元素
    result, err := client.RPop(ctx, "list8").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

RPopCount：从列表的尾部弹出指定数量的元素。

方法签名：

RPopCount(ctx context.Context, key string, count int) *StringSliceCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • count：弹出的元素数量

返回结果说明：返回一个 *StringSliceCmd，包含弹出的元素列表。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "list1" 的尾部弹出 3 个元素
    result, err := client.RPopCount(ctx, "list1", 3).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("弹出的元素:", result)
}

RPopLPush：从源列表中弹出一个元素并推送到目标列表的头部。

方法签名：

RPopLPush(ctx context.Context, source, destination string) *StringCmd

参数说明：

  • ctx：上下文
  • source：源列表的键
  • destination：目标列表的键

返回结果说明：返回一个 *StringCmd，包含弹出的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "sourceList" 中弹出一个元素并推送到列表 "destinationList" 的头部
    result, err := client.RPopLPush(ctx, "sourceList", "destinationList").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("移动的元素:", result)
}

RPush：将一个或多个元素插入到列表的尾部。

方法签名：

RPush(ctx context.Context, key string, values ...interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • values：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 向列表 "list9" 的尾部插入元素 "a" 和 "b"
    result, err := client.RPush(ctx, "list9", "a", "b").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

RPushX：将一个或多个元素插入到列表的尾部，仅在列表存在时生效。

方法签名：

RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd

参数说明：

  • ctx：上下文
  • key：列表的键
  • values：待插入的元素

返回结果说明：返回一个 *IntCmd，表示插入后的列表长度。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 向已存在的列表 "list1" 的尾部插入元素 "x"
    result, err := client.RPushX(ctx, "list1", "x").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("插入后的列表长度:", result)
}

LMove：从一个列表移动元素到另一个列表，并指定源和目标位置。

方法签名：

LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd

参数说明：

  • ctx：上下文
  • source：源列表的键
  • destination：目标列表的键
  • srcpos：源列表的位置（“left” 或 “right”）
  • destpos：目标列表的位置（“left” 或 “right”）

返回结果说明：返回一个 *StringCmd，包含移动的元素。

示例代码：

package main

import (
    "context"
    "fmt"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "sourceList" 的尾部移动一个元素到列表 "destinationList" 的头部
    result, err := client.LMove(ctx, "sourceList", "destinationList", "right", "left").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("移动的元素:", result)
}

BLMove：从源列表的指定方向弹出一个元素并推送到目标列表的指定方向，支持阻塞操作。

方法签名：

BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *StringCmd

参数说明：

  • ctx：上下文
  • source：源列表的键
  • destination：目标列表的键
  • srcpos：源列表的弹出方向（“left” 或 “right”）
  • destpos：目标列表的推送方向（“left” 或 “right”）
  • timeout：阻塞时间，超时则返回空

返回结果说明：返回一个 *StringCmd，包含移动的元素。

示例代码：

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    ctx := context.Background()
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    // 从列表 "sourceList" 的左边弹出一个元素并推送到列表 "destinationList" 的右边
    result, err := client.BLMove(ctx, "sourceList", "destinationList", "left", "right", 5*time.Second).Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("移动的元素:", result)
}

结语

本文详细介绍了 Redis List 数据结构及其在 go-redis 中的操作方法。希望通过这些示例代码，你能更好地理解如何在 Golang 中使用 go-redis 操作 Redis List 数据类型。

希望这篇文章对你有所帮助！点击 go-redis 使用指南 可查看更多相关教程！

关注我

X

 go-redis使用指南  redis  golang  编程

也可以看看

小而赚副业指南

分享低成本靠谱赚钱副业，获取实用的搞钱指南，开启你的副业赚钱之旅吧！

全国大流量卡免费领

19元月租ㆍ超值优惠ㆍ长期套餐ㆍ免费包邮ㆍ官方正品