Go语言：用接口作为函数参数处理任意结构体切片，优化重复代码

针对你的问题，我们有两种常见的优化方案，既能避免重复代码，又能优雅地处理任意结构体切片的存储逻辑。下面分别介绍：

方案一：使用反射实现通用遍历（无需修改原有结构体） #

如果你的存储逻辑大部分是重复的，只是需要遍历切片并处理每个元素，那么利用Go的reflect包可以快速实现通用函数，不需要修改现有的结构体定义：

package main

import (
	"fmt"
	"reflect"
)

type typeA struct {
	fieldA1 int
	fieldA2 string
}

type typeB struct {
	fieldB1 float32
	fieldB2 bool
}

// saveSlice 接收任意类型的切片，统一处理存储逻辑
func saveSlice(slice interface{}) error {
	sliceVal := reflect.ValueOf(slice)
	// 先校验输入是否为切片类型
	if sliceVal.Kind() != reflect.Slice {
		return fmt.Errorf("expected a slice, got %T", slice)
	}

	// 遍历切片中的每个元素
	for idx := 0; idx < sliceVal.Len(); idx++ {
		elem := sliceVal.Index(idx).Interface()
		// 这里替换成你的数据库存储逻辑，比如调用DB的Insert方法
		fmt.Printf("Processing element %d: %+v\n", idx, elem)

		// 可选：如果不同结构体需要特殊处理，用类型断言区分
		switch item := elem.(type) {
		case typeA:
			fmt.Printf("  Handling typeA: fieldA1=%d, fieldA2=%s\n", item.fieldA1, item.fieldA2)
		case typeB:
			fmt.Printf("  Handling typeB: fieldB1=%.1f, fieldB2=%t\n", item.fieldB1, item.fieldB2)
		}
	}
	return nil
}

func main() {
	a := []typeA{
		{10, "foo"},
		{20, "boo"},
	}
	b := []typeB{
		{2.5, true},
		{3.5, false},
	}

	// 用同一个函数处理两种不同的切片
	if err := saveSlice(a); err != nil {
		fmt.Println("Failed to save typeA slice:", err)
	}
	if err := saveSlice(b); err != nil {
		fmt.Println("Failed to save typeB slice:", err)
	}
}

方案一说明： #

• 核心是用反射获取切片的元信息，遍历每个元素并转换为空接口类型，再统一处理。
• 优点：不需要修改原有结构体，快速复用遍历逻辑；如果有少量差异化逻辑，可以用类型断言补充。
• 缺点：反射有轻微的性能开销，且编译期无法校验输入类型，需要运行时做错误检查。

方案二：定义通用接口（类型安全，更符合Go设计哲学） #

如果不同结构体的存储逻辑差异较大，或者你希望代码有更强的类型安全性，那么可以定义一个通用接口，让每个结构体实现该接口的方法：

package main

import "fmt"

type typeA struct {
	fieldA1 int
	fieldA2 string
}

type typeB struct {
	fieldB1 float32
	fieldB2 bool
}

// 定义一个通用的可存储接口
type Storable interface {
	Save() error
}

// 让typeA实现Save方法，编写专属的存储逻辑
func (a typeA) Save() error {
	fmt.Printf("Saving typeA to DB: fieldA1=%d, fieldA2=%s\n", a.fieldA1, a.fieldA2)
	// 这里替换为实际的数据库存储代码
	return nil
}

// 让typeB实现Save方法，编写专属的存储逻辑
func (b typeB) Save() error {
	fmt.Printf("Saving typeB to DB: fieldB1=%.1f, fieldB2=%t\n", b.fieldB1, b.fieldB2)
	// 这里替换为实际的数据库存储代码
	return nil
}

// saveStorableSlice 接收Storable接口切片，统一处理存储
func saveStorableSlice(items []Storable) error {
	for _, item := range items {
		if err := item.Save(); err != nil {
			return fmt.Errorf("failed to save item: %w", err)
		}
	}
	return nil
}

func main() {
	a := []typeA{
		{10, "foo"},
		{20, "boo"},
	}
	b := []typeB{
		{2.5, true},
		{3.5, false},
	}

	// 将原有切片转换为Storable接口切片
	storableA := make([]Storable, len(a))
	for i, item := range a {
		storableA[i] = item
	}
	if err := saveStorableSlice(storableA); err != nil {
		fmt.Println("Error saving typeA:", err)
	}

	storableB := make([]Storable, len(b))
	for i, item := range b {
		storableB[i] = item
	}
	if err := saveStorableSlice(storableB); err != nil {
		fmt.Println("Error saving typeB:", err)
	}
}

方案二说明： #

• 核心是利用Go的"鸭子类型"，只要结构体实现了Save()方法，就可以被saveStorableSlice处理。
• 优点：类型安全，编译期就能检查错误；每个结构体的存储逻辑封装在自身的Save方法中，代码更清晰、可维护。
• 缺点：需要给每个结构体添加Save方法，且需要手动将原有切片转换为接口切片。

方案选择建议 #

• 如果你的存储逻辑大部分是重复的，只是需要遍历切片，优先选反射方案，快速解决重复代码问题。
• 如果每个结构体的存储逻辑差异明显，或者你追求代码的可维护性和类型安全，优先选接口方案，更符合Go的设计思想。

内容的提问来源于stack exchange，提问作者stacker free ai trainer