第13章 - 反射与泛型

本章讲解 Go 两项强大但需谨慎使用的高级特性：反射（reflection）允许程序在运行时检查和操作类型与值；泛型（generics，Go 1.18 引入）允许编写类型参数化的可复用代码。

13.1 反射基础

反射是程序在运行时检查自身结构（类型、字段、方法）并动态操作的能力。Go 的反射由 reflect 包提供，核心是两个类型：reflect.Type 和 reflect.Value。

13.1.1 Type 与 Value

import "reflect"

x := 42
t := reflect.TypeOf(x)   // 获取类型信息：int
v := reflect.ValueOf(x)  // 获取值信息：42

fmt.Println(t.Kind())    // int（底层种类）
fmt.Println(v.Int())     // 42（提取具体值）

• Type 描述类型的元信息（名称、种类、字段、方法等）。
• Value 持有实际的值，可读取甚至修改。
• Kind 表示底层种类（如 Int、Struct、Slice、Ptr），区别于具体 Type。

13.1.2 反射三定律

Go 作者 Rob Pike 总结了反射三定律：

1. 从接口值可以反射出反射对象：reflect.TypeOf/ValueOf 接收 interface{}。
2. 从反射对象可以还原出接口值：Value.Interface() 返回 interface{}。
3. 要修改反射对象，其值必须可设置（settable）：必须传入指针并通过 Elem() 获取可寻址的值。

13.2 通过反射操作结构体

反射最常见的用途是处理结构体字段和标签，这是序列化库（如 encoding/json）的实现基础：

type User struct {
    Name  string `json:"name" validate:"required"`
    Age   int    `json:"age"`
}

func inspect(obj any) {
    t := reflect.TypeOf(obj)
    v := reflect.ValueOf(obj)

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        fmt.Printf("字段: %s, 类型: %s, 值: %v, json标签: %s\n",
            field.Name, field.Type, value.Interface(),
            field.Tag.Get("json"))
    }
}

inspect(User{Name: "Alice", Age: 30})

13.2.1 修改值

要通过反射修改值，必须传入指针：

func setName(obj any, name string) {
    v := reflect.ValueOf(obj).Elem() // 解引用指针，获得可设置的 Value
    field := v.FieldByName("Name")
    if field.CanSet() {
        field.SetString(name)
    }
}

u := &User{}
setName(u, "Bob")
fmt.Println(u.Name) // Bob

13.3 反射的代价与适用场景

反射功能强大，但有显著缺点：

• 性能开销大：反射操作比直接代码慢得多。
• 失去编译期类型检查：错误推迟到运行时，容易 panic。
• 代码可读性差：难以理解和维护。

适用场景：序列化/反序列化（JSON、ORM）、依赖注入框架、通用工具库。原则：能用普通代码或泛型解决的，就不要用反射。

13.4 泛型简介

泛型是 Go 1.18 引入的重大特性，允许函数和类型使用类型参数，在保持类型安全的同时实现代码复用。在泛型出现之前，编写通用容器或算法只能依赖 interface{}（牺牲类型安全和性能）或为每种类型重复编写代码。

13.5 泛型函数

类型参数写在函数名后的方括号 [] 中：

// T 是类型参数，any 是其约束（接受任意类型）
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := []int{1, 2, 3}
strs := Map(nums, func(n int) string {
    return strconv.Itoa(n)
}) // ["1" "2" "3"]

13.5.1 类型约束

约束限定了类型参数允许的类型集合。any 表示任意类型，但若函数体需要特定操作（如比较、运算），需使用更具体的约束。

comparable 是内置约束，表示可用 == 比较的类型：

func Contains[T comparable](s []T, target T) bool {
    for _, v := range s {
        if v == target {
            return true
        }
    }
    return false
}

13.5.2 自定义约束

约束本质上是接口。可以用接口定义类型集合，| 表示并集，~ 表示底层类型：

type Number interface {
    ~int | ~int64 | ~float64 // ~ 表示底层类型为这些的也满足
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

Sum([]int{1, 2, 3})           // 6
Sum([]float64{1.1, 2.2})      // 3.3

~int 中的波浪号表示：不仅 int 本身，所有底层类型为 int 的自定义类型（如 type MyInt int）也满足约束。

13.5.3 constraints 包

golang.org/x/exp/constraints 提供了常用约束（Ordered、Integer、Float 等）。其中 Ordered 约束已可通过标准库 cmp.Ordered（Go 1.21+）使用：

import "cmp"

func Max[T cmp.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

13.6 泛型类型

类型也可以泛型化，常用于实现通用数据结构：

// 泛型栈
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, bool) {
    var zero T
    if len(s.items) == 0 {
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

// 使用
s := &Stack[int]{}
s.Push(1)
s.Push(2)
val, ok := s.Pop() // 2, true

13.7 类型推断

调用泛型函数时，编译器通常能从参数自动推断类型参数，无需显式指定：

Sum([]int{1, 2, 3})        // 自动推断 T = int
Sum[int]([]int{1, 2, 3})   // 也可显式指定

13.8 泛型的限制与最佳实践

Go 泛型有意保持克制，存在一些限制：

• 方法不能有自己独立的类型参数（只能用类型的类型参数）。
• 不能对类型参数做类型断言（需通过约束表达能力）。
• 泛型不能完全替代反射，二者适用场景不同。

最佳实践：

1. 不要为了泛型而泛型。Go 谚语："A little copying is better than a little dependency."（少量重复优于不当抽象。）只有当确实需要对多种类型复用逻辑时才用泛型。
2. 优先用于容器和算法：如集合操作、数据结构。
3. 约束尽量精确：用最贴切的约束表达需求。
4. 泛型 vs 接口：当不同类型有共同行为时用接口；当逻辑相同只是类型不同时用泛型。

13.9 反射与泛型的对比

许多过去依赖反射的场景，现在可用泛型更安全高效地实现。

13.10 本章小结

本章讲解了 Go 的两项高级特性。反射提供运行时类型检查与操作能力，是序列化等框架的基础，但有性能和安全代价，应谨慎使用。泛型（Go 1.18+）通过类型参数和约束，实现了类型安全的代码复用，特别适合通用容器和算法。理解二者的适用边界——能用泛型不用反射，不为抽象而抽象——是写出优雅 Go 代码的进阶能力。

下一章我们将深入 Go 的内存管理与垃圾回收机制。