Go泛型问题：如何用泛型处理含相同成员的不同结构体？

你遇到的编译错误是因为泛型参数T使用了any约束，编译器无法确认所有传入的T类型都包含val字段，因此无法解析elem.val。

解决方案 #

Go 1.18+的泛型需要通过类型约束来限定参数类型的范围，明确告知编译器该类型具备的字段或方法。以下是两种可行的实现方式：

方式一：基于方法的接口约束（灵活扩展）

定义一个接口，要求实现该接口的类型必须提供Val()方法来返回内部的val值，然后让Foo和Bar实现这个接口：

package main

import "fmt"

type Foo struct {
    val int
}

type Bar struct {
    val int
}

// 定义类型约束：拥有Val() int方法的类型
type HasVal interface {
    Val() int
}

// 为Foo实现Val方法
func (f Foo) Val() int {
    return f.val
}

// 为Bar实现Val方法
func (b Bar) Val() int {
    return b.val
}

// 修改泛型约束为HasVal
func Add[T HasVal](slice []T) int {
    var sum int
    for _, elem := range slice {
        sum += elem.Val()
    }
    return sum
}

func Test() {
    f1 := Foo{val: 2}
    f2 := Foo{val: 2}
    fslice := []Foo{f1, f2}
    fsum := Add(fslice)
    fmt.Printf("fsum = %d\n", fsum)

    b1 := Bar{val: 3}
    b2 := Bar{val: 3}
    bslice := []Bar{b1, b2}
    bsum := Add(bslice)
    fmt.Printf("bsum = %d\n", bsum)
}

func main() {
    Test()
}

方式二：基于结构体字段的约束（简洁直接）

直接通过结构体字段定义类型约束，适用于只需要访问特定字段的场景：

package main

import "fmt"

type Foo struct {
    val int
}

type Bar struct {
    val int
}

// 定义类型约束：包含val int字段的类型（~表示底层类型匹配即可）
type HasVal interface {
    ~struct{ val int }
}

// 修改泛型约束为HasVal
func Add[T HasVal](slice []T) int {
    var sum int
    for _, elem := range slice {
        sum += elem.val
    }
    return sum
}

func Test() {
    f1 := Foo{val: 2}
    f2 := Foo{val: 2}
    fslice := []Foo{f1, f2}
    fsum := Add(fslice)
    fmt.Printf("fsum = %d\n", fsum)

    b1 := Bar{val: 3}
    b2 := Bar{val: 3}
    bslice := []Bar{b1, b2}
    bsum := Add(bslice)
    fmt.Printf("bsum = %d\n", bsum)
}

func main() {
    Test()
}

原理说明 #

• 原代码中T any等价于T interface{}，这意味着T可以是任意类型，编译器无法保证所有类型都有val字段，因此报错。
• 通过类型约束HasVal，我们明确限定了T的范围：只有符合约束的类型（要么实现了Val()方法，要么包含val int字段）才能传入Add函数，编译器此时可以安全地解析对应的字段或方法。

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