第12课：泛型 — 编写可复用的类型安全代码

所属模块：类型系统
难度：Intermediate
标签：generics, type-parameter, constraint
上一课：结构体嵌入与组合
下一课：错误处理

1. 学习目标

完成本课学习后，你将能够：

理解Go语言中泛型（Generics）出现的背景及其核心价值。
掌握使用类型参数（Type Parameter）定义泛型函数和泛型类型。
能够使用并自定义类型约束（Constraint）来限定类型参数的行为。
在合适的场景下应用泛型来提升代码的复用性与类型安全性。

2. 核心概念

在Go 1.18之前，如果你想写一个能够处理多种类型的函数（例如，一个返回切片中最小值的函数），你需要为每种类型（int, float64, string等）都写一个几乎一模一样的函数，或者使用interface{}但牺牲编译时类型安全。

泛型解决了这个问题。它允许你在定义函数、类型时，不指定具体的类型，而是使用一个“类型参数”作为占位符，这个占位符在调用时由具体的类型来填充。

你可以把泛型函数想象成一个“万能插头”模板，而类型参数就是插头的形状。定义函数时，我们先画一个通用插头形状（例如 [T any]），然后在函数体里使用这个形状。调用时，我们指定插头是方头的（int）还是圆头的（string），模板会自动生成对应的具体插头。

但仅仅有“任何类型”（any）是不够的。有些函数需要类型具备特定的能力，比如能比较大小。这时就需要类型约束（Constraint）。约束本质上是一个接口，它列出了类型参数必须满足的方法集（或底层类型集）。这样，我们在函数体内就能安全地调用这些方法。

3. 代码示例

示例1：基础泛型函数

一个能够比较任意两个可比较类型值并返回较大值的函数。

package main

import (
	"fmt"
	"cmp" // Go 1.21引入的比较包
)

// Max 是一个泛型函数。
// [T cmp.Ordered] 是类型参数列表，它声明了一个类型参数T。
// cmp.Ordered 是一个约束，表示T必须是任何有序类型（如整数、浮点数、字符串）。
func Max[T cmp.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	// 调用泛型函数时，有时可以不指定类型，让编译器推断
	intMax := Max(3, 5) // 编译器推断T为int
	fmt.Println(intMax) // 输出: 5

	// 也可以显式指定类型参数
	strMax := Max[string]("apple", "banana")
	fmt.Println(strMax) // 输出: banana
}

示例2：自定义约束与泛型类型

首先定义一个约束，然后创建一个使用该约束的泛型切片类型和处理函数。

package main

import "fmt"

// Number 是一个自定义约束，允许所有整数和浮点数类型。
type Number interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
	~float32 | ~float64
}

// Numbers 是一个泛型类型，表示一个元素类型为T的切片，其中T必须满足Number约束。
type Numbers[T Number] []T

// Sum 方法计算切片中所有元素的和。
func (n Numbers[T]) Sum() T {
	var sum T // 声明一个T类型的零值变量
	for _, val := range n {
		sum += val // 因为T满足Number约束，所以可以安全地使用+运算符
	}
	return sum
}

func main() {
	ints := Numbers[int]{1, 2, 3, 4, 5}
	fmt.Println(ints.Sum()) // 输出: 15

	floats := Numbers[float64]{1.1, 2.2, 3.3}
	fmt.Println(floats.Sum()) // 输出: 6.6
}

4. 实践练习

练习1（基础）：实现一个泛型函数 Filter，它接受一个任意类型的切片和一个函数作为参数，返回一个新切片，其中只包含使传入函数返回true的元素。

要求：函数签名应为 func Filter[T any](slice []T, f func(T) bool) []T
预期输出：Filter([]int{1, 2, 3, 4}, func(i int) bool { return i%2 == 0 }) 应返回 []int{2, 4}

练习2（中等）：实现一个泛型函数 Map，它接受一个任意类型的切片和一个转换函数，返回一个新切片，其中包含对原切片每个元素应用转换函数后的结果。

要求：函数签名应为 func Map[T, U any](slice []T, f func(T) U) []U
预期输出：Map([]int{1, 2, 3}, strconv.Itoa) 应返回 []string{"1", "2", "3"}

练习3（挑战）：定义一个泛型的Stack（栈）数据结构。栈应支持Push（入栈）、Pop（出栈）和Peek（查看栈顶）操作。

要求：使用切片作为底层存储。考虑如何定义Pop操作（当栈为空时返回什么？）。
提示：你的Stack类型可能像这样：type Stack[T any] struct { items []T }

5. 常见错误

约束定义不当：在约束中列出了方法或类型，但类型参数却使用了不满足这些条件的类型。例如，尝试对any约束的类型使用+运算符。

// 错误示范
func Add[T any](a, b T) T {
    return a + b // 编译错误：any约束未保证T支持+运算
}
// 正确做法：使用`int | float64`等包含+运算符的类型集合

类型参数名称冲突：在同一个函数或类型定义中，使用了和外部作用域同名的标识符。例如，函数外定义了变量T，函数内又用T作为类型参数。
```
var T = 10
// 错误示范
func MyFunc[T any](t T) {} // 编译器会提示T重复定义
```

忽略约束限制：在约束为接口（如Number）时，错误地尝试调用接口未定义的方法。

func Double[T Number](x T) T {
    // 错误：Number约束中没有String()方法，无法调用
    // fmt.Println(x.String())
    return x + x // 正确：Number约束保证了+运算可用
}

过早/过度使用泛型：对于逻辑简单、只处理单一类型的函数，使用泛型反而会增加理解成本。优先为重复出现的、处理多种类型的逻辑使用泛型。

6. 小结

本节课我们学习了Go语言的泛型特性：

核心价值：泛型允许我们编写类型安全且可复用的代码，避免了过去使用interface{}带来的运行时断言和类型转换，也减少了为每种类型编写重复代码的烦恼。
基本语法：通过 [T Constraint] 语法在函数或类型前声明类型参数。T是占位符名称，Constraint规定了T必须满足的条件。
类型约束：约束是泛型的核心。它通常是一个接口，定义了类型参数必须支持的操作。Go标准库提供了any和cmp.Ordered等常用约束。
应用场景：泛型非常适合用于实现通用的数据结构（如栈、队列、树、图）、算法函数（如过滤、映射、归约）以及需要处理多种类型的工具函数。

掌握泛型将使你能够编写出更加简洁、健壮和高效Go代码。下一步，我们将进入Go程序错误处理的世界。

泛型