泛型

是什么，为什么存在

泛型是带有一个或多个类型参数的函数或类型。调用泛型函数或实例化泛型类型时，具体类型会替换这些参数。编译器仍在编译期检查操作、参数和返回值，不需要调用方把结果从 any 断言回目标类型。

泛型解决的是跨类型重复但结构相同的代码。切片映射、集合查找和栈等代码只关心元素之间的类型关系，却不应为 int、string 和每个业务类型各写一份。类型参数把这种关系写进签名，例如 Map[T, U any]([]T, func(T) U) []U 表明转换函数的输入来自原切片，输出决定结果切片的元素类型。

接口与泛型解决的问题不同。接口值隐藏一个动态具体类型，适合让调用方通过一组方法使用不同实现；泛型在每次实例化中保留具体静态类型，适合算法和容器。若实现只调用 Read 或 String 这样的方法，普通接口参数往往更直接；若同一个类型出现在多个参数或返回位置，类型参数通常更能表达契约。

Go 1.18 加入了泛型。你会在标准库的 slices、maps 和 cmp 包、通用数据结构以及避免反射的辅助函数中遇到它。它不是消除所有重复代码的机制：当不同类型需要不同语义时，分别实现通常更清楚。

工作原理

类型参数保留类型关系

类型参数（type parameter） 写在声明名称后的方括号中。T、K 和 V 只是声明内部使用的类型名称；每个名称后都必须有约束。相邻参数约束相同时可以合写成 [T, U any]。

泛型函数的普通参数和返回值可以使用这些名称。泛型类型的字段也可以使用它们，而该类型的方法会在接收器中重新声明对应的接收器类型参数，例如 func (s *Stack[T]) Push(value T)。这里的 T 对应 Stack 的类型参数，不是方法新增的独立参数。

实例化包含两个检查。编译器先确认类型实参满足约束，再用这些实参建立具体的函数或类型实例。实例化后的 Stack[string] 与 Stack[int] 是不同的具名类型，二者不能相互赋值。

约束决定可写的操作

泛型约束（generic constraint） 是一种接口。它描述允许替换类型参数的 type set，也决定函数体中能对该参数执行哪些操作。约束为 any 时，代码只能依赖所有类型都具备的行为，例如赋值、传递和返回。

内置约束 comparable 接受可作为 map 键的类型，并允许 == 与 !=。它没有承诺顺序，所以 a < b 无法通过编译。需要顺序运算时，可以使用标准库的 cmp.Ordered，也可以声明只覆盖领域所需类型的约束。

约束接口可以嵌入方法、type term 或两者。fmt.Stringer 要求 String() string 方法；~int | ~int64 是一个 union，接纳底层类型为 int 或 int64 的类型。约束中各项取交集，因此同时写方法和 type term 时，类型必须满足两边。

类型集描述候选类型

类型集（type set） 是接口所代表的全部非接口类型集合。方法元素保留实现这些方法的类型，union 元素合并候选 type term，嵌入的多个元素再取交集。泛型代码只能使用集合中每个类型都支持且语义一致的操作。

普通 type term int 只表示预声明类型 int。~int 还包括 type Score int 这样的命名类型，因为它们的 底层类型（underlying type） 是 int。~ 不是近似运行时匹配；它是约束语法的一部分，由编译器静态判断。

包含 type term 的接口只能用作约束，不能作为普通变量类型。你可以写 func Max[T Ordered](...)，但不能声明 var value Ordered 来保存任意有序值。需要装入接口值时，应改用只含方法的基本接口，或明确使用 any 并在边界验证动态类型。

类型推断减少调用噪声

类型推断（type inference） 让编译器从函数实参和约束关系求出省略的类型实参。调用 Map(ids, strconv.Itoa) 时，ids 给出 T，函数值 strconv.Itoa 的签名给出 U。推断成功后，调用方不必写 Map[int, string]。

推断只适用于函数调用等规定的上下文，不会让泛型类型字面量凭字段值推断实参。Stack[string]{} 必须写出 string。函数调用也可能因没有足够信息而失败，例如某个类型参数只出现在返回值中；这时要显式提供类型实参，或重新设计签名，让输入携带所需关系。

未类型化常量会参与推断和表示性检查。混合不同种类的常量可能得到比预期更宽的默认类型，也可能找不到同时满足约束与实参的类型。API 的示例和测试应包含变量、命名类型和未类型化常量，而不只测试整数字面量。

泛型类型仍遵守零值规则

泛型结构体、切片别名式定义和其他具名类型在实例化后仍遵守普通 Go 规则。字段的零值由实际类型实参决定：var item T 对 int 是 0，对指针是 nil。当零值有业务含义时，只返回 T 无法表示操作是否成功。

