Go泛型实战：用类型参数编写类型安全的泛型工具与数据结构

泛型是 Go 1.18 引入的最重要特性之一。在泛型之前，要写一个支持多种类型的通用函数，要么靠 interface{} 配合类型断言（丢失编译期类型检查），要么靠代码生成（繁琐难维护）。泛型让我们可以在保证类型安全的前提下，编写「一份代码、多种类型」的通用工具。

本文用几个贴近日常开发的例子，讲清楚类型参数、类型约束，以及泛型在工具函数和数据结构中的实际用法。

一、从一个重复函数说起

没有泛型时，给 int64 和 float64 写求和，要么写两份几乎相同的代码，要么退回到 interface{}：

// 两份逻辑完全一致、只是类型不同的代码
func SumInt64(m map[string]int64) int64 {
	var s int64
	for _, v := range m {
		s += v
	}
	return s
}

func SumFloat64(m map[string]float64) float64 {
	var s float64
	for _, v := range m {
		s += v
	}
	return s
}

如果用 interface{} 强行合一，每次调用都要类型断言，类型错误只能在运行时暴露，编译器完全帮不上忙。

二、泛型函数：类型参数

泛型引入了「类型参数」的概念，用方括号声明。把求和改成泛型版本：

import "golang.org/x/exp/constraints"

// K 是键类型，V 是值类型
func SumMap[K comparable, V constraints.Ordered](m map[K]V) V {
	var zero V
	for _, v := range m {
		zero += v
	}
	return zero
}

调用时类型参数通常可以省略，编译器会自动推导：

ints := map[string]int64{"a": 1, "b": 2}
fmt.Println(SumMap(ints)) // 3，返回 int64

floats := map[string]float64{"x": 1.5, "y": 2.5}
fmt.Println(SumMap(floats)) // 4，返回 float64

这里有两个关键点：

• K comparable：键类型必须是「可比较」的，即能作为 map 的键、能进行 == 判断。
• V constraints.Ordered：值类型必须支持 >、<、+ 等运算，否则 zero += v 这一行无法通过编译。

三、自定义类型约束

标准库 constraints 提供了 Ordered、Number、Integer 等常用约束。你也可以定义自己的约束，例如限定一组数值类型：

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

注意 ~ 符号：~int 表示「底层类型是 int 的所有类型」，这样自定义类型也能通过约束：

type MyInt int

func Double[T Number](x T) T {
	return x + x
}

Double(MyInt(5)) // 合法，因为 MyInt 的底层类型是 int

如果只写 int 而不加 ~，MyInt 就无法使用这个泛型函数，这是新手最容易踩的坑。

四、泛型工具函数实战

下面几个工具函数在实际项目中非常常用。

1. 通用 Map：对切片做转换

func Map[T, U any](s []T, f func(T) U) []U {
	r := make([]U, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

// 把 []int 转换成 []string
nums := []int{1, 2, 3}
strs := Map(nums, func(n int) string {
	return strconv.Itoa(n)
})
// ["1" "2" "3"]

2. 通用 Filter：按条件过滤

func Filter[T any](s []T, keep func(T) bool) []T {
	r := make([]T, 0, len(s))
	for _, v := range s {
		if keep(v) {
			r = append(r, v)
		}
	}
	return r
}

evens := Filter(nums, func(n int) bool { return n%2 == 0 })

3. 通用 Reduce：聚合

func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
	acc := init
	for _, v := range s {
		acc = f(acc, v)
	}
	return acc
}

total := Reduce(nums, 0, func(acc, n int) int { return acc + n })

any 就是 interface{} 的别名，表示不做任何类型限制。配合函数类型参数，就能得到类似函数式编程的体验，同时全程有编译期类型检查，再也不用写大量类型断言。

五、泛型数据结构：以栈为例

泛型最大的价值之一，是让容器类型真正可用。以一个栈为例：

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, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}

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

使用方式：

var s Stack[string]
s.Push("hello")
s.Push("world")
v, ok := s.Pop() // "world", true

一个类型定义，Stack[string]、Stack[int]、Stack[*User] 都能用，而且取出的元素不需要类型断言。同样的模式可以写出泛型的集合、堆、LRU 缓存、并发安全的 map 等。

六、几个容易踩的坑

1. 不要为了泛型而泛型：如果一个函数只服务于一种具体类型，引入类型参数只会增加阅读成本。泛型适合「逻辑相同、类型不同」的场景。
2. 方法不能带额外的类型参数：Go 目前只允许普通函数声明类型参数，方法不能在接收者之外再引入新的类型参数；需要时请改用普通函数。
3. 泛型不是模板特化：Go 泛型通过类型字典与 GC shape 机制实现，不要指望它像 C++ 模板那样做激进的内联优化。
4. 类型约束要最小化：能用 any 就不要写更窄的约束，除非函数内部确实用到了相应运算；过窄的约束会让函数难以复用。

七、总结

• 泛型用「类型参数」让函数和类型可以参数化，any 表示无约束，comparable 表示可比较；
• 用 constraints 或自定义 interface 描述约束，~T 表示包含所有底层类型为 T 的类型；
• Map / Filter / Reduce 等工具函数，以及泛型容器，是泛型最常见的落地场景；
• 泛型保证了编译期类型安全，同时避免了大量重复代码。

从 Go 1.18 开始，标准库的 slices、maps 包也已经全面泛型化。熟悉泛型之后，建议直接阅读这两个包的源码——它们是泛型最佳实践的教科书。

泛型解决的是「重复」而非「复杂」。下次再要为每种类型复制一份工具函数时，不妨停下来想想：这里是不是可以交给一个类型参数。欢迎在评论区分享你的泛型实践。