Go语言的泛型（Generics）在Go 1.18版本中得到了引入，它使得Go语言能够编写更灵活和可复用的代码，而无需丧失类型安全。Go的泛型主要通过类型参数（type parameters）来实现，允许你编写接受不同类型的函数、结构体或接口。
Go 泛型的核心概念是 类型参数，它允许你定义接受不同类型的函数、结构体或接口。你可以把类型参数看作是占位符，编译器会根据调用时的实际类型来替换它。
Life is like a journey
func Print[T any](value T) {
fmt.Println(value)
}
T 是类型参数，可以代表任何类型。any 是类型约束，表示 T 可以是任意类型，相当于旧版本的 interface{}。Go 泛型允许你对类型参数指定 类型约束，以确保类型参数满足某些条件。你可以通过接口来定义这些约束。
类型约束是通过接口来实现的，接口可以声明类型必须实现的方法或属性。
package main
import "fmt"
// 定义一个接口约束，要求类型参数 T 必须实现 String() 方法
type Stringer interface {
String() string
}
// 泛型函数，限制 T 必须实现 Stringer 接口
func PrintString[T Stringer](s T) {
fmt.Println(s.String())
}
type Person struct {
Name string
}
func (p Person) String() string {
return p.Name
}
func main() {
p := Person{Name: "John"}
PrintString(p) // 输出: John
}
在上面的代码中，Stringer 是一个接口，T 类型参数被约束为实现了 String() 方法的类型。
你可以为类型参数指定多个约束，这样类型参数必须满足所有约束条件。例如，可以让类型同时满足多个接口：
type Adder interface {
Add(a, b int) int
}
type Printer interface {
Print()
}
type MyStruct struct{}
func (m MyStruct) Add(a, b int) int {
return a + b
}
func (m MyStruct) Print() {
fmt.Println("Printing...")
}
type MyGeneric[T Adder & Printer] struct {
Value T
}
func (g MyGeneric[T]) ShowValue() {
fmt.Println(g.Value)
}
func main() {
ms := MyStruct{}
g := MyGeneric[MyStruct]{Value: ms}
g.ShowValue() // 输出 MyStruct
}
这里，MyGeneric[T] 限制 T 必须同时实现 Adder 和 Printer 接口。
泛型函数使得函数能够处理任意类型的数据。除了 any，你还可以使用接口来进行类型约束。
package main
import "fmt"
// 泛型函数
func Print[T any](value T) {
fmt.Println(value)
}
func main() {
Print(42) // 输出: 42
Print("hello") // 输出: hello
}
在这个例子中，Print 函数可以接收任意类型的参数，因为 T any 表示类型 T 可以是任何类型。
package main
import "fmt"
// 定义一个类型约束接口
type Adder interface {
Add(a, b int) int
}
func Sum[T Adder](a T, x, y int) int {
return a.Add(x, y)
}
type MyStruct struct{}
func (m MyStruct) Add(a, b int) int {
return a + b
}
func main() {
ms := MyStruct{}
result := Sum(ms, 5, 3) // 输出: 8
fmt.Println(result)
}
这个例子展示了泛型函数 Sum，它接收一个实现了 Adder 接口的类型 T，并返回加法结果。
Go 泛型不仅可以用在函数中，还可以用在结构体中。通过定义泛型结构体，你可以让结构体接受任意类型的数据。
package main
import "fmt"
// 定义一个泛型结构体
type Box[T any] struct {
Value T
}
// 泛型方法
func (b Box[T]) GetValue() T {
return b.Value
}
func main() {
intBox := Box[int]{Value: 42}
stringBox := Box[string]{Value: "Hello"}
fmt.Println(intBox.GetValue()) // 输出: 42
fmt.Println(stringBox.GetValue()) // 输出: Hello
}
在这个例子中，Box[T any] 是一个泛型结构体，它可以存储任意类型的值。GetValue 方法返回存储的值。
Go 编译器会根据你传入的实际类型来推导泛型类型，因此你不必显式指定类型参数。
func main() {
intBox := Box{Value: 42} // 推导 T 为 int
stringBox := Box{Value: "Go"} // 推导 T 为 string
fmt.Println(intBox.GetValue()) // 输出: 42
fmt.Println(stringBox.GetValue()) // 输出: Go
}
你可以使用泛型来创建处理不同类型切片的函数或结构体。
package main
import "fmt"
// 泛型函数，打印切片的所有元素
func PrintSlice[T any](slice []T) {
for _, v := range slice {
fmt.Println(v)
}
}
func main() {
intSlice := []int{1, 2, 3, 4}
stringSlice := []string{"apple", "banana", "cherry"}
PrintSlice(intSlice) // 输出: 1 2 3 4
PrintSlice(stringSlice) // 输出: apple banana cherry
}
Go的泛型可以与接口结合使用。例如，使用泛型来定义实现不同接口的函数或结构体。
package main
import "fmt"
// 定义泛型接口
type Adder[T any] interface {
Add(a T, b T) T
}
// 定义泛型结构体
type IntAdder struct{}
func (i IntAdder) Add(a int, b int) int {
return a + b
}
func sum[T any, A Adder[T]](a A, x, y T) T {
return a.Add(x, y)
}
func main() {
intAdder := IntAdder{}
result := sum(intAdder, 5, 3)
fmt.Println(result) // 输出: 8
}
Go的泛型设计避免了运行时的性能开销。泛型类型在编译时会根据具体类型生成代码，这被称为 monomorphization。这与C++模板类似，不同之处在于 Go 泛型不会产生运行时开销。
Go 1.18引入的泛型是 Go 语言的重要特性之一，它提供了一种类型安全且灵活的方式来编写可复用的代码。通过类型参数和约束，可以编写函数、结构体、接口等更加通用的代码。理解如何使用类型约束、组合约束、类型推导等功能将帮助你更高效地使用泛型。