如何在Go函数中近似实现结构类型，规避重复类型断言与开闭原则违反？

问题背景 #

某库提供了一系列结构体T1、T2、T3等，它们都包含字段n，且均实现了标记接口S：

type T1 struct {
  n int
}
type T2 struct {
  n int
}
type T3 struct {
  n int
}

type S interface { 
   isS()
}

func (T1) isS() {}
func (T2) isS() {}
func (T3) isS() {}

尝试直接通过接口获取字段n的代码无法编译：

func getN(s S) int {
  return s.n // 编译错误：接口S没有字段n
}

当前通过逐个类型断言的方式实现，但库会频繁新增结构体，每次都要修改getN函数，严重违反开闭原则。

可行解决方案 #

1. 扩展接口定义（推荐，若可修改库代码） #

既然所有实现S的结构体都有n字段，最合理的方式是给S接口添加一个获取n的方法，让每个结构体实现该方法。这样新增结构体时只需实现方法，无需修改getN函数，完全符合开闭原则。

修改接口：

type S interface { 
   isS()
   GetN() int // 新增获取n的方法
}

为每个结构体实现GetN：

func (t T1) GetN() int {
    return t.n
}

func (t T2) GetN() int {
    return t.n
}

// 后续新增T4时，只需添加对应的实现
func (t T4) GetN() int {
    return t.n
}

简化后的getN函数：

func getN(s S) int {
    return s.GetN()
}

2. 使用反射（无法修改库时的妥协方案） #

如果没有权限修改库的接口，反射可以绕过接口限制直接读取结构体字段。只要新增的结构体仍保留int类型的n字段，getN函数无需任何修改。

import "reflect"

func getN(s S) int {
    val := reflect.ValueOf(s)
    // 确保传入的是结构体实例
    if val.Kind() != reflect.Struct {
        return 0 // 或根据业务需求返回错误值
    }
    // 获取名为n的字段
    nField := val.FieldByName("n")
    // 检查字段是否有效且类型为int
    if !nField.IsValid() || nField.Kind() != reflect.Int {
        return 0
    }
    return int(nField.Int())
}

注意：反射存在一定性能开销，且依赖字段名和类型的稳定性，若库后续修改n的字段名或类型，该方法会失效。

3. 优化类型断言（临时过渡方案） #

如果不想使用反射，可通过type switch简化原有的多分支断言，代码更简洁，但仍需在新增结构体时修改函数，不推荐长期使用：

func getN(s S) int {
    switch t := s.(type) {
    case T1:
        return t.n
    case T2:
        return t.n
    case T3:
        return t.n
    // 新增结构体时在此处添加case
    default:
        return 0 // 处理未知类型
    }
}

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