Go 泛型学习笔记

泛型

多个业务逻辑一样，传入类型不一样时，使用泛型。

定义泛型

切片，map泛型定义：

func main() {

	//切片泛型
	type aa[T int | float32] []T //后面的T是占位符，形参，  前面的T是约束

	var a1 aa[int] = []int{5} //使用的时候[]中需要指定类型
	fmt.Println(a1)
	var a2 aa[float32] = []float32{1}
	fmt.Println(a2)
	//map泛型
	type MyMap[Key int | string, Value float32 | float64] map[Key]Value
	var m1 MyMap[int, float32]
	m1 = map[int]float32{
		5: 5,
		6: 6,
	}
	fmt.Println(m1)

}

结构体，接口泛型定义：

泛型方法

type slip[T int | string] []T    //泛型

func (s1 slip[T]) sum() {      //泛型添加方法
	var sum T
	for _, v := range s1 {
		sum += v
	}
	fmt.Println(sum)
}

func main() {
	var arr slip[int] = []int{1, 2, 3}
	var arr1 slip[string] = []string{"1", "2", "3"}
	arr.sum()
	arr1.sum()

}

泛型函数

func add[T int | string](a, b T) T {

	return a + b
}

func main() {
	fmt.Println(add[int](1, 2))
	fmt.Println(add(3, 5))
	fmt.Println(add[string]("1", "hhh"))
	fmt.Println(add("12", "hhh"))

}

自定义泛型约束

泛型类型太多的时候，除了内置的2个

还可以通过设置接口自定义泛型约束

type kind interface {
	int | int8 | ~int32 | int8aaa //波浪线代表衍生类型都支持
}

func getMaxNum[T kind](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	var a int8aaa = 3
	//var b int =5
	var b int8aaa = 3
	fmt.Println(getMaxNum(a, b)) //a,b类型必须一样，b如果是int都不可以

}