Go语言中遍历混合类型切片并访问结构体字段的方法

方法一：类型断言 #

因为你的items切片存储的是interface{}类型，遍历的时候需要将其断言为具体的struct类型，才能访问对应的字段。修改循环部分即可：

for _, item := range items {
    switch v := item.(type) {
    case X:
        fmt.Println("Type:", v.Type, "Num:", v.Num)
    case Y:
        fmt.Println("Type:", v.Type, "Num:", v.Num)
    case Z:
        fmt.Println("Type:", v.Type, "Num:", v.Num)
    default:
        fmt.Println("未知类型")
    }
}

通过switch类型断言匹配每个具体的struct类型，就能直接访问Type和Num字段。

方法二：定义公共接口 #

既然三个struct都包含Type和Num字段，可以定义一个公共接口，让这些struct隐式实现该接口，之后切片直接存储接口类型，遍历的时候就能统一访问字段（或通过接口方法）。

首先定义接口并给每个struct实现接口方法：

type Item interface {
    GetType() string
    GetNum() int
}

func (x X) GetType() string { return x.Type }
func (x X) GetNum() int    { return x.Num }

func (y Y) GetType() string { return y.Type }
func (y Y) GetNum() int    { return y.Num }

func (z Z) GetType() string { return z.Type }
func (z Z) GetNum() int    { return z.Num }

然后修改main函数中的切片类型：

func main() {
    var items []Item
    x := X{Type: "X-type", Num: 1}
    items = append(items, x)

    y := Y{Type: "Y-type", Num: 2}
    items = append(items, y)

    z := Z{Type: "Z-type", Num: 3}
    items = append(items, z)

    for _, item := range items {
        fmt.Println("Type:", item.GetType(), "Num:", item.GetNum())
    }
}

这种方式符合Go的面向接口编程思想，扩展性更好，后续新增类似struct时，只需实现接口方法即可。

方法三：使用反射 #

如果不想修改现有struct结构或定义接口，可以使用reflect包动态获取字段值，适合字段名统一的场景：

import "reflect"

// 原struct定义不变

func main() {
    var items []interface{}
    // 原append代码不变

    for _, item := range items {
        val := reflect.ValueOf(item)
        if val.Kind() == reflect.Struct {
            typeField := val.FieldByName("Type")
            numField := val.FieldByName("Num")
            if typeField.IsValid() && numField.IsValid() {
                fmt.Println("Type:", typeField.String(), "Num:", numField.Int())
            }
        }
    }
}

反射方式灵活性高，但性能略低、代码可读性较差，适合特殊场景下使用。

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