Golang 范型

引言

Go 从 1.18 开始正式支持泛型，带来了更强的类型抽象能力，使得我们可以编写更通用、可复用的代码。本文档将介绍下泛型与应用的一些内容

什么是泛型

泛型（Generic）是一种允许你编写“参数化类型”的编程方式。你可以将类型视为函数的参数，在函数或结构体中使用不同的类型而不重复写代码。

这里我们用一个简单的例子介绍一下基本的应用。

• 求和函数的应用

无泛型写法

func SumInts(nums []int) int {
    total := 0
    for _, v := range nums {
        total += v
    }
    return total
}

func SumFloat64s(nums []float64) float64 {
    total := 0.0
    for _, v := range nums {
        total += v
    }
    return total
}

泛型写法

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

func Sum[T constraints.Integer | constraints.Float](nums []T) T {
    var total T
    for _, v := range nums {
        total += v
    }
    return total
}

调用代码

ints := []int{1, 2, 3}
floats := []float64{1.1, 2.2, 3.3}

fmt.Println(Sum(ints))    // 输出：6
fmt.Println(Sum(floats))  // 输出：6.6

看上去是不是一下就清爽多了？函数只写一次，类型可以变化 。这就是简单的泛型的应用。

那么对泛型你可以理解成一句话：

• 泛型是对类型做"参数化"处理，让函数或结构体能复用不同的数据类型，而不重复写代码。

用人话说就是：

• 我不想因为参数是 int 就写一遍函数，参数是 float64 又写一遍，我只想写一次，能通用就行。

Go 泛型应用

泛型函数

泛型函数允许你对函数的参数和返回值类型进行参数化。

基本语法：

func FuncName[T TypeConstraint](param T) T {
    // 函数体
}

例如：交换两个值

func Swap[T any](a, b T) (T, T) {
    return b, a
}

• T 是类型参数
• any 表示“任意类型”（等价于 interface{}）
  • 在 Go 1.18 之前（也就是泛型正式加入之前），interface{} 是 Go 中唯一的“通用类型”。它表示一个空接口，可以接受任何类型的值。
• (T, T) 表示返回两个同类型的值

泛型结构体

你也可以定义"带类型参数"的结构体或类型：

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 {
    n := len(s.items)
    item := s.items[n-1]
    s.items = s.items[:n-1]
    return item
}

泛型约束

Go 中泛型之所以能“限制”传入类型，是靠"约束"实现的。

常用约束方式：

• any

代表任何类型（最常用，类似 interface{}）

func Print[T any](val T) {
    fmt.Println(val)
}

• 使用 constraints 包（来自 golang.org/x/exp/constraints）

你需要先引入：

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

示例：支持排序的 Min 函数

func Min[T constraints.Ordered](a, b T) T {if a < b {return a
    }return b
}

注意事项

实际用例

通用 map 函数

func Map[T any, R any](in []T, f func(T) R) []R {
    out := make([]R, len(in))
    for i, v := range in {
        out[i] = f(v)
    }
    return out
}

总结

✅ 推荐使用泛型的场景：

• 你需要写工具类、公共库（如缓存、通用排序等）
• 同样的逻辑重复出现在多个类型中（int、float、string 等）
• 你想限制传入类型的范围，避免滥用 interface{}

❌ 不推荐使用泛型的场景：

• 项目中类型固定（比如订单 ID 永远是 int64）
• 团队成员不熟悉泛型，增加理解和维护成本
• 为“使用泛型而使用泛型”会让代码变复杂