Go 泛型实战：类型参数、约束与实际模式

Go 在 1.18 版本中加入了泛型（类型参数），到 2026 年，生态系统已经就何时以及如何有效使用泛型形成了清晰的模式。本指南涵盖实践方面：从基本语法到实际集合实现，再到理解性能影响。

基本泛型函数

泛型最简单的用法是编写一个适用于多种类型的函数：

package main

import (
    "cmp"
    "fmt"
)

// 无泛型：多个函数
func MinInt(a, b int) int {
    if a < b { return a }
    return b
}

// 使用泛型和 cmp.Ordered 约束
func Min[T cmp.Ordered](a, b T) T {
    if a < b { return a }
    return b
}

func main() {
    fmt.Println(Min(3, 5))
    fmt.Println(Min(3.14, 2.71))
    fmt.Println(Min("apple", "banana"))
}

类型约束

约束限制了哪些类型可以用作类型实参：

type Number interface {
    int | int8 | int16 | int32 | int64 |
    uint | uint8 | uint16 | uint32 | uint64 |
    float32 | float64
}

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

// ~T：底层类型约束（包含命名类型）
type MyInt int

type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

func Double[T Integer](x T) T {
    return x * 2
}

func main() {
    ints := []int{1, 2, 3, 4, 5}
    floats := []float64{1.1, 2.2, 3.3}

    fmt.Println(Sum(ints))   // 15
    fmt.Println(Sum(floats)) // 6.6

    var m MyInt = 5
    fmt.Println(Double(m)) // 10
}

comparable 和 any 约束

comparable 允许 == 和 != 操作，支持 map 和相等性检查：

type Set[T comparable] struct {
    items map[T]struct{}
}

func NewSet[T comparable]() *Set[T] {
    return &Set[T]{items: make(map[T]struct{})}
}

func (s *Set[T]) Add(item T) {
    s.items[item] = struct{}{}
}

func (s *Set[T]) Contains(item T) bool {
    _, ok := s.items[item]
    return ok
}

func (s *Set[T]) Remove(item T) {
    delete(s.items, item)
}

func (s *Set[T]) Size() int {
    return len(s.items)
}

func (s *Set[T]) Union(other *Set[T]) *Set[T] {
    result := NewSet[T]()
    for k := range s.items {
        result.Add(k)
    }
    for k := range other.items {
        result.Add(k)
    }
    return result
}

func (s *Set[T]) Intersection(other *Set[T]) *Set[T] {
    result := NewSet[T]()
    for k := range s.items {
        if other.Contains(k) {
            result.Add(k)
        }
    }
    return result
}

泛型集合

类型安全的栈

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

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

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

func (s *Stack[T]) Peek() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    return s.items[len(s.items)-1], true
}

泛型队列

type Queue[T any] struct {
    items []T
    head  int
}

func (q *Queue[T]) Enqueue(item T) {
    q.items = append(q.items, item)
}

func (q *Queue[T]) Dequeue() (T, bool) {
    if q.head >= len(q.items) {
        var zero T
        return zero, false
    }
    item := q.items[q.head]
    q.head++
    // 当 head 前进足够远时压缩
    if q.head > len(q.items)/2 {
        q.items = q.items[q.head:]
        q.head = 0
    }
    return item, true
}

泛型工具函数

标准库（Go 1.21+）中的 slices 和 maps 包提供了泛型工具：

import (
    "slices"
    "maps"
    "cmp"
)

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

    // 使用泛型排序
    slices.Sort(nums)
    fmt.Println(nums) // [1 1 2 3 4 5 6 9]

    // 二分查找
    idx, found := slices.BinarySearch(nums, 5)
    fmt.Printf("Found 5 at index %d: %v\n", idx, found)

    // Map 操作
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    keys := slices.Sorted(maps.Keys(m))
    fmt.Println(keys)
}

自定义泛型工具：

// Filter：返回匹配谓词的元素
func Filter[T any](slice []T, predicate func(T) bool) []T {
    result := make([]T, 0)
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

// Map：转换每个元素
func Map[T, U any](slice []T, transform func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = transform(v)
    }
    return result
}

// Reduce：将切片折叠为单个值
func Reduce[T, U any](slice []T, initial U, combine func(U, T) U) U {
    result := initial
    for _, v := range slice {
        result = combine(result, v)
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    evens := Filter(nums, func(n int) bool { return n%2 == 0 })
    fmt.Println(evens) // [2 4 6 8 10]

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

    sum := Reduce(nums, 0, func(acc, n int) int { return acc + n })
    fmt.Println(sum) // 55
}

何时使用泛型

泛型何时增加价值，何时坚持使用接口的指南：

// 使用泛型的情况：
// 1. 算法对多种类型相同
func Contains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {
            return true
        }
    }
    return false
}

// 2. 需要类型安全的集合
type Cache[K comparable, V any] struct {
    mu    sync.RWMutex
    items map[K]V
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.items[key]
    return v, ok
}

// 使用接口的情况：
// 行为因类型而异（多态）
type Writer interface {
    Write(p []byte) (n int, err error)
}

// 接口还允许运行时调度；泛型是编译时

性能影响

Go 中的泛型通过 GC shapes（字典传递）实现，这可能会带来性能影响：

// 基准测试泛型函数与特定函数
// 通常：泛型与具体类型结合会编译为优化代码
// 基于接口：一个实现，运行时调度

// 性能关键代码：考虑特定实现
func SumInt(nums []int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// 泛型版本 - 由于 GC shape 开销，在非常热的循环中可能稍慢，
// 但对大多数用例来说可以忽略不计
func SumGeneric[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

实用泛型模式

用于错误处理的 Result 类型

type Result[T any] struct {
    value T
    err   error
}

func Ok[T any](v T) Result[T] {
    return Result[T]{value: v}
}

func Err[T any](err error) Result[T] {
    return Result[T]{err: err}
}

func (r Result[T]) Unwrap() T {
    if r.err != nil {
        panic(r.err)
    }
    return r.value
}

func (r Result[T]) IsOk() bool {
    return r.err == nil
}

Optional 类型

type Option[T any] struct {
    value *T
}

func Some[T any](v T) Option[T] {
    return Option[T]{value: &v}
}

func None[T any]() Option[T] {
    return Option[T]{}
}

func (o Option[T]) IsSome() bool {
    return o.value != nil
}

func (o Option[T]) Unwrap() T {
    if o.value == nil {
        panic("called Unwrap on None")
    }
    return *o.value
}

结论

Go 泛型在类型安全的集合、工具函数以及跨类型结构相同的算法方面表现出色。关键在于克制：当你确实需要消除代码重复并保持类型安全时使用泛型。不要泛化一切——当需要运行时多态时，接口仍然是正确的工具。到 2026 年，模式已经清晰：泛型用于数据结构和算法，接口用于行为。