Go语言如何向函数传递[]Record1或[]Record2类型的切片？

针对你的问题，有几种优雅的实现方式，不用手动转换切片类型，也能把重复逻辑封装起来：

一、泛型方案（Go 1.18+ 推荐） #

利用Go的泛型约束，直接匹配所有包含Important string字段的结构体，无需修改原有定义：

// 定义泛型约束：匹配所有底层包含Important string字段的结构体
type HasImportant interface {
	~struct{ Important string }
}

// 封装核心逻辑的函数
func processImportant(s string) {
	// 这里写你对Important字段的大量操作逻辑
}

// 通用helper函数，处理任意符合约束的切片
func helper[T HasImportant](records []T) {
	for _, record := range records {
		processImportant(record.Important)
	}
}

// 业务代码调用
func main() {
	tx := getTx()
	helper(tx.a)
	helper(tx.b)
	helper(tx.c)
}

这种方式最简洁，直接复用原有结构体，泛型会自动推导类型，调用起来和普通函数一样。

二、接口抽象方案（兼容Go 1.17及以下） #

如果你的Go版本不支持泛型，可以通过定义接口来抽象“获取Important字段”的行为：

// 定义接口，要求实现GetImportant方法
type HasImportant interface {
	GetImportant() string
}

// 给Record1实现接口
func (r Record1) GetImportant() string {
	return r.Important
}

// 给Record2实现接口
func (r Record2) GetImportant() string {
	return r.Important
}

// 封装核心逻辑
func processImportant(s string) {
	// 大量操作逻辑
}

// helper函数接收接口切片
func helper(records []HasImportant) {
	for _, record := range records {
		processImportant(record.GetImportant())
	}
}

// 业务代码调用：需要将原切片转换为接口切片（仅需一次循环）
func main() {
	tx := getTx()
	
	// 转换tx.a为[]HasImportant
	aSlice := make([]HasImportant, len(tx.a))
	for i, r := range tx.a {
		aSlice[i] = r
	}
	helper(aSlice)
	
	// 同理处理tx.b和tx.c
	bSlice := make([]HasImportant, len(tx.b))
	for i, r := range tx.b {
		bSlice[i] = r
	}
	helper(bSlice)
	
	cSlice := make([]HasImportant, len(tx.c))
	for i, r := range tx.c {
		cSlice[i] = r
	}
	helper(cSlice)
}

三、回调遍历方案（无需修改结构体） #

如果不想修改结构体也不想用泛型，可以通过回调函数把遍历逻辑传给helper，核心逻辑依然封装：

// 封装核心逻辑
func processImportant(s string) {
	// 大量操作逻辑
}

// helper接收一个遍历函数，该函数会逐个传入Important字段的值
func helper(iter func(yield func(string))) {
	iter(func(s string) {
		processImportant(s)
	})
}

// 业务代码调用
func main() {
	tx := getTx()
	
	// 处理tx.a
	helper(func(yield func(string)) {
		for _, r := range tx.a {
			yield(r.Important)
		}
	})
	
	// 处理tx.b
	helper(func(yield func(string)) {
		for _, r := range tx.b {
			yield(r.Important)
		}
	})
	
	// 处理tx.c
	helper(func(yield func(string)) {
		for _, r := range tx.c {
			yield(r.Important)
		}
	})
}

这种方式完全不用修改原有结构体，只是把循环的逻辑放到匿名函数里，核心操作还是集中在processImportant中，避免重复代码。

内容的提问来源于stack exchange，提问作者kosciej16