如何访问Go语言接口类型数组中嵌套结构体的FieldBase字段

因为InterfaceA接口仅定义了FunA()方法，接口类型变量只能访问接口声明的成员，无法直接读取底层结构体的FieldBase字段，可通过以下几种方式解决：

方案一：扩展接口，添加字段访问方法 #

给InterfaceA新增获取FieldBase的方法，让所有实现该接口的结构体都实现此方法，即可直接通过接口变量访问字段。

import "fmt"

type InterfaceA interface {
    FunA()
    GetFieldBase() string // 新增字段访问方法
}

type BaseStruct struct {
    FieldBase string
}

type SubStruct struct {
    BaseStruct
}

func (c SubStruct) FunA() {}

func (c SubStruct) GetFieldBase() string {
    return c.FieldBase
}

type SubStruct2 struct {
    BaseStruct
}

func (c SubStruct2) FunA() {}

func (c SubStruct2) GetFieldBase() string {
    return c.FieldBase
}

func main() {
    var x = [2]InterfaceA{
        SubStruct{BaseStruct: BaseStruct{FieldBase: "aaa"}},
        SubStruct2{BaseStruct: BaseStruct{FieldBase: "bbb"}},
    }

    // 遍历数组直接访问字段
    for _, item := range x {
        fmt.Println(item.GetFieldBase())
    }
}

方案二：遍历数组时批量处理类型断言 #

如果不想修改原接口，可在遍历数组时，通过switch类型断言匹配所有可能的子类型，逐个访问字段。

import "fmt"

// 原类型定义保持不变
type InterfaceA interface {
    FunA()
}

type BaseStruct struct {
    FieldBase string
}

type SubStruct struct {
    BaseStruct
}

func (c SubStruct) FunA() {}

type SubStruct2 struct {
    BaseStruct
}

func (c SubStruct2) FunA() {}

func main() {
    var x = [2]InterfaceA{
        SubStruct{BaseStruct: BaseStruct{FieldBase: "aaa"}},
        SubStruct2{BaseStruct: BaseStruct{FieldBase: "bbb"}},
    }

    for _, item := range x {
        switch v := item.(type) {
        case SubStruct:
            fmt.Println(v.FieldBase)
        case SubStruct2:
            fmt.Println(v.FieldBase)
        default:
            fmt.Println("无法访问FieldBase")
        }
    }
}

方案三：利用结构体嵌入特性定义中间接口 #

定义一个新接口，给BaseStruct实现该接口的方法，所有嵌入BaseStruct的子类型会自动继承此方法，无需逐个实现。

import "fmt"

type InterfaceA interface {
    FunA()
}

// 定义新接口，要求具备字段访问能力
type HasFieldBase interface {
    GetFieldBase() string
}

type BaseStruct struct {
    FieldBase string
}

// 给BaseStruct实现方法，子类型自动继承
func (b BaseStruct) GetFieldBase() string {
    return b.FieldBase
}

type SubStruct struct {
    BaseStruct
}

func (c SubStruct) FunA() {}

type SubStruct2 struct {
    BaseStruct
}

func (c SubStruct2) FunA() {}

func main() {
    var x = [2]InterfaceA{
        SubStruct{BaseStruct: BaseStruct{FieldBase: "aaa"}},
        SubStruct2{BaseStruct: BaseStruct{FieldBase: "bbb"}},
    }

    for _, item := range x {
        if v, ok := item.(HasFieldBase); ok {
            fmt.Println(v.GetFieldBase())
        } else {
            fmt.Println("无法访问FieldBase")
        }
    }
}

方案对比 #

• 方案一符合Go接口设计原则，扩展性强，新增子类型只需实现接口方法即可。
• 方案二适合子类型少且固定的场景，但新增子类型时需修改switch分支，扩展性差。
• 方案三利用结构体嵌入特性，兼顾扩展性与代码简洁，无需给每个子类型重复实现方法。

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