一五九、Go语言的泛型

场景导入

现在有一个取数组最小值的函数如下：

// 取数组的最小值
func FindMin(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	min := arr[0]
	for _, num := range arr {
		if num < min {
			min = num
		}
	}
	return min
}

结果后面来需求了，要增加对 int16，float32 等类型数组的取最小值功能。从代码发现，除了类型不一样，其他逻辑是一模一样的，完全可以复用。
在 go 语言里面，参数类型要求必须是完全一致的才可以，int 和 int16 是不同的，虽然可以用强制类型转换解决，那 float32 怎么搞？
这时候，就是 go 泛型的用武之地了。我们用泛型实现一个支持所有整型+浮点型的 FindMin 函数：

// 取数组的最小值
func FindMin[T int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64](arr []T) T {
	if len(arr) == 0 {
		return 0
	}
	min := arr[0]
	for _, num := range arr {
		if num < min {
			min = num
		}
	}
	return min
}

下面是测试的代码，可以看到咱们使用泛型的函数，能支持咱们想要的类型了：

intArr := []int{3, -2, 1}
fmt.Println(FindMin(intArr))

unit32Arr := []uint32{6, 5, 4}
fmt.Println(FindMin(unit32Arr))

float32Arr := []float32{9.1, 8.2, -7.3}
fmt.Println(FindMin(float32Arr))

应用场景

参数泛型类型

参数泛型类型可以说是泛型使用过程应用最多的场景了， 一般应用于函数的形参或返回参数上。
参数泛型类型基本的使用格式可参见如下：

func FuncName[P, Q constraint1, R constraint2, ...](parameter1 P, parameter2 Q, ...) (R, Q, ...)

说明: 参数泛型类型定义后，可以用于函数的形参或返回参数上。
例子就是这个 FindMin 函数：

// 取数组的最小值
func FindMin[T int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64](arr []T) T {
    if len(arr) == 0 {
        return 0
    }
    min := arr[0]
    for _, num := range arr {
        if num < min {
            min = num
        }
    }
    return min
}

对象与方法上使用泛型定义

目前 go 语言只支持在对象上定义泛型参数，应用到方法中，但无法直接在方法中定义泛型。
比如下面这个例子：

type Queue[T int | float32 | string] struct {
	datas            []T
	putPos, offerPos int
}

// 存储数据
func (q *Queue[T]) Put(data T) {
	q.datas[q.putPos] = data
}

// 获取数据
func (q *Queue[T]) Offer() T {
	return q.datas[q.offerPos]
}

问题
目前 go 语言还不支持在对象的方法中定义泛型形参，如下面的代码是无法被编译通过的：

// 打印数据
func (q *Queue[T]) Print[E int](idx E) {    // 编译不通过
	fmt.Println(q.datas[idx])
}

其他补充

a. 如有多个泛型类型约束时，可以用 “|” 来组织, 例如 [T int | uint | float32]；
b. “~” 标识符，表示基础类型，针对这种设置，只要最终的基础类型一致就可以调用，否则就要求类型完全一致。如下面的代码

func PrintMyAge11[T ~int8 | ~int16 | ~int32](age T) {
	fmt.Printf("my age is %d\n", age)
}

func PrintMyAge22[T int8 | int16 | int32](age T) {
	fmt.Printf("my age is %d\n", age)
}

函数调用：

var age1 int16 = 20

	// TestInt32 的最终基础类型是 int32
	type TestInt32 int32
	var age2 TestInt32 = 30

	PrintMyAge11(age1)
	PrintMyAge11(age2)

	PrintMyAge22(age1)
	PrintMyAge22(age2)    // 编译不通过

c. 在泛型类型定义中，支持多个泛型类型，且支持嵌套。如下面的代码：

// 判断是否在数组里
func InArray[T []E, E ~int | ~uint | ~float32](arr T, val E) bool {
	for _, v := range arr {
		if val == v {
			return true
		}
	}
	return false
}

函数调用：

intArr := []int{1, 2, 3}
	fmt.Println(InArray(intArr, 3))

	float32Arr := []float32{1.0, 2.0, 3.0}
	fmt.Println(InArray(float32Arr, 2.0))

类型集合

通过上面的例子讲解，估计大家也是理解并学会了泛型，那么大家有没有发现一个问题，就是泛型约束可能会非常长，不仅写起来不方便，而且不好复用，喜提中危bug。

func FindMin[T int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64](arr []T) T {}

func FindMax[T int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64](arr []T) T {}

这一块go语言的设计师已经帮大家考虑到这个问题，这就是类型集合。
类型集合是为了简化泛型约束的使用，提升阅读性，同时增加了复用能力，它通过接口定义的方式使用。
编写格式如下：

type Constraint1 interface {
    Type1 | ~Type2 | ...
}

直接定义

该方式就是直接定义一下接口，然后把泛型约束列出来。如以下示例定义了有符号整型与无符号整型的泛型约束：

type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

type Unsigned interface {
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

通过继承方式复用

类型集合也支持继承的方式，简化复用。使用方式也接口的继承是完全一致。如以下示例定义把 **Signed **和 **Unsigned **进行了组合，用于表达对整型泛型约束的定义：

type Integer interface {
    Signed | Unsigned
}

我们通过类型集合重写 FindMin 函数：

// 有符号整型
type Signed interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

// 无符号整型
type Unsigned interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

// 整型
type Integer interface {
	Signed | Unsigned
}

// 浮点型
type Float interface {
	~float32 | ~float64
}

// 取数组的最小值
func FindMin[T Integer | Float](arr []T) T {
	if len(arr) == 0 {
		return 0
	}
	min := arr[0]
	for _, num := range arr {
		if num < min {
			min = num
		}
	}
	return min
}

利用类型集合，就能使咱们的代码更加整洁，提高可读性和代码复用性。

Go内置的泛型参数类型

go语言内置了2个参数类型，以方便大家的使用

• any 其定义等同于 interface{}

func Println[T any](input T){}

// 上面的方式，也等同如下
func Println(intput any){}
func Println(intput interface{}){}

• comparable 定义所有可比较的类型， 常用于map映射类型时，key的泛型参数指定。操作符只能使用 == 和 != 进行比较操作

func MapSet[T comparable](key T, val any) map[T]any {
	ret := make(map[T]any)
	ret[key] = val
	return ret
}

总结

什么时候使用泛型？

• 提升代码的复用能力。 例如函数里只是类型不同，但处理逻辑完全一样的场景，推荐使用泛型；
• 提升代码可读性和约束。应用泛型后，比 any, interface{} 会有更好的可读性；