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

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

👉 点击查看《go-redis使用指南》系列文章目录

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

Redis List 数据结构简介

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

常见使用场景：

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

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 使用指南可查看更多相关教程！

关注我

Redis List 数据结构简介

go-redis 中 List 操作的方法

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

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

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

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

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

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

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

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

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

LLen：获取列表的长度。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

结语

关注我

也可以看看

关注博主

微信打赏

文章分类

广告赞助

热门标签

大流量卡

最新文章

广告赞助

今日热门

广告赞助

随便看看

广告赞助

资源下载

好物推荐

网站统计

广告赞助