详解Go语言中的Slice链式操作

业务场景示例

在处理复杂的业务逻辑时，经常需要对嵌套数据结构进行过滤、映射和展开。为了演示链式操作的实用性，我们首先定义一组基础的结构体：订单（Order）、产品（Product）和自定义订单（CustomOrder）。

其中，一个订单包含多个产品，这使得后续需要进行多层级的数据处理：

type Order struct {
	Id       string
	Products []Product
}

type Product struct {
	Id    string
	Price int
}

type CustomOrder struct {
	Id string
}

接下来，初始化模拟数据列表：

var orders = []Order{
	{
		Id: "o1",
		Products: []Product{
			{ Id: "p1", Price: 1 },
			{ Id: "p2", Price: 2 },
		},
	},
	{
		Id: "o2",
		Products: []Product{
			{ Id: "p3", Price: 3 },
			{ Id: "p4", Price: 4 },
		},
	},
}

有了数据结构后，我们可以尝试对订单列表执行以下几种典型的链式操作：

第1步：过滤特定条件的订单

目的：从所有订单列表中筛选出 ID 为 "o2" 的订单。

// 过滤Id为o2的订单
func TestFilter(t *testing.T) {
	res := Lists[Order](orders).Filter(func(o any) bool {
		return o.(Order).Id == "o2"
	}).Collect()
	t.Log(res)
}

该方法通过 Filter 传入闭包函数，并在最后调用 Collect() 收集结果。

第2步：将订单映射为自定义订单

目的：将原始订单列表转换为只包含特定 ID 格式的自定义订单列表。

// 将订单列表映射为自定义订单列表
func TestMap(t *testing.T) {
	res := Lists[CustomOrder](orders).Map(func(o any) any {
		return CustomOrder{
			Id: "custom-" + o.(Order).Id,
		}
	}).Collect()
	t.Log(res)
}

第3步：扁平化并映射（Flat & Map）

目的：将每个订单里的“产品”提取出来（展平），并进一步映射为自定义结构体。

// 将每个订单里的产品展开，并映射为自定义订单
func TestFlatAndMap(t *testing.T) {
	res := Lists[CustomOrder](orders).
		Flat(func(o any) []any {
			return Lists[any](o.(Order).Products).ToList()
		}).
		Map(func(p any) any {
			return CustomOrder{
				Id: "ProductId-" + p.(Product).Id,
			}
		}).Collect()
	t.Log(res)
}

第4步：查找最大值

目的：在所有订单的产品中，找出价格最高的那个产品。

// 找到所有订单产品中价格最贵的那个产品
func TestMax(t *testing.T) {
	res, found := Lists[Product](orders).
		Flat(func(o any) []any {
			return Lists[any](o.(Order).Products).ToList()
		}).
		Max(func(i, j any) bool {
			return i.(Product).Price > j.(Product).Price
		})
	t.Log(found, res)
}

底层原理与设计思路

要实现上述流畅的链式调用，核心在于对原生 Slice 进行一层泛型包装。

泛型容器的设计

我们将 Go 原生的切片包装成一个名为 List[T] 的结构体：

type List[T any] struct {
	list []any
}

这里的关键点在于泛型参数 T 的定义：T 代表的是最终经过一系列链式操作后返回的元素类型，而不是最初输入切片的类型。

这种设计主要是受限于 Go 语言的特性——Go 不支持在被定义为接收者函数（Receiver function）的方法中直接定义泛型参数。因此，为了让方法之间能够互相衔接，我们在结构体内部使用 []any（即 []interface{}）来暂存任意类型的元素，并在方法体内使用类型断言（Type Assertion）来恢复原始数据类型（如代码中的 i.(Product).Price）。

链式实现的逻辑

所有的操作方法（如 Filter、Map、Flat）在执行完各自的逻辑后，都会返回同一个 *List[T] 指针实例或其新的实例。由于返回值仍然是一个包含这些操作上下文的结构体，因此可以无缝地在其后继续调用其他方法，从而实现链式语法。

核心功能的完整实现

基于以上原理，以下是支撑整个链式调用的完整 Go 代码实现：

import (
	"fmt"
	"reflect"
	"sort"
)

type List[T any] struct {
	list []any
}

// Lists 构造器：利用反射将传入的 slice 转换为 List 对象
func Lists[T any](items any) *List[T] {
	rv := reflect.ValueOf(items)
	if rv.Kind() != reflect.Slice {
		panic(fmt.Sprintf("not supported type: %v, please use slice instead", rv.Kind()))
	}
	l := rv.Len()
	s := make([]any, 0, l)
	for i := 0; i < l; i++ {
		s = append(s, rv.Index(i).Interface())
	}
	return &List[T]{
		list: s,
	}
}

// Filter：过滤元素
func (s *List[T]) Filter(fn func(any) bool) *List[T] {
	l := make([]any, 0)
	for _, e := range s.list {
		if fn(e) {
			l = append(l, e)
		}
	}
	s.list = l
	return s
}

// Map：映射元素
func (s *List[T]) Map(fn func(any) any) *List[T] {
	l := make([]any, 0)
	for _, element := range s.list {
		l = append(l, fn(element))
	}
	return &List[T]{
		list: l,
	}
}

// Flat：扁平化/展平元素
func (s *List[T]) Flat(fn func(any) []any) *List[T] {
	l := make([]any, 0)
	for _, element := range s.list {
		l = append(l, fn(element)...)
	}
	return &List[T]{
		list: l,
	}
}

// Sort：排序
func (s *List[T]) Sort(fn func(i, j any) bool) *List[T] {
	if len(s.list) <= 0 {
		return s
	}
	sort.SliceStable(s.list, func(i, j int) bool {
		return fn(s.list[i], s.list[j])
	})
	return s
}

// Max：获取最大值（先排序后取第一个）
func (s *List[T]) Max(fn func(i, j any) bool) (T, bool) {
	return s.Sort(fn).FindFirst()
}

// FindFirst：获取第一个元素
func (s *List[T]) FindFirst() (T, bool) {
	if len(s.list) <= 0 {
		var nonsense T
		return nonsense, false
	}
	return s.list[0].(T), true
}

// ToList：直接返回原始 interface{} 切片
func (s *List[T]) ToList() []any {
	return s.list
}

// Collect：将内部元素强转为泛型类型 T 后返回
func (s *List[T]) Collect() []T {
	t := make([]T, 0)
	for _, a := range s.list {
		t = append(t, a.(T))
	}
	return t
}

以上就是关于详解Go语言中的Slice链式操作的详细内容，更多关于Go Slice链式操作内容请搜索本站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本站！