通过引入 类型形参 和 类型实参 这两个概念，我们让一个函数获得了处理多种不同类型数据的能力，这种编程方式被称为 泛型编程。
2. Go的泛型
- 类型形参 (Type parameter)
- 类型实参(Type argument)
- 类型形参列表( Type parameter list)
- 类型约束(Type constraint)
- 实例化(Instantiations)
- 泛型类型(Generic type)
- 泛型接收器(Generic receiver)
- 泛型函数(Generic function)
基本格式:
type Slice[T int|float32|float64 ] []T- T 就是上面介绍过的类型形参(Type parameter)，在定义Slice类型的时候 T 代表的具体类型并不确定，类似一个占位符
- int|float32|float64 这部分被称为类型约束(Type constraint)，中间的 | 的意思是告诉编译器，类型形参 T 只可以接收 int 或 float32 或 float64 这三种类型的实参
- 中括号里的 T int|float32|float64 这一整串因为定义了所有的类型形参(在这个例子里只有一个类型形参T），所以我们称其为 类型形参列表(type parameter list)
- 这里新定义的类型名称叫 Slice[T]
泛型类型不能直接拿来使用，必须传入类型实参(Type argument) 将其确定为具体的类型之后才可使用。而传入类型实参确定具体类型的操作被称为 实例化(Instantiations)
// 声明一个泛型
type slice[T int | float32 | float64] []T
func main() {
// 这里传入了类型实参int，泛型类型Slice[T]被实例化为具体的类型 Slice[int]
var a slice[int] = []int{1, 2, 3}
fmt.Println(a) //[1 2 3]
// 传入类型实参float32, 将泛型类型Slice[T]实例化为具体的类型 Slice[float32]
var b slice[float32] = []float32{1.2, 123.123, 2123.1}
fmt.Println(b) //[1.2 123.123 2123.1]
}
其他类型的泛型
//泛型map
type myMap[KEP int | string, VAL int | float32] map[KEP]VAL
func main() {
table := myMap[string, int]{
"xiaoming": 190,
"xiaohong": 150,
}
fmt.Printf("%+v", table) //map[xiaohong:150 xiaoming:190]
}
//泛型结构体
type myStruct[T int|string] struct {
name string
data T
}// 一个泛型接口(关于泛型接口在后半部分会详细讲解）
type IPrintData[T int | float32 | string] interface {
Print(data T)
}
// 一个泛型通道，可用类型实参 int 或 string 实例化
type MyChan[T int | string] chan T3 类型形参的互相套用
// 泛型嵌套
type woStruct[T int | string, s []T] struct {
Data s
maxval T
minval T
}
func main() {
var test woStruct[int, []int] = woStruct[int, []int]{
[]int{1, 2, 3},
12,
31,
}
fmt.Printf("%+v", test) //{Data:[1 2 3] maxval:12 minval:31}
}
任何泛型类型都必须传入类型实参实例化才可以使用。上面的代码中，我们为T传入了实参 int，然后因为 S 的定义是 []T ，所以 S 的实参自然是 []int
因为 S 的定义是 []T ，所以 T 一定决定了的话 S 的实参就不能随便乱传了
几种语法错误
- 定义泛型类型的时候，基础类型不能只有类型形参，如下：
- 当类型约束的一些写法会被编译器误认为是表达式时会报错。如下：
go
复制代码// 错误，类型形参不能单独使用
type CommonType[T int|string|float32] Tgo
复制代码//✗ 错误。T *int会被编译器误认为是表达式 T乘以int，而不是int指针
type NewType[T *int] []T
// 上面代码再编译器眼中：它认为你要定义一个存放切片的数组，数组长度由 T 乘以 int 计算得到
type NewType [T * int][]T
//✗ 错误。和上面一样，这里不光*被会认为是乘号，| 还会被认为是按位或操作
type NewType2[T *int|*float64] []T
//✗ 错误
type NewType2 [T (int)] []T为了避免这种误解，解决办法就是给类型约束包上 interface{} 或加上逗号消除歧义（关于接口具体的用法会在后半篇提及）
go
复制代码type NewType[T interface{*int}] []T
type NewType2[T interface{*int|*float64}] []T
// 如果类型约束中只有一个类型，可以添加个逗号消除歧义
type NewType3[T *int,] []T
//✗ 错误。如果类型约束不止一个类型，加逗号是不行的
type NewType4[T *int|*float32,] []T因为上面逗号的用法限制比较大，这里推荐统一用 interface{} 解决问题
匿名结构体不支持泛型
4. 泛型receiver
type mySlice[T int | string | float32] []T
//泛型方法
func (m mySlice[T]) sum() T {
var sum T
for _, v := range m {
sum += v
}
return sum
}
func main() {
var t mySlice[int] = []int{1, 2, 3, 4, 5}
fmt.Println(t.sum()) //15
var f mySlice[float32] = []float32{1.2, 3.4, 5.6}
fmt.Println(f.sum()) //10.200001
}
- 首先看receiver (s MySlice[T]) ，所以我们直接把类型名称 MySlice[T] 写入了receiver中
- 然后方法的返回参数我们使用了类型形参 T ****(实际上如果有需要的话，方法的接收参数也可以实用类型形参)
- 在方法的定义中，我们也可以使用类型形参 T （在这个例子里，我们通过 var sum T 定义了一个新的变量 sum )
动态判断变量的类型
泛型不像接口一样可以通过类型断言来判断其类型
但可以通过反射来实现动态判断其类型
func (receiver Queue[T]) Put(value T) {
// Printf() 可输出变量value的类型(底层就是通过反射实现的)
fmt.Printf("%T", value)
// 通过反射可以动态获得变量value的类型从而分情况处理
v := reflect.ValueOf(value)
switch v.Kind() {
case reflect.Int:
// do something
case reflect.String:
// do something
}
// ...
}
泛型函数
func main() {
//在调用函数的时候声明类型
fmt.Println(add[float64](float64(6.123), float64(8.12312)))
//自动类型推断
fmt.Println(add(19, 123)) //142
}
//定义一个函数泛型
func add[T int | float32 | float64](a T, b T) T {
return a + b
}
匿名函数不能自己定义类型形参：
但是匿名函数可以使用别处定义好的类型实参，如：
go
复制代码func MyFunc[T int | float32 | float64](a, b T) {
// 匿名函数可使用已经定义好的类型形参
fn2 := func(i T, j T) T {
return i*2 - j*2
}
fn2(a, b)
}
既然函数都支持泛型了，那你应该自然会想到，方法支不支持泛型？很不幸，目前Go的方法并不支持泛型
6. 变得复杂的接口
type IntUintFloat interface {
int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}
type Slice[T IntUintFloat] []T这段代码把类型约束给单独拿出来，写入了接口类型 IntUintFloat 当中。需要指定类型约束的时候直接使用接口 IntUintFloat 即可。
不过这样的代码依旧不好维
6.1 ~ : 指定底层类型
上面定义的 Slie[T] 虽然可以达到目的，但是有一个缺点：
go
复制代码var s1 Slice[int] // 正确
type MyInt int
var s2 Slice[MyInt] // ✗ 错误。MyInt类型底层类型是int但并不是int类型，不符合 Slice[T] 的类型约束这里发生错误的原因是，泛型类型 Slice[T] 允许的是 int 作为类型实参，而不是 MyInt （虽然 MyInt 类型底层类型是 int ，但它依旧不是 int 类型）。
为了从根本上解决这个问题，Go新增了一个符号 ~ ，在类型约束中使用类似 ~int 这种写法的话，就代表着不光是 int ，所有以 int 为底层类型的类型也都可用于实例化。
限制：使用 ~ 时有一定的限制：
- ~后面的类型不能为接口
- ~后面的类型必须为基本类型
type MyInt int
type _ interface {
~[]byte // 正确
~MyInt // 错误，~后的类型必须为基本类型
~error // 错误，~后的类型不能为接口
}6.2 从方法集(Method set)到类型集(Type set)
当满足以下条件时，我们可以说 类型 T 实现了接口 I ( type T implements interface I)：
- T 不是接口时：类型 T 是接口 I 代表的类型集中的一个成员 (T is an element of the type set of I)
- T 是接口时： T 接口代表的类型集是 I 代表的类型集的子集(Type set of T is a subset of the type set of I)
6.2.2 类型的并集
并集我们已经很熟悉了，之前一直使用的 | 符号就是求类型的并集( union )
6.2.3 类型的交集
接口可以不止书写一行，如果一个接口有多行类型定义，那么取它们之间的 交集
go
复制代码type AllInt interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint32
}
type Uint interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
type A interface { // 接口A代表的类型集是 AllInt 和 Uint 的交集
AllInt
Uint
}
type B interface { // 接口B代表的类型集是 AllInt 和 ~int 的交集
AllInt
~int
}上面这个例子中
- 接口 A 代表的是 AllInt 与 Uint 的 交集，即 ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
- 接口 B 代表的则是 AllInt 和 ~int 的交集，即 ~int
除了上面的交集，下面也是一种交集：
go
复制代码type C interface {
~int
int
}很显然，~int 和 int 的交集只有int一种类型，所以接口C代表的类型集中只有int一种类型
6.2.4 空集
当多个类型的交集如下面 Bad 这样为空的时候， Bad 这个接口代表的类型集为一个空集：
go
复制代码type Bad interface {
int
float32
} // 类型 int 和 float32 没有相交的类型，所以接口 Bad 代表的类型集为空
6.2.5 空接口和 any
上面说了空集，接下来说一个特殊的类型集——空接口 interface{} 。因为，Go1.18开始接口的定义发生了改变，所以 interface{} 的定义也发生了一些变更：
空接口代表了所有类型的集合
// 空接口代表所有类型的集合。写入类型约束意味着所有类型都可拿来做类型实参
type Slice[T interface{}] []T因为空接口是一个包含了所有类型的类型集，所以我们经常会用到它。于是，Go1.18开始提供了一个和空接口 interface{} 等价的新关键词 any ，用来使代码更简单：
type Slice[T any] []T // 代码等价于 type Slice[T interface{}] []T
6.2.6 comparable(可比较) 和 可排序(ordered)
Go直接内置了一个叫 comparable 的接口，它代表了所有可用 != 以及 == 对比的类型
6.3.1 基本接口(Basic interface)
接口定义中如果只有方法的话，那么这种接口被称为基本接口(Basic interface)。这种接口就是Go1.18之前的接口，用法也基本和Go1.18之前保持一致
6.3.2 一般接口(General interface)
如果接口内不光只有方法，还有类型的话，这种接口被称为 一般接口(General interface) ，如下例子都是一般接口：
go
复制代码type Uint interface { // 接口 Uint 中有类型，所以是一般接口
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
type ReadWriter interface { // ReadWriter 接口既有方法也有类型，所以是一般接口
~string | ~[]rune
Read(p []byte) (n int, err error)
Write(p []byte) (n int, err error)
}一般接口类型不能用来定义变量，只能用于泛型的类型约束中。所以以下的用法是错误的：
go
复制代码type Uint interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
var uintInf Uint // 错误。Uint是一般接口，只能用于类型约束，不得用于变量定义这一限制保证了一般接口的使用被限定在了泛型之中，不会影响到Go1.18之前的代码，同时也极大减少了书写代码时的心智负担
