Go中的泛型编程和reflect(反射)

此前一直对GO中的泛型编程和reflect（反射）的了解优点模糊不清，因此特意查了相关资料，在此梳理，以备后阅。

核心关系

两者都用于处理多种类型，但实现方式与使用场景不同。

主要区别

编译时 vs 运行时

泛型：编译时确定类型，零运行时开销

Go 复制代码

func Print[T any](value T) {
    fmt.Println(value)
}

反射：运行时动态获取类型信息，有性能开销

Go 复制代码

func PrintReflect(value interface{}) {
    v := reflect.ValueOf(value)
    fmt.Println(v.Interface())
}

类型安全

泛型

编译时类型检查
类型错误在编译期发现

反射

运行时类型检查
类型错误可能在运行时暴露

性能

泛型

编译时特化，性能接近手写代码
无运行时开销

反射

运行时动态处理，性能较低
需要类型断言和转换

互补关系

泛型无法替代反射的场景

动态类型处理

Go 复制代码

// 反射：运行时才知道具体类型
func ProcessUnknownType(data interface{}) {
    v := reflect.ValueOf(data)
    switch v.Kind() {
    case reflect.Slice:
        // 处理切片
    case reflect.Map:
        // 处理映射
    }
}

结构体字段遍历

Go 复制代码

// 反射：动态获取所有字段
func PrintFields(s interface{}) {
    t := reflect.TypeOf(s)
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Println(field.Name, field.Type)
    }
}

JSON/数据库映射

Go 复制代码

// 反射：根据标签动态处理
type User struct {
    Name string `json:"name" db:"user_name"`
    Age  int    `json:"age" db:"user_age"`
}

泛型可以替代反射的场景

泛型出现前（使用反射）：

Go 复制代码

// 旧方式：用反射实现通用容器
type Stack struct {
    items []interface{}
}

func (s *Stack) Push(item interface{}) {
    s.items = append(s.items, item)
}

func (s *Stack) Pop() interface{} {
    // 需要类型断言，不安全
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

泛型出现后（类型安全）：

Go 复制代码

// 新方式：用泛型实现类型安全的容器
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() T {
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item // 直接返回，无需类型断言
}

实际应用对比

场景 1：通用函数

反射方式：

Go 复制代码

func Max(a, b interface{}) interface{} {
    va := reflect.ValueOf(a)
    vb := reflect.ValueOf(b)
    // 需要大量类型判断和转换
    if va.Int() > vb.Int() {
        return a
    }
    return b
}

泛型方式：

Go 复制代码

func Max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

场景 2：需要两者结合

Go 复制代码

// 泛型提供类型安全
type Repository[T any] struct {
    items []T
}

// 反射提供动态能力
func (r *Repository[T]) FindByField(fieldName string, value interface{}) *T {
    for _, item := range r.items {
        v := reflect.ValueOf(item)
        field := v.FieldByName(fieldName)
        if field.IsValid() && field.Interface() == value {
            return &item
        }
    }
    return nil
}

总结

特性	泛型	反射
时机	编译时	运行时
性能	高（零开销）	较低
类型安全	编译时检查	运行时检查
适用场景	类型已知的通用代码	类型未知的动态处理
代码可读性	高	较低

最佳实践：

优先使用泛型：类型已知、需要类型安全、性能敏感
使用反射：需要动态类型处理、结构体字段遍历、序列化/反序列化
两者互补，泛型提升类型安全和性能，反射提供运行时灵活性。