跟着 Go 作者掌握泛型

Posted 2022-02-26 Go语言中文网

，跟函数的类型参数语法是一样的，T 相当于是一个类型，所以，之后用到 Tree 的地方，T 都跟随着，即 Tree[T]，包括方法的接收者（receiver）。

注意实例化的地方：var stringTree Tree[string]，和上面两个实例化步骤中的第一步一样。

操作符，因为函数体中使用了该操作符。

意味着包含底层类型 T 的所有类型集合。

如果约束中的所有类型都支持一个操作，则该操作可以与相应的类型参数一起使用

除了将约束单独定义为类型外，还可以写成字面值的形式，比如：

[S 表示底层是 []E 切片类型的都符合该约束。
3、类型推断
在调用泛型函数时，提供类型实参感觉有点多余。Go 虽然是静态类型语言，但擅长类型推断。因此泛型这里，Go 也实现了类型推断。
调用泛型版的 min，可以不提供类型实参，而是直接由 Go 进行类型推断：
var a, b, m float64
m := min[float64](a, b)
类型推断的细节很复杂，但使用起来还是很简单，大部分时候，跟普通函数调用没有区别。
关于类型推断，演讲中给了一个例子：
func Scale[E constraints.Integer](s []E, c E) []E 
 r := make([]E, len(s))
 for i, v := range s 
  r[i] = v * c
 
 return r

这个函数的目的是希望对 s 中的每个元素都乘以参数 c，最后返回一个新的切片。
接着定义一个类型：
type Point []int32

func (p Point) String() string 
 // 实现细节不重要，忽略
 return "point"

很显然，Point 类型的切片可以传递给 Scale：
func ScaleAndPrint(p Point) 
 r := Scale(p, 2)
 fmt.Println(r.String())

我们希望对 p 进行 Scale，得到一个新的 p，但发现返回的 r 根本不是 Point：
func main() 
 p := Point3, 2, 4
 ScaleAndPrint(p)

会报错：r.String undefined (type []int32 has no field or method String)。
所以，我们应该这样修改 Scale 函数：
func Scale[S ~[]E, E constraints.Integer](s S, c E) S 
 r := make(S, len(s))
 for i, v := range s 
  r[i] = v * c
 
 return r

注意其中的变化：加入了泛型 S，以及额外的类型约束 ~[]E。
调用 Scale 时，不需要 r := Scale[Point, int32](p, 2)，因为 Go 会进行类型推断。
正确的完整代码如下：
package main

import (
 "constraints"
 "fmt"
)

func Scale[S ~[]E, E constraints.Integer](s S, c E) S 
 r := make(S, len(s))
 for i, v := range s 
  r[i] = v * c
 
 return r


type Point []int32

func (p Point) String() string 
 // 实现细节不重要，忽略
 return "point"


func ScaleAndPrint(p Point) 
 r := Scale(p, 2)
 fmt.Println(r.String())


func main() 
 p := Point3, 2, 4
 ScaleAndPrint(p)

4、什么时候用泛型
泛型的加入，无疑增加了复杂度。我个人认为，能不用泛型就不用泛型。在演讲中，两位大佬提到，在以下场景可以考虑使用泛型：
对于 slice、map、channel 等类型，如果它们的元素类型是不确定的，操作这类类型的函数可以考虑用泛型
一些通用目的的数据结构，比如前面提到的二叉树等
如果一些函数行为相同，只是类型不同，可以考虑用泛型重构
注意，目前 Go 方法不支持类型参数，所以，如果方法有需要泛型的场景，可以转为函数的形式。
此外，不要为了泛型而泛型。比如这样的泛型就很糟糕：
func ReadFour[T io.Reader](r T) ([]byte, error)
而应该使用非泛型版本：
func ReadFour(r io.Reader) ([]byte, error)
5、总结
泛型是一把双刃剑。泛型的加入，让 Go 不那么简单了。有些代码写出来，可读性可能非常差。我们应该按没有泛型时候写代码，当发现在 Repeat Yourself 时，再考虑能不能用泛型重构，千万别玩什么花样！
最后，放上演讲的视频地址，有兴趣的可以观看：https://www.youtube.com/watch?v=Pa_e9EeCdy8。




---




往期推荐

Go 泛型简明入门教程


我是 polarisxu，北大硕士毕业，曾在 360 等知名互联网公司工作，10多年技术研发与架构经验！2012 年接触 Go 语言并创建了 Go 语言中文网！著有《Go语言编程之旅》、开源图书《Go语言标准库》等。


坚持输出技术（包括 Go、Rust 等技术）、职场心得和创业感悟！欢迎关注「polarisxu」一起成长！也欢迎加我微信好友交流：gopherstudio

10分钟掌握Go泛型

为什么需要泛型

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

func add(x, y int) int 
	return x + y

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

func add(x, y float32) float32 
	return x + y

再要支持其它类型比如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
	

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

• 泛型实现

1.18开始引入

func addT[T int | float32](x, y T) T 
	return x + y

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

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

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

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

泛型定义语法

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

泛型常见用法

基础类型扩展

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

func addT2[T ~int | ~int64 | ~float32 | ~float64](x, y T) T 
	return x + y

类型独立成接口

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

type Number interface 
	int | int64 | float32 | float64


func addNumber[T Number](x, y T) T 
	return x + y

自定义泛型类型

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

func makeStringT[T fmt.Stringer](x T) string 
	return x.String()

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

type MyT struct 
	val int

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

func (t MyT) String() string 
	return strconv.Itoa(t.val)

go自带泛型类型支持

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

any

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

func printT[T any](x T) 
	fmt.Println(x)

comparable

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

func isEqualT2[T any](x, y T) bool 
	if x == y 
		return true
	 else 
		return false
	

编译报错-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
	

ordered

如下实现一个泛型max函数

func maxT2[T any](x, y T) T 
	if x >= y 
		return x
	 else 
		return y
	

编译报错-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
	

可以看到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)

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

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

编译报错-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

演示代码

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

参考

An Introduction to Generics in Go

以上是关于跟着 Go 作者掌握泛型的主要内容，如果未能解决你的问题，请参考以下文章

10分钟掌握Go泛型

10分钟掌握Go泛型

跟着邓神 3 天掌握 Go 语言基础（免费）

Go语言11周年，泛型问题有望明年得到解决

快来！2023面试必问的Go泛型解析

Go语言泛型问题一直被呼喊，从未被解决 | 年度开发者调查报告