Golang 泛型：类型参数、约束与示例

泛型函数

类型参数写在方括号里，放在普通参数之前。每个类型参数都有一个约束，规定允许哪些类型。

package main

import (
	"fmt"
	"strconv"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, it := range items {
		out = append(out, f(it))
	}
	return out
}

func main() {
	nums := []int{1, 2, 3}

	squares := Map(nums, func(n int) int { return n * n })
	fmt.Println(squares)

	labels := Map(nums, strconv.Itoa)
	fmt.Printf("%q\n", labels)

	lengths := Map([]string{"go", "rust", "c"}, func(s string) int { return len(s) })
	fmt.Println(lengths)
}

T 和 U 是从实参推断出来的，所以你很少需要写 Map[int, string](...)。推断依据的是函数的实参；只出现在返回值里的类型无法推断。对于 func Zero[T any]() T，你必须写 Zero[int]()。

在 Go 1.18 之前，这个函数要么为每种类型各写一遍，要么接收 []interface{}，从而失去类型安全。

约束

约束就是一个接口。它限制了可以使用哪些类型，作为交换，它也告诉编译器可以对该类型的值执行哪些操作。

package main

import (
	"cmp"
	"fmt"
)

func Index[T comparable](s []T, target T) int {
	for i, v := range s {
		if v == target { // needs comparable
			return i
		}
	}
	return -1
}

func Largest[T cmp.Ordered](s []T) T {
	m := s[0]
	for _, v := range s[1:] {
		if v > m { // needs cmp.Ordered
			m = v
		}
	}
	return m
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Largest([]float64{2.5, 9.1, 4.0}))
	fmt.Println(Largest([]string{"pear", "apple", "zucchini"}))
}

如果把 comparable 换成 any，v == target 就会编译失败：invalid operation: v == target (incomparable types in type set)。正是约束让这个运算符变得合法。

这两个辅助函数其实已经存在：slices.Index 和 slices.Max。标准库的 slices、maps 和 cmp 包涵盖了大多数日常的泛型需求，所以自己动手写之前先去查一查。

用类型联合和 ~ 自定义约束

约束可以用 | 列出多个类型。允许使用的运算符，是所有列出的类型都支持的那些。

package main

import "fmt"

type Number interface {
	~int | ~int64 | ~float64
}

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

type Cents int64

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{0.5, 0.25}))
	fmt.Println(Sum([]Cents{199, 250})) // works because of ~int64
}

波浪号很关键。~int64 表示“底层类型为 int64 的任意类型”，所以命名类型 Cents 也能被接受。如果写成普通的 int64，Sum([]Cents{...}) 就会失败，报错 Cents does not satisfy Number (possibly missing ~ for int64 in Number)。

包含类型联合的接口只能用作约束，不能用作普通变量的类型。var n Number 无法编译。

golang.org/x/exp/constraints 包提供了现成的 Integer、Float 和 Signed 约束。它不在标准库中，所以这里的运行环境无法导入它；标准库里对应的是 cmp.Ordered。

泛型类型

结构体、切片、map 等类型也可以有类型参数。泛型类型上的方法使用接收者的类型参数。

package main

import (
	"errors"
	"fmt"
)

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, errors.New("empty stack")
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}

func (s *Stack[T]) Len() int { return len(s.items) }

type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	var s Stack[string]
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println(v, s.Len())

	_, err := (&Stack[int]{}).Pop()
	fmt.Println(err)

	p := Pair[string, int]{Key: "age", Val: 31}
	fmt.Printf("%+v\n", p)
}

这个例子里有两个细节会经常遇到：

• T 的零值。 在泛型代码中，用 var zero T 返回“空”值。没有适用于所有类型的 T{} 或 nil。
• 实例化。 泛型类型在使用前必须实例化：写 Stack[string]，而不是 Stack。在它自己的方法里，接收者写作 Stack[T]。

Go 1.24 新增了泛型类型别名：type Set[T comparable] = map[T]struct{} 现在可以编译了。

你会遇到的限制

• 方法不能有类型参数。 func (s *Stack[T]) Map[U any](...) 是不允许的。改用顶层函数。
• 不支持特化。 你不能为 T = string 单独写一个实现。变通办法是在函数内部对 any(v) 做类型 switch，而这通常说明泛型并不是合适的工具。
• 不能按名字约束运算符。 你没法说“任何带 + 方法的类型”；只能在类型联合里逐一列出类型。
• 不能通过约束访问字段。 即使联合中的每个类型都有一个 ID 字段，也不允许写 v.ID。改为在约束里使用方法。

什么时候不该用泛型

泛型适合容器类型（栈、集合、缓存、树），以及对每种元素类型都执行相同操作的切片和 map 算法。它并非处处适用。

• 只有一种具体类型。 如果这个函数只会用 []User 调用，泛型版本只会增加阅读成本，别无好处。
• 行为随类型而不同。 这正是接口的用武之地。接收 io.Writer 的函数比接收 [T io.Writer] 的函数更简单，效果却一样。
• 替代接口参数。 func Print[T fmt.Stringer](v T) 并不比 func Print(v fmt.Stringer) 更好。

Go 团队自己的建议是：先针对具体类型写代码，当你发现自己第二次写同样的代码、只是换了类型时，再考虑使用类型参数。

常见错误

• 在需要 comparable 或 cmp.Ordered 的地方用了 any。 编译器会拒绝对 any 类型参数使用 == 或 <。
• 忘了写 ~。 像 type ID int 这样的自定义类型无法满足普通的 int 约束。
• 为类型参数返回 nil。 除非约束把 T 限定为类指针类型，否则不允许。返回零值。
• 写了一个早已存在的泛型辅助函数。 先查一查 slices、maps 和 cmp。