跳至主要內容

Go 泛型实战（Go 1.18+）——类型参数、约束、泛型数据结构完整使用指南

老张2026/4/30大约 8 分钟

Go 泛型实战（Go 1.18+）——类型参数、约束、泛型数据结构完整使用指南

适读人群：使用Go 1.18+、想用泛型写出通用代码的工程师 | 阅读时长：约18分钟 | 核心价值：Go泛型和Java泛型设计思路差异很大，用对了能显著减少重复代码

一、小赵的「重复代码地狱」

小赵在一家数据公司做Go后端，项目里有大量处理不同数据类型的工具函数：

// 过滤int slice
func FilterInts(nums []int, pred func(int) bool) []int { ... }
// 过滤string slice
func FilterStrings(strs []string, pred func(string) bool) []string { ... }
// 过滤User slice
func FilterUsers(users []User, pred func(User) bool) []User { ... }

三个函数逻辑完全一样，只是类型不同。Java里有泛型，一个 <T> 就搞定了。他转到Go时是1.17，没有泛型，只能用 interface{} 凑合：

func Filter(slice interface{}, pred interface{}) interface{} {
    // 一堆reflect代码，慢且不安全
}

升级到1.18之后，他终于用上了泛型，三行搞定：

func Filter[T any](slice []T, pred func(T) bool) []T {
    // 一个函数，所有类型通用
}

这就是泛型的价值所在。

二、Go泛型基础语法

类型参数

泛型函数在函数名后面用方括号声明类型参数：

package main

import "fmt"

// T是类型参数，any是约束（任意类型）
func Map[T, R any](slice []T, fn func(T) R) []R {
    result := make([]R, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

func Filter[T any](slice []T, pred func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if pred(v) {
            result = append(result, v)
        }
    }
    return result
}

func Reduce[T, R any](slice []T, initial R, fn func(R, T) R) R {
    result := initial
    for _, v := range slice {
        result = fn(result, v)
    }
    return result
}

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

    // Map：int → string
    strs := Map(nums, func(n int) string {
        return fmt.Sprintf("%d", n*n)
    })
    fmt.Println("Map:", strs) // [1 4 9 16 25]

    // Filter：保留偶数
    evens := Filter(nums, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println("Filter:", evens) // [2 4]

    // Reduce：求和
    sum := Reduce(nums, 0, func(acc, n int) int {
        return acc + n
    })
    fmt.Println("Reduce:", sum) // 15
}

三、约束（Constraints）

约束定义了类型参数必须满足的条件。Go的约束是接口，但可以包含类型集合：

内置约束

package main

import "fmt"

// any：任意类型（等价于 interface{}）
func Print[T any](v T) {
    fmt.Println(v)
}

// comparable：可以用==和!=比较的类型
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    Print(42)
    Print("hello")
    Print([]int{1, 2, 3})

    fmt.Println(Contains([]int{1, 2, 3}, 2))    // true
    fmt.Println(Contains([]string{"a", "b"}, "c")) // false
}

自定义约束

package main

import (
    "fmt"
    "golang.org/x/exp/constraints" // 需要 go get golang.org/x/exp
)

// 自定义约束：数字类型
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
        ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
        ~float32 | ~float64
}

// ~int 表示：底层类型是int的所有类型（包括自定义的type MyInt int）
type Celsius float64
type Fahrenheit float64

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

func Min[T Number](a, b T) T {
    if a < b {
        return a
    }
    return b
}

func Max[T Number](a, b T) T {
    if a > b {
        return a
    }
    return b
}

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

    fmt.Println("int sum:", Sum(ints))       // 15
    fmt.Println("float sum:", Sum(floats))   // 6.6
    fmt.Println("celsius sum:", Sum(temps))  // 157.1

    fmt.Println("min:", Min(3, 7))      // 3
    fmt.Println("max:", Max(3.14, 2.72)) // 3.14
}

四、泛型数据结构

泛型栈

package main

import (
    "errors"
    "fmt"
)

// 泛型栈
type Stack[T any] struct {
    items []T
}

func NewStack[T any]() *Stack[T] {
    return &Stack[T]{}
}

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

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

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

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

func main() {
    // int栈
    intStack := NewStack[int]()
    intStack.Push(1)
    intStack.Push(2)
    intStack.Push(3)

    for intStack.Size() > 0 {
        v, _ := intStack.Pop()
        fmt.Println(v) // 3, 2, 1
    }

    // string栈
    strStack := NewStack[string]()
    strStack.Push("hello")
    strStack.Push("world")

    top, _ := strStack.Peek()
    fmt.Println("top:", top) // world
}

泛型有序集合

package main

import (
    "fmt"
    "sort"
)

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

type SortedSet[T Ordered] struct {
    items []T
}

func (s *SortedSet[T]) Add(item T) {
    // 找到插入位置（保持有序）
    i := sort.Search(len(s.items), func(i int) bool {
        return s.items[i] >= item
    })
    // 已存在则不添加
    if i < len(s.items) && s.items[i] == item {
        return
    }
    s.items = append(s.items, item)
    copy(s.items[i+1:], s.items[i:])
    s.items[i] = item
}

func (s *SortedSet[T]) Contains(item T) bool {
    i := sort.Search(len(s.items), func(i int) bool {
        return s.items[i] >= item
    })
    return i < len(s.items) && s.items[i] == item
}

func (s *SortedSet[T]) Items() []T {
    return append([]T{}, s.items...) // 返回副本
}

