Go 语言在 1.18 版本中引入了泛型（Generics）功能，解决了以往在编写通用代码时的一些痛点。泛型使得开发者可以编写更加灵活、可复用的代码，同时又保留了 Go 的类型安全。为了支持泛型，Go 引入了一些新的概念，如类型形参、类型形参列表、类型实参、类型约束等。

文章导航

一、Go 泛型的三大应用场景

Go 的泛型功能目前可以应用在三个主要场景中：

泛型类型：类型定义中带类型形参的类型。
泛型 Receiver：泛型类型作为方法的接收者。
泛型函数：带类型形参的函数。
泛型类型

泛型类型允许我们定义一个带有类型形参的类型，来使类型本身具有更高的灵活性。通过泛型类型，我们可以创建更加通用的数据结构，避免了重复编写类似的代码。

示例：

package main
import "fmt"
// 定义一个泛型结构体
type Pair[T any] struct {
    First  T
    Second T
}
func main() {
    // 使用泛型结构体，指定类型为 int
    p1 := Pair[int]{First: 1, Second: 2}
    fmt.Println(p1)
    // 使用泛型结构体，指定类型为 string
    p2 := Pair[string]{First: "Hello", Second: "World"}
    fmt.Println(p2)
}

在上述代码中，Pair[T any] 是一个带类型形参 T 的结构体。可以传入不同的类型 int 或 string，并且避免了重复定义多个结构体的需要。

泛型 Receiver

泛型 Receiver 允许我们为类型方法指定类型形参，方法的接收者也可以是一个带有类型形参的类型。这使得对象的方法也变得更加通用和灵活。

示例：

package main
import "fmt"
// 定义一个泛型结构体
type Box[T any] struct {
    Value T
}
// 定义一个泛型方法
func (b Box[T]) Display() {
    fmt.Println(b.Value)
}
func main() {
    // 泛型方法接收者类型为 int
    boxInt := Box[int]{Value: 42}
    boxInt.Display()
    // 泛型方法接收者类型为 string
    boxString := Box[string]{Value: "Generics in Go"}
    boxString.Display()
}

在上述代码中，Display 方法的接收者 Box[T] 是一个泛型类型。因此，Box 类型的接收者可以接受不同类型的数据，实现了类型的通用性。

泛型函数

泛型函数允许我们定义带有类型形参的函数，使得函数可以适应不同类型的输入。这是泛型编程中的一个非常常见的应用，可以大大提高代码的复用性

示例：

package main
import "fmt"
// 定义一个泛型函数
func Print[T any](value T) {
    fmt.Println(value)
}
func main() {
    Print(42)             // 输出 int 类型
    Print("Hello, Go!")   // 输出 string 类型
    Print(3.14)           // 输出 float64 类型
}

在这个例子中，Print 是一个泛型函数，它接受一个类型为 T 的参数，并打印它的值。通过泛型，Print 函数可以同时处理不同类型的参数。

二、实现泛型的概念与原理

为了实现泛型，Go 引入了一些新的概念，这些概念为泛型提供了强大的支持。理解这些概念能够帮助开发者更好地使用 Go 的泛型功能。

1.类型形参

类型形参是泛型的核心，它定义了一个通用类型的占位符。在定义泛型类型、方法或函数时，类型形参将作为占位符，等待在实际使用时指定具体类型。

示例：

type Pair[T any] struct {
    First  T
    Second T
}

在这个例子中，T 就是一个类型形参。

2.类型形参列表

类型形参列表是定义多个类型形参的地方。可以在一个泛型类型或方法中定义多个类型形参。

示例：

type Map[K comparable, V any] struct {
    Key   K
    Value V
}

在这个例子中，Map 类型接受两个类型形参：K 和 V。K 必须是 comparable 类型，这意味着它可以进行比较操作，而 V 是任意类型。

3.类型实参

类型实参是泛型类型或方法实例化时传入的具体类型。在实际使用泛型时，我们需要指定一个具体的类型实参来替代类型形参。

示例：

p1 := Pair[int]{First: 1, Second: 2}  // int 类型作为类型实参
p2 := Pair[string]{First: "Hello", Second: "World"}  // string 类型作为类型实参

4.类型约束

类型约束用于限制类型形参所允许的类型。在 Go 的泛型中，可以使用接口类型来定义类型约束，确保类型形参符合特定的要求。Go 1.18 版本引入了 any 和 comparable 等预定义类型约束，便于开发者定义灵活而安全的泛型代码。

示例：

type Addable[T any] interface {
    Add(a T, b T) T
}

在这个例子中，Addable 是一个类型约束接口，它限制了类型 T 必须实现 Add 方法。

5.实例化

泛型类型不能直接使用，必须在实际使用时通过类型实参进行实例化。只有通过类型实参，泛型类型才会被具体化成某一类型，从而才能使用。

示例：

type Pair[T any] struct {
    First  T
    Second T
}
p1 := Pair[int]{First: 1, Second: 2}  // 实例化为 Pair[int]
p2 := Pair[string]{First: "Hello", Second: "World"}  // 实例化为 Pair[string]