第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 总结了反射三定律：
- 从接口值可以反射出反射对象：
reflect.TypeOf/ValueOf接收interface{}。 - 从反射对象可以还原出接口值：
Value.Interface()返回interface{}。 - 要修改反射对象，其值必须可设置（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 泛型有意保持克制，存在一些限制：
- 方法不能有自己独立的类型参数（只能用类型的类型参数）。
- 不能对类型参数做类型断言（需通过约束表达能力）。
- 泛型不能完全替代反射，二者适用场景不同。
最佳实践：
- 不要为了泛型而泛型。Go 谚语：”A little copying is better than a little dependency.”（少量重复优于不当抽象。）只有当确实需要对多种类型复用逻辑时才用泛型。
- 优先用于容器和算法：如集合操作、数据结构。
- 约束尽量精确：用最贴切的约束表达需求。
- 泛型 vs 接口：当不同类型有共同行为时用接口；当逻辑相同只是类型不同时用泛型。
13.9 反射与泛型的对比
| 维度 | 反射 | 泛型 |
|---|---|---|
| 类型检查 | 运行时 | 编译期 |
| 性能 | 慢 | 接近手写代码 |
| 安全性 | 低（易 panic） | 高 |
| 灵活性 | 极高（完全动态） | 受约束限制 |
| 适用 | 序列化、框架 | 容器、算法 |
许多过去依赖反射的场景，现在可用泛型更安全高效地实现。
13.10 本章小结
本章讲解了 Go 的两项高级特性。反射提供运行时类型检查与操作能力，是序列化等框架的基础，但有性能和安全代价，应谨慎使用。泛型（Go 1.18+）通过类型参数和约束，实现了类型安全的代码复用，特别适合通用容器和算法。理解二者的适用边界——能用泛型不用反射，不为抽象而抽象——是写出优雅 Go 代码的进阶能力。
下一章我们将深入 Go 的内存管理与垃圾回收机制。