func main() {
    set := &SortedSet[int]{}
    for _, v := range []int{5, 3, 1, 4, 1, 2, 3} {
        set.Add(v)
    }
    fmt.Println("有序集合:", set.Items()) // [1 2 3 4 5]
    fmt.Println("包含3:", set.Contains(3)) // true
    fmt.Println("包含6:", set.Contains(6)) // false

    strSet := &SortedSet[string]{}
    strSet.Add("banana")
    strSet.Add("apple")
    strSet.Add("cherry")
    fmt.Println("字符串集合:", strSet.Items()) // [apple banana cherry]
}

泛型Map工具函数

package main

import "fmt"

// Keys 获取map所有key
func Keys[K comparable, V any](m map[K]V) []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    return keys
}

// Values 获取map所有value
func Values[K comparable, V any](m map[K]V) []V {
    vals := make([]V, 0, len(m))
    for _, v := range m {
        vals = append(vals, v)
    }
    return vals
}

// MapValues 对map的所有value做变换
func MapValues[K comparable, V, R any](m map[K]V, fn func(V) R) map[K]R {
    result := make(map[K]R, len(m))
    for k, v := range m {
        result[k] = fn(v)
    }
    return result
}

func main() {
    scores := map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Carol": 92,
    }

    fmt.Println("Keys:", Keys(scores))
    fmt.Println("Values:", Values(scores))

    // 把分数变成等级
    grades := MapValues(scores, func(score int) string {
        switch {
        case score >= 90:
            return "A"
        case score >= 80:
            return "B"
        default:
            return "C"
        }
    })
    fmt.Println("Grades:", grades)
}

五、Go泛型 vs Java泛型的核心差异

维度JavaGo
类型擦除运行时类型信息被擦除不擦除，但单态化实现
约束extends/super（上界/下界通配符）interface（类型集合）
类型推断有限大部分场景可推断
基本类型必须用包装类（Integer等）直接支持int等基本类型
运算符约束不支持（需要Comparable接口）支持（~int等类型集合支持+-*/<等）
方法泛型完整支持支持（方法不能有独立类型参数，只能继承类型的）

Java的类型擦除 vs Go的单态化：

Java泛型在编译后，List<Integer> 和 List<String> 都变成 List，运行时无法区分。这就是为什么Java泛型里有很多限制（比如不能 new T()）。

Go的泛型采用「字典+部分单态化」策略：编译器为不同的类型参数可能生成不同的实现（指针类型共享，值类型可能单态化）。好处是没有类型擦除的限制，缺点是可能导致代码膨胀。

六、泛型的坑与限制

限制1：方法不能有自己的类型参数

package main

type MyType struct{}

// 错误：方法不能声明自己的类型参数
// func (m *MyType) Process[T any](v T) T { return v }

// 正确方案1：把类型参数放到struct上
type Processor[T any] struct{}
func (p *Processor[T]) Process(v T) T { return v }

// 正确方案2：用普通函数（推荐）
func Process[T any](v T) T { return v }

func main() {
    p := &Processor[int]{}
    _ = p.Process(42)
    
    _ = Process("hello")
    _ = Process(3.14)
}

限制2：不能直接实例化类型参数

package main

// 错误：不能直接 new T 或 T{}
// func NewInstance[T any]() *T {
//     return new(T)  // 这个实际上可以！
// }

// 但不能调用T的方法（除非约束里有）
func NewZero[T any]() T {
    var zero T // 可以：zero value
    return zero
}

func main() {
    _ = NewZero[int]()    // 0
    _ = NewZero[string]() // ""
}

限制3：约束必须显式声明，不能隐式推断

package main

import "fmt"

// 如果需要用+运算符，必须约束到支持+的类型
type Addable interface {
    ~int | ~float64 | ~string
}

func Add[T Addable](a, b T) T {
    return a + b
}

func main() {
    fmt.Println(Add(1, 2))         // 3
    fmt.Println(Add(1.5, 2.5))     // 4
    fmt.Println(Add("hello", " world")) // hello world
}

七、泛型最佳实践

什么时候用泛型：

  1. 函数逻辑完全相同，只是操作的类型不同（Filter、Map、Reduce等）
  2. 数据结构的实现与元素类型无关（Stack、Queue、Set等）
  3. 需要在保持类型安全的前提下处理多种类型

什么时候不用泛型：

  1. 接口能解决的问题，优先用接口（更符合Go习惯）
  2. 不同类型有不同的处理逻辑，用泛型反而更复杂
  3. 只有一两种类型，直接写两个具体函数更清晰

我的经验： 泛型最适合「容器」和「算法」，不适合「业务逻辑」。业务逻辑里不同类型通常有不同语义，泛型只会让代码更难理解。

小赵用泛型重构后，工具函数库从600行缩减到150行，而且新增类型时不需要修改任何工具函数。这才是泛型该发光的地方。

八、总结

Go 1.18的泛型虽然有一些限制（方法不能有独立类型参数、约束必须显式声明），但对于常见的通用容器和算法场景，已经足够用了。

核心要点：

  1. [T any]：任意类型参数
  2. [T comparable]：可以用==比较的类型
  3. 自定义约束：用interface + 类型集合（~T语法）
  4. 泛型struct：适合通用数据结构
  5. 约束要精确：只约束你真正需要的能力
编辑此页
最近更新:
贡献者: xiaozhangge