golang泛型初尝试

go的1.18版本在3月15这天正式发布了 release notes，虽然在bate版本就可以尝试了，毕竟那时候还没正式发布，也就没去尝试了，现在正式发布了，马上就更了尝试一下。

总算是千呼万唤始出来，其实我对Go的泛型还是挺期待的，毕竟用 interface 能实现一些东西，但是还是不如原生支持来得好，用interface首先会因为类型转换带来一些性能损失，用interface做类型强转，有时候会因为不小心写错了，导致一些运行时错误。要是支持泛型，这些问题就会解决了，一些通用的库就会更好用了。

当然泛型也不是完美无缺的，泛型会导致语言变得复杂，大型项目的代码可能会更难读、难理解了，这也会导致编译器实现起来更复杂。但是优势还是大于劣势的

这里想骂一句，其他语言的泛型一般都是用 <> go 的泛型用 [] 搞不懂为啥不用 <> 非要独树一帜，打不过就加入，你说用啥就用啥吧

先通过几个简单的例子来练习一下

泛型函数

 1func main() {
 2	fmt.Println(Max[int](1, 2))
 3	fmt.Println(Max(1.5, 2.6))
 4	fmt.Println(Max("abc", "efg"))
 5}
 6
 7func Max[T int | float64 | string](a, b T) T {
 8	if a > b {
 9		return a
10	}
11	return b
12}

通过泛型，实现了一个获取大值的函数，如果没有泛型，就要手写三个不同类型的函数。在使用泛型函数的时候，fmt.Println(Max[int](1, 2)) 和 fmt.Println(Max(1.5, 2.6)) 两种写法都是可以的。可以指定类型，也可以不指定，让编译器自己类型推导

Max函数的参数可不是任意类型的参数都可以传入，只能传入int float64 string 这三种类型，因为定义函数的时候，类型参数就只有这三种。泛型不是任意类型的，也是有类型的，这就是泛型的类型约束

泛型约束

 1func main() {
 2	x := uint32(10)
 3	y := uint32(20)
 4	fmt.Println(Max(x, y))
 5}
 6
 7func Max[T int | float64 | string](a, b T) T {
 8	if a > b {
 9		return a
10	}
11	return b
12}

上面这段代码是无法通过编译的，会有如下的报错 uint32 does not implement int|float64|string 因为 Max 只允许 int float64 string 这三种

还有一种情况是无法通过编译的

 1type Myint int
 2
 3func main() {
 4	x := Myint (10)
 5	y := Myint (20)
 6	fmt.Println(Max(x, y))
 7}
 8
 9func Max[T int | float64 | string](a, b T) T {
10	if a > b {
11		return a
12	}
13	return b
14}

这个也是无法通过编译的，虽然 Myint 是 int 类型的，但是依然无法通过编译。这种情况是可以在定义时，修改一下就行了

 1type Myint int
 2
 3func main() {
 4	x := Myint (10)
 5	y := Myint (20)
 6	fmt.Println(Max(x, y))
 7}
 8
 9func Max[T ~int | ~float64 | ~string](a, b T) T {
10	if a > b {
11		return a
12	}
13	return b
14}

在定义函数时，只要在类型前加上 ~ 就可以了。

每次在定义泛型约束时，都要写一堆类型好麻烦啊，go 官方也想到了，就是定义约束类型

 1type MyGenerics interface {
 2    ~int | ~float64 | ~string
 3}
 4
 5func Max[T MyGenerics](a, b T) T {
 6	if a > b {
 7		return a
 8	}
 9	return b
10}

这样就完成了一个泛型的约束类型的定义

而且go的泛型约束也可以像 interface 那样相互嵌套的

 1type Int interface {
 2    ~int | ~uint
 3}
 4
 5type Float interface {
 6    ~float32 | ~float64
 7}
 8
 9type Number interface {
10	Int | Float
11}
12
13func Max2[T Number](a, b T) T {
14	if a > b {
15		return a
16	}
17	return b
18}

Go内置一个 constraints包，定义好了一些常用的泛型约束

 1type Signed interface {
 2	~int | ~int8 | ~int16 | ~int32 | ~int64
 3}
 4
 5type Unsigned interface {
 6	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
 7}
 8
 9type Integer interface {
10	Signed | Unsigned
11}
12
13type Float interface {
14	~float32 | ~float64
15}
16
17type Complex interface {
18	~complex64 | ~complex128
19}
20
21type Ordered interface {
22	Integer | Float | ~string
23}

go 还定义了一个类型约束 any 看这个名字应该就知道什么意思了，就是任意类型，这个也没啥神秘的，就是给 interface 整了一个别名

1type any interface{}

go 还有一种约束类型，函数类型约束，也就是只有实现了对应函数，才能作为泛型类型

 1type MyToString interface {
 2	ToString() string
 3}
 4
 5type Myint int
 6
 7func (m Myint) ToString() string {
 8	return strconv.Itoa(int(m))
 9}
10
11func MyString[T MyToString](value T) {
12	fmt.Println(value.ToString())
13}
14
15func main() {
16	var x Myint
17	x = 100
18	MyString[Myint](x)
19}

在定义函数 MyString 函数的时候，MyString[T MyToString](value T) 函数的泛型约束时一个接口，函数 MyString 的类型约束就是实现了 MyToString 接口的类型。所以传入函数的 T 类型的 value 一定会有 ToString 这个函数。

泛型结构体

 1func main() {
 2	stack := NewStack[int](10)
 3
 4	for i := 0; i < 10; i++ {
 5		stack.Push(i)
 6	}
 7
 8	for i := 0; i < 10; i++ {
 9		fmt.Printf("%d ", stack.Pop())
10	}
11}
12
13func NewStack[T any](size int) *Stack[T] {
14	stack := &Stack[T]{
15		arr: make([]T, size),
16	}
17	stack.size = size
18	stack.index = -1
19	return stack
20}
21
22type Stack[T any] struct {
23	arr   []T
24	size  int
25	index int
26}
27
28func (s *Stack[T]) Full() bool {
29	return s.index+1 == s.size
30}
31
32func (s *Stack[T]) Empty() bool {
33	return s.index < 0
34}
35
36func (s *Stack[T]) Push(v T) bool {
37	if s.Full() {
38		return false
39	}
40	s.index++
41	s.arr[s.index] = v
42	return true
43}
44
45func (s *Stack[T]) Pop() T {
46	var v T
47	if s.Empty() {
48		return v
49	}
50	v = s.arr[s.index]
51	s.index--
52	return v
53}

用泛型写了一个简单的栈

1type Stack[T any] struct {
2    arr   []T
3    size  int
4    index int
5}

在定义结构体的同时指定了泛型类型，这样就定义了泛型的结构体

目前结构体的泛型还是有一些限制，比如结构的 method 不能是泛型的

1type Mystruct struct {
2}
3
4func (m Mystruct) One[T ~int | ~float64](value T) {
5	fmt.Println(value)
6}

这段代码是编译不过的，后续可能会完善这部分吧

end

go的泛型总算是正式发布了，趁周末学习了一波。现在go泛型刚发布，工作中用上泛型可能还要等很长时间，毕竟线上的东西稳定最重要。我记得我刚入职公司的时候，那时候公司用的go版本还是 1.4，那时候go 已经到了 1.13了。后来因为dlv调试不兼容低版本的go，就逐步升上来了。相信go的泛型肯定是一个趋势，后续很多的内置酷和第三方库都会用上泛型了。先学到这里吧，等有空继续学习go泛型的更多知识，比如底层是怎样实现的，是java那样类型擦除还是C++那样代码展开的。