50. 泛型类型推断与要点

类型推断

Go 编译器能根据函数参数自动推断类型参数，大多数时候你不用手写：

func First[T any](s []T) T {
    return s[0]
}

// 编译器从参数推断出 T = int
first := First([]int{1, 2, 3})    // 不用写 First[int](...)

// 推断出 T = string
second := First([]string{"a", "b"}) // 不用写 First[string](...)

什么时候需要手动指定

类型推断不是万能的。以下情况需要手动写类型实参：

1. 参数不足以推断类型：

func Zero[T any]() T {
    var zero T
    return zero
}

// 没有参数，推断不出来
v := Zero[int]() // 必须手动指定

2. 多个类型参数推断不全：

func Convert[T any, U any](v T) U {
    // ...
}

// T 能从参数推断，但 U 推断不出来
result := Convert[int, string](42)

3. 推断结果不符合预期：

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

// 传入 int 和 float64，编译器不知道 T 该是哪个
// Max(1, 2.5) // 编译错误
Max(1.0, 2.5) // OK，都是 float64

泛型 vs 接口：怎么选

泛型和接口都能实现「一段代码处理多种类型」，但适用场景不同。

用泛型的场景

• 逻辑和类型无关：同样的算法对多种类型都适用（排序、查找、转换）
• 需要类型安全：编译期检查类型，避免运行时 panic
• 需要返回具体类型：调用方拿到的不是 any，是确定的类型
• 数据结构：栈、队列、树等容器类型

// 泛型：类型安全，返回具体类型
func Map[T, U any](s []T, f func(T) U) []U { ... }

用接口的场景

• 需要多态行为：不同类型有不同的实现逻辑
• 运行时动态分派：直到运行时才知道具体类型
• 需要类型断言：需要根据类型走不同分支

// 接口：不同类型不同行为
type Speaker interface {
    Speak() string
}

对比表

维度	泛型	接口
类型检查	编译期	运行时
性能	直接操作具体类型	有间接调用开销
返回类型	具体类型	接口类型
灵活性	同一逻辑多类型	不同实现多态
复杂度	语法稍复杂	简单直观

常见陷阱

泛型类型不能做类型断言

func Process[T any](v T) {
    // v.(int) // 编译错误：泛型类型不能断言
    switch v.(type) { // 编译错误：泛型类型不能 type switch
    }
}

如果需要根据类型做不同操作，不应该用泛型，用 any + type switch：

func Process(v any) {
    switch v := v.(type) {
    case int:
        fmt.Println("整数:", v)
    case string:
        fmt.Println("字符串:", v)
    }
}

泛型零值不是 nil

func GetOrDefault[T any](m map[string]T, key string) T {
    if v, ok := m[key]; ok {
        return v
    }
    var zero T
    return zero // 零值，不一定是 nil
}

泛型零值用 var zero T 声明。对于指针、切片、map 等引用类型，零值是 nil；对于数字，零值是 0；对于字符串，零值是 ""。

不能用泛型类型做 map 的 key（除非 comparable）

// T any 不行，因为 map key 必须可比较
func Count[T any](items []T) map[T]int { // 编译错误
}

// T comparable 才行
func Count[T comparable](items []T) map[T]int {
    counts := make(map[T]int)
    for _, item := range items {
        counts[item]++
    }
    return counts
}

泛型方法不支持

type Box[T any] struct{ Value T }

// 编译错误：方法不能有自己的类型参数
func (b *Box[T]) Convert[U any](f func(T) U) U {
    return f(b.Value)
}

// 改成泛型函数
func Convert[T any, U any](b *Box[T], f func(T) U) U {
    return f(b.Value)
}

性能影响

Go 的泛型采用的是 GC Shape Stenciling 策略，是编译期单态化和运行时字典的折中方案：

• 同一种「内存形状」的类型共享一份代码
• 指针类型共享一份代码（因为所有指针大小一样）
• 具体值类型（int、float64 等）各生成一份代码

这意味着泛型代码的性能接近手写的具体类型版本，远好于用 any 接口（省去了装箱拆箱）。

小结

泛型使用的要点：

• 类型推断能省略类型实参，但不是所有情况都能推断
• 逻辑和类型无关用泛型，逻辑因类型而异用接口
• 泛型类型不能做类型断言和 type switch
• 泛型零值用 var zero T，不一定是 nil
• 方法不能有自己的类型参数

下一部分进入错误处理，Go 编程中最重要的主题之一。