10分钟掌握Go泛型

要是本文对您有帮助的话，欢迎【关注】作者，【点赞】+【收藏】，保持交流！

为什么需要泛型

比如现在实现一个add函数，支持int累加

func add(x, y int) int {
	return x + y
}
1
2
3

现在新增一个float32累加，如下实现

func add(x, y float32) float32 {
	return x + y
}
1
2
3

再要支持其它类型比如float/string等，应该如何做呢？

• 每种类型定义一个函数

这是最朴素的想法，1.18之前go经常这样干，毕竟那时候go的口号是大道至简，手撸就完了！
当然，也可以结合go generate实现自动化，符合go依赖工具补充语法的设计思想。

• 万能类型+类型断言实现通用化

1.18之前go中也很常用，interface接受所有类型，类似c++的空指针或者java中的object表达通用参数，实现一个通用函数，如下

func addGeneral(x, y interface{}) interface{} {
	switch ret := x.(type) {
	case int:
		return ret + y.(int)

	case float32:
		return ret + y.(float32)

	default:
		return nil
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

这个程序可以不用重试定义多个add函数，但缺点也很明显：
1.需要添加多个类型实现
2.必须保证传入类型是符合要求的，比如addGeneral(1,"2")就会报错，也就是类型不安全
3.返回的类型也必须是interface，无法自动推断

• 泛型实现

1.18开始引入

func addT[T int | float32](x, y T) T {
	return x + y
}
1
2
3

这里定义了int和float32的add支持，并且类型安全+返回自动推断，完美！

所以可以看到，泛型的作用在于如下

• 通用化，同一逻辑不用重复对每个类型实现
• 类型安全和自动推断

💡 Tips：
不是所有地方都适合用泛型，原则上避免使用泛型引入新的抽象。
一般只有类库或者明确同一逻辑需要多个类型实现时才引入。

泛型定义语法

// 声明一个带有泛型的函数
// T :
// 指类型参数，就是一个参数，代表类型
// Constraint :
// 是对类型参数T的约束，限制T的取值， 
// 可以是int、string、any等类型，any可以是任意类型的意思
// 也可以是一系列类型的组合，使用|连接 比如如上add函数定义的int |float32
// s ：
// T类型的参数
func name[T {Constraint}](s T) T {}
1
2
3
4
5
6
7
8
9
10

泛型常见用法

基础类型扩展

如下，~前缀表示基础类型的扩展类型也可以支持，
对于type MyInt int MyInt类型，如上addT函数无法支持，
如下定义声明扩展类型也支持即可

func addT2[T ~int | ~int64 | ~float32 | ~float64](x, y T) T {
	return x + y
}
1
2
3

类型独立成接口

本质上，每种类型是一种接口，因此如上的泛型定义可以抽象成接口，如下定义

type Number interface {
	int | int64 | float32 | float64
}

func addNumber[T Number](x, y T) T {
	return x + y
}
1
2
3
4
5
6
7

自定义泛型类型

如上已提到泛型类型本质是不同接口类型
除了默认类型组合，也可以自己定义接口作为类型，如下要求泛型类型必须实现fmt.Stringer接口

func makeStringT[T fmt.Stringer](x T) string {
	return x.String()
}
1
2
3

此时对于如下自定义类型，直接调用makeStringT会报错，因为MyT没有实现接口fmt.Stringer

type MyT struct {
	val int
}
1
2
3

增加如下fmt.Stringer接口实现即可满足泛型类型检查

func (t MyT) String() string {
	return strconv.Itoa(t.val)
}
1
2
3

go自带泛型类型支持

为了更好支持泛型，go标准库定义了几种常见用到的泛型接口作为自带支持

any

其实any就是interface{}别名，go标准库默认使用any替换之前的interface{}
一个常见泛型示例

func printT[T any](x T) {
	fmt.Println(x)
}
1
2
3

comparable

如下实现一个泛型比较函数

func isEqualT2[T any](x, y T) bool {
	if x == y {
		return true
	} else {
		return false
	}
}
1
2
3
4
5
6
7

编译报错-Invalid operation: x == y (the operator == is not defined on T)
因为go不允许重载运算符，这里any类型T，无法知道T类型是否实现==运算符，因此报错。

go中引入comparable预定义接口标记类型实现==运算符，可如下定义

func isEqualT[T comparable](x, y T) bool {
	if x == y {
		return true
	} else {
		return false
	}
}
1
2
3
4
5
6
7

ordered

如下实现一个泛型max函数

func maxT2[T any](x, y T) T {
	if x >= y {
		return x
	} else {
		return y
	}
}
1
2
3
4
5
6
7

编译报错-Invalid operation: x >= y (the operator >= is not defined on T)
因为go不允许重载运算符，这里any类型T，无法知道T类型是否实现>=运算符，因此报错。

go 1.18 beta1 contraints包中引入ordered，但是后续contraints被移除，原本的ordered计划后续直接引入，这里我们可以先自行定义，如下

type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~string
}

func maxT[T Ordered](x, y T) T {
	if x >= y {
		return x
	} else {
		return y
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以看到ordered其实就是内建标准类型的集合

结构体泛型支持

和函数泛型定义类似，如下实现一个泛型栈的Pop和Push

type MyStack[T any] struct {
	vals []T
}

func (s *MyStack[T]) Pop() (T, error) {
	l := len(s.vals)
	if l == 0 {
		var zero T
		return zero, errors.New("empty stack")
	}

	v := s.vals[l-1]
	s.vals = s.vals[:l-1]

	return v, nil
}

func (s *MyStack[T]) Push(val T) {
	s.vals = append(s.vals, val)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意go目前不支持结构体的方法定义泛型参数，如下

func (s *MyStack[T]) ConvertAndPush[In any](val In, f func (x In) T ) {
	s.vals = append(s.vals, f(val))
}
1
2
3

编译报错-Method cannot have type parameters

泛型注意点

如下示例，addT3不会提示语法错误，但是编译报错-untyped int constant 1000
因为前面我们提到泛型的一大作用是类型安全，这里1000超出int8范围，所以编译报错
addT4正常编译通过

func addT3[T int8](x T) T {
	return x + 1_000
}

func addT4[T int8](x T) T {
	return x + 100
}
1
2
3
4
5
6
7

演示代码

https://gitee.com/wenzhou1219/go-in-prod/blob/master/generics/simple_test.go

参考

An Introduction to Generics in Go