GO泛型相关

通过引入 类型形参 和 类型实参 这两个概念，我们让一个函数获得了处理多种不同类型数据的能力，这种编程方式被称为 泛型编程。

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 T

3 类型形参的互相套用

// 泛型嵌套
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] T

go
复制代码//✗ 错误。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 为底层类型的类型也都可用于实例化。

限制：使用 ~ 时有一定的限制：

1. ~后面的类型不能为接口
2. ~后面的类型必须为基本类型

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之前的代码，同时也极大减少了书写代码时的心智负担