go的1.18版本在3月15这天正式发布了 release notes，虽然在bate版本就可以尝试了，毕竟那时候还没正式发布，也就没去尝试了，现在正式发布了，马上就更了尝试一下。
总算是千呼万唤始出来，其实我对Go的泛型还是挺期待的，毕竟用 interface 能实现一些东西，但是还是不如原生支持来得好，用interface首先会因为类型转换带来一些性能损失，用interface做类型强转，有时候会因为不小心写错了，导致一些运行时错误。要是支持泛型，这些问题就会解决了，一些通用的库就会更好用了。
当然泛型也不是完美无缺的，泛型会导致语言变得复杂，大型项目的代码可能会更难读、难理解了，这也会导致编译器实现起来更复杂。但是优势还是大于劣势的
这里想骂一句，其他语言的泛型一般都是用 <> go 的泛型用 [] 搞不懂为啥不用 <> 非要独树一帜，打不过就加入，你说用啥就用啥吧
先通过几个简单的例子来练习一下
泛型函数
1
2
3
4
5
6
7
8
9
10
11
12
| func main() {
fmt.Println(Max[int](1, 2))
fmt.Println(Max(1.5, 2.6))
fmt.Println(Max("abc", "efg"))
}
func Max[T int | float64 | string](a, b T) T {
if a > b {
return a
}
return b
}
|
通过泛型，实现了一个获取大值的函数，如果没有泛型，就要手写三个不同类型的函数。
在使用泛型函数的时候，fmt.Println(Max[int](1, 2)) 和 fmt.Println(Max(1.5, 2.6)) 两种写法都是可以的。可以指定类型，也可以不指定，让编译器自己类型推导
Max函数的参数可不是任意类型的参数都可以传入，只能传入int float64 string 这三种类型，因为定义函数的时候，类型参数就只有这三种。泛型不是任意类型的，也是有类型的，这就是泛型的类型约束
泛型约束
1
2
3
4
5
6
7
8
9
10
11
12
| func main() {
x := uint32(10)
y := uint32(20)
fmt.Println(Max(x, y))
}
func Max[T int | float64 | string](a, b T) T {
if a > b {
return a
}
return b
}
|
上面这段代码是无法通过编译的，会有如下的报错 uint32 does not implement int|float64|string
因为 Max 只允许 int float64 string 这三种
还有一种情况是无法通过编译的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| type Myint int
func main() {
x := Myint (10)
y := Myint (20)
fmt.Println(Max(x, y))
}
func Max[T int | float64 | string](a, b T) T {
if a > b {
return a
}
return b
}
|
这个也是无法通过编译的，虽然 Myint 是 int 类型的，但是依然无法通过编译。这种情况是可以在定义时，修改一下就行了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| type Myint int
func main() {
x := Myint (10)
y := Myint (20)
fmt.Println(Max(x, y))
}
func Max[T ~int | ~float64 | ~string](a, b T) T {
if a > b {
return a
}
return b
}
|
在定义函数时，只要在类型前加上 ~ 就可以了。
每次在定义泛型约束时，都要写一堆类型好麻烦啊，go 官方也想到了，就是定义约束类型
1
2
3
4
5
6
7
8
9
10
| type MyGenerics interface {
~int | ~float64 | ~string
}
func Max[T MyGenerics](a, b T) T {
if a > b {
return a
}
return b
}
|
这样就完成了一个泛型的约束类型的定义
而且go的泛型约束也可以像 interface 那样相互嵌套的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| type Int interface {
~int | ~uint
}
type Float interface {
~float32 | ~float64
}
type Number interface {
Int | Float
}
func Max2[T Number](a, b T) T {
if a > b {
return a
}
return b
}
|
Go内置一个 constraints包，定义好了一些常用的泛型约束
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| type Signed interface {
~int | ~int8 | ~int16 | ~int32 | ~int64
}
type Unsigned interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}
type Integer interface {
Signed | Unsigned
}
type Float interface {
~float32 | ~float64
}
type Complex interface {
~complex64 | ~complex128
}
type Ordered interface {
Integer | Float | ~string
}
|
go 还定义了一个 类型约束 any 看这个名字应该就知道什么意思了，就是任意类型，这个也没啥神秘的，就是给 interface 整了一个别名
go 还有一种约束类型，函数类型约束，也就是只有实现了 对应函数，才能作为泛型类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| type MyToString interface {
ToString() string
}
type Myint int
func (m Myint) ToString() string {
return strconv.Itoa(int(m))
}
func MyString[T MyToString](value T) {
fmt.Println(value.ToString())
}
func main() {
var x Myint
x = 100
MyString[Myint](x)
}
|
在定义函数 MyString 函数的时候，MyString[T MyToString](value T) 函数的泛型约束时一个接口，函数 MyString 的类型约束就是 实现了 MyToString 接口的类型。所以传入函数的 T 类型的 value 一定会有 ToString 这个函数。
泛型结构体
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
| func main() {
stack := NewStack[int](10)
for i := 0; i < 10; i++ {
stack.Push(i)
}
for i := 0; i < 10; i++ {
fmt.Printf("%d ", stack.Pop())
}
}
func NewStack[T any](size int) *Stack[T] {
stack := &Stack[T]{
arr: make([]T, size),
}
stack.size = size
stack.index = -1
return stack
}
type Stack[T any] struct {
arr []T
size int
index int
}
func (s *Stack[T]) Full() bool {
return s.index+1 == s.size
}
func (s *Stack[T]) Empty() bool {
return s.index < 0
}
func (s *Stack[T]) Push(v T) bool {
if s.Full() {
return false
}
s.index++
s.arr[s.index] = v
return true
}
func (s *Stack[T]) Pop() T {
var v T
if s.Empty() {
return v
}
v = s.arr[s.index]
s.index--
return v
}
|
用泛型写了一个简单的栈
1
2
3
4
5
| type Stack[T any] struct {
arr []T
size int
index int
}
|
在定义结构体的同时指定了泛型类型，这样就定义了泛型的结构体
目前结构体的泛型还是有一些限制，比如结构的 method 不能是泛型的
1
2
3
4
5
6
| type Mystruct struct {
}
func (m Mystruct) One[T ~int | ~float64](value T) {
fmt.Println(value)
}
|
这段代码是编译不过的，后续可能会完善这部分吧
end
go的泛型总算是正式发布了，趁周末学习了一波。现在go泛型刚发布，工作中用上泛型可能还要等很长时间，毕竟线上的东西稳定最重要。我记得我刚入职公司的时候，那时候公司用的go版本还是 1.4， 那时候go 已经到了 1.13了。后来因为dlv调试不兼容低版本的go，就逐步升上来了。相信go的泛型肯定是一个趋势，后续很多的内置酷和第三方库都会用上泛型了。
先学到这里吧，等有空继续学习go泛型的更多知识，比如底层是怎样实现的，是java那样类型擦除还是C++那样代码展开的。