在Go语言1.18版本之前，编写通用代码是许多开发者的痛点。要么得为每种类型重复编写逻辑相似的代码，要么使用interface{}牺牲类型安全性。泛型的引入彻底改变了这一局面。

什么是泛型？

泛型，简单来说就是参数化类型。它允许我们在定义函数、结构体或接口时使用类型参数，在使用时再确定具体类型。

想象一下，你要编写一个加法函数。在没有泛型的情况下，你需要为每种数据类型编写单独的函数：

func AddInts(a, b int) int {
    return a + b
}

func AddFloats(a, b float64) float64 {
    return a + b
}

而使用泛型，只需一个函数就能搞定：

func Add[T int | float64](a, b T) T {
    return a + b
}

这里的T就是类型参数，int | float64是类型约束，表示T可以是int或float64类型。

为什么需要泛型？

1. 类型安全性

使用interface{}虽然灵活，但编译器无法在编译时进行类型检查，容易导致运行时错误。泛型通过在编译期进行类型检查，解决了这个问题。

2. 代码复用性

无需再为不同类型编写重复逻辑。一套泛型代码就能处理多种数据类型，大大减少了代码量。

3. 性能优化

泛型代码在编译期间会生成特定类型的实现，运行时不需要额外的类型检查或转换，性能接近手写特定类型代码。

泛型的基本用法

泛型函数

// 比较两个值的大小
func Max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// 使用
fmt.Println(Max(10, 20))        // 输出: 20
fmt.Println(Max(3.14, 2.71))    // 输出: 3.14

泛型结构体

// 通用的栈结构
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 {
    if len(s.items) == 0 {
        panic("stack is empty")
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

// 使用
stack := Stack[int]{}
stack.Push(1)
stack.Push(2)
fmt.Println(stack.Pop()) // 输出: 2

类型约束

我们可以定义自己的类型约束来控制泛型的类型范围：

type Number interface {
    int | float64
}

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

泛型的典型应用场景

1. 通用数据结构

泛型非常适合实现通用的数据结构，如列表、队列、堆栈、集合等。

// 通用集合类型
// 通用集合类型
type Set[T comparable] map[T]struct{}

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

func (s Set[T]) Contains(item T) bool {
    _, exists := s[item]
    return exists
}

2. 通用算法

排序、查找、过滤等算法不依赖具体数据类型，非常适合用泛型实现。

// 查找元素在切片中的索引
func FindIndex[T comparable](slice []T, target T) int {
    for i, v := range slice {
        if v == target {
            return i
        }
    }
    return -1
}

3. 函数式编程操作

// 映射函数：将切片中的每个元素转换为另一种类型
func Map[T any, R any](list []T, f func(T) R) []R {
    result := make([]R, len(list))
    for i, v := range list {
        result[i] = f(v)
    }
    return result
}

// 使用
numbers := []int{1, 2, 3}
squares := Map(numbers, func(x int) int { return x * x })
// squares = [1, 4, 9]

使用建议与注意事项

推荐使用泛型的场景：

  • 工具类、公共库：如通用缓存、集合类
  • 重复逻辑：同样的逻辑出现在多个类型处理中
  • 通用算法：排序、查找、过滤等

谨慎使用的场景：

  • 类型固定：如果项目中类型已经固定，不必强行使用泛型
  • 简单场景：如果接口已经能满足需求，可能不需要泛型
  • 团队熟悉度：如果团队成员对泛型不熟悉，过度使用会增加维护成本

注意事项：

  • 泛型类型不能使用运算符（如+、-、<、==等），除非加了对应约束
  • 编译器报错信息可能较晦涩
  • 二进制文件大小可能会增加

写在最后

Go语言的泛型为我们提供了一种强大的工具，使代码更加通用、类型安全且易于维护。通过类型参数和类型约束，我们可以写出既灵活又安全的代码。

虽然泛型功能强大，但也要根据实际情况权衡使用。在简单场景下，接口可能更为直观；而在需要类型安全的复杂逻辑中，泛型则是不二之选。