泛型容器是否可零值使用，取决于其字段和方法。以切片作为存储的栈可以直接 append，因此零值很好用；以 map 作为存储的集合在第一次写入前必须初始化。构造函数、惰性初始化或文档化的零值契约都可以，关键是只选一种清楚的行为。

示例

映射时保留输入输出关系

第一个例子把发票编号转成标签。T 和 U 可以不同，调用点则完全依靠推断。返回类型仍是 []string，无需类型断言。

Map 的实现只分配结果、读取 T、调用转换函数并写入 U，所以 any 已经足够。给它增加数值 union 不会带来可用操作，只会无端拒绝字符串或结构体。这个签名的价值在于保留关系，不在于放宽运行时类型。

用 type set 接纳命名类型

这个最大值函数需要 >，因此声明真正支持顺序比较的 type set。Score 是独立的命名类型，但其底层类型为 int；~int 让它满足约束。空输入使用额外的布尔值与合法的零值区分。

package main

import "fmt"

type Ordered interface {
	~int | ~int64 | ~float64 | ~string
}

type Score int

func Max[T Ordered](values []T) (T, bool) {
	if len(values) == 0 {
		var zero T
		return zero, false
	}

	best := values[0]
	for _, value := range values[1:] {
		if value > best {
			best = value
		}
	}
	return best, true
}

func main() {
	best, ok := Max([]Score{72, 91, 84})
	fmt.Println(best, ok)

	empty, ok := Max([]Score(nil))
	fmt.Println(empty, ok)
}

91 true
0 false

如果把 ~int 改成 int，Score 就不再满足约束。函数不需要知道实际实参是不是 Score；约束已经证明 > 对所有候选类型有效。返回的 best 仍保持 Score 类型。

让泛型容器的零值可用

Stack[T] 的底层表示是切片。nil 切片可以 append，所以调用方不需要构造函数。Pop 返回 (T, bool)，避免把空栈与压入的零值混为一谈。

package main

import "fmt"

type Stack[T any] []T

func (s *Stack[T]) Push(value T) {
	*s = append(*s, value)
}

func (s *Stack[T]) Pop() (T, bool) {
	if len(*s) == 0 {
		var zero T
		return zero, false
	}

	last := len(*s) - 1
	value := (*s)[last]
	*s = (*s)[:last]
	return value, true
}

func main() {
	var stages Stack[string]
	stages.Push("review")
	stages.Push("publish")

	for range 3 {
		stage, ok := stages.Pop()
		fmt.Printf("%q %t\n", stage, ok)
	}
}

"publish" true
"review" true
"" false

接收器写成 *Stack[T]，因为 Push 和 Pop 都要替换切片描述符。元素类型仍由实例化时的 string 决定。若把存储改成 map，零值不再能安全写入，API 契约也必须随之改变。

陷阱

把 comparable 当成有序约束

切片、map 和函数不满足 comparable；多数标量、指针、通道、接口以及字段均可比较的数组和结构体满足它。但可比较不等于有顺序，布尔值和结构体就是直接反例。

修复方法： 使用标准库 cmp.Ordered，或声明只包含所需预声明类型及其命名类型的约束。若顺序来自业务规则，应接收比较函数，而不是假定 < 能表达该规则。

约束太宽却执行额外操作

把代码改成类型 switch 通常只是绕开静态关系，还会漏掉命名类型。它也会让新增类型分支变成运行时维护工作。

修复方法： 从函数体需要的操作推导约束。需要方法时嵌入方法接口；需要运算符时声明合适的 type term；其实只需传递值时保留 any。

忘记 ~ 后拒绝领域类型

强制调用方先转换成 int 会丢失有用的静态类型，还可能让不同领域的标识混在一起。约束是关于类型身份和底层类型的规则，不是一般的转换规则。

修复方法： 如果算法对所有底层类型相同的命名类型都有效，使用 ~int。如果业务上只允许精确的预声明类型，就保留 int，并把这种限制写进 API 文档和测试。

给方法新增类型参数

把所有未来可能用到的类型参数提前塞进接收器，会让每个实例化都携带无关参数。它还把一次操作的关系错误地提升为整个类型的身份。

修复方法： 需要引入 U 时写独立函数，例如 MapStack[T, U any](Stack[T], func(T) U) Stack[U]。只有当某个类型参数决定字段或所有方法的长期契约时，才把它放到泛型类型上。

用零值表示查找失败

生成代码常用 var zero T 避免编译错误，却没有处理调用方如何理解它。这个问题不是泛型独有，但类型参数会让零值形状在写函数时不可知。

修复方法： 返回 (T, bool) 或 (T, error)，由调用方显式处理缺失。只有当零值按领域契约就是唯一正确结果时，才返回单个 T。

延伸阅读

• Go 语言规范：类型参数声明
• Go 教程：泛型入门
• Go 博客：泛型简介
• 标准库 cmp.Ordered 文档