Golang 泛型初级教程

泛型的优势

泛型编程（Generic Programming）是现代编程语言中的一项强大功能，它允许程序员编写出一种通用的形式来表示函数或数据结构，从而抽象出数据类型。

泛型的使用可以极大地减少代码重复，增加程序的灵活性与可维护性。

对于库的开发者来说，泛型的确引入了额外的复杂性；但对库的使用者而言，泛型提供了简洁和强大的工具，极少地增加了复杂性。

初级教程

首先，来看两个函数，它们的功能都是计算一个切片中所有元素的总和：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func SumInts(s []int) int {
	var r int
	for _, v := range s {
		r += v
	}
	return r
}

func SumFloats(s []float64) float64 {
	var r float64
	for _, v := range s {
		r += v
	}
	return r
}

但因为它们处理的数据类型不同（一个是 int，另一个是 float64），我们不得不为每种类型编写一个新函数。

泛型在这里发挥作用，允许我们使用类型参数来泛化函数的实现。

可以通过一些测试用例来确认函数的正确性：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func TestSumInts(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6
	gotInt := SumInts(inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}
}

func TestSumFloats(t *testing.T) {
	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumFloats(inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

接下来通过泛型代码来重写：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func SumIntsOrFloats[T int | float64](s []T) T {
	var r T
	for _, v := range s {
		r += v
	}
	return r
}

func TestSumIntsOrFloats(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6

	gotInt := SumIntsOrFloats[int](inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumIntsOrFloats[float64](inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

可以看到，泛型函数声明后面多了一对方括号 []，然后才是正常函数的参数和返回值。

在方括号里面的内容可以用类似正常变量声明的方式来阅读：[T int | float64] 表示声明了一个变量 T，T 的类型是 int 或 float64，| 表示或。

在这里，T 叫做类型参数，可以理解为把类型（int、float64、bool 等）当作参数变量来使用。而 int | float64 叫做类型约束，表示类型参数允许的类型集合。

然后在参数和返回值里，就可以像使用普通类型一样来使用这个类型参数。

(s []T) T 表示传入一个名为 s 的参数，类型是 []T，返回一个 T 类型的值。

可以自然地把类型参数 T 视为 int 或 float64 的一个占位符：

在 T 为 int 时：(s []T) T 等同于 (s []int) int，表示传入一个名为 s 的参数，类型是 []int，返回一个 int 类型的值；
在 T 为 float64 时：(s []T) T 等同于 (s []float64) float64，表示传入一个名为 s 的参数，类型是 []float64，返回一个 float64 类型的值。

在函数内部，也可以像使用普通类型一样来使用这个类型参数：var r T 表示声明了一个变量 r，r 的类型是 T，既是 int 或 float64。

在调用泛型函数的时候，像传入普通参数一样传入类型：SumIntsOrFloats[int](inputInts)。只不过传入类型时使用方括号，传入参数还是像以前一样使用圆括号。

一般情况下，可以不用传入类型，像普通函数一样调用 SumIntsOrFloats(inputInts)，因为 Go 编译器会根据传入的参数来推断类型。

在这里，前面已经通过 inputInts := []int{1, 2, 3} 来显式声明参数类型，是 []int，所以 Go 编译器能够推断出来正确的类型。

如果调用的泛型函数没有参数，就不可能通过参数来推断类型，这时就需要显式传入类型参数。

接下来可以进一步优化代码，通过接口来定义类型约束，来使得它能够被多个函数使用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
type Number interface {
	int | float64
}

func SumNumbers[T Number](s []T) T {
	var r T
	for _, v := range s {
		r += v
	}
	return r
}

func TestSumNumbers(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6

	gotInt := SumNumbers(inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumNumbers(inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

在这里，我们定义了一个名为 Number 的 interface，跟以前不同，interface 里面不是方法，而是类型的集合。

通过将 Number 放在类型参数的后面，就可以起到类型约束的效果。

参考链接

Why Generics?

Tutorial: Getting started with generics

BLCL的博客小馆