GO语言泛型

有一个遍历数组的方法，要求数组的类型既可以是int型也可以是float64型。以前面对不同数据类型但是逻辑相同的方法写起来会比较麻烦，有了泛型之后写起来就很容易了

// T就是泛型，Go语言中用[]来表示泛型
func PrintFunc[T int | string](arr []T) {
	for _, i := range arr {
		fmt.Println(i)
	}
}

Go语言泛型中还有两个内置类型

// any等价于interface{}， comparable 表示Go语言内置类型中所有可比较的类型
func PrintFunc[T any](arr []T) {
	for _, i := range arr {
		fmt.Println(i)
	}
}

泛型类型

func main() {
	// 泛型切片
	type MySlice[T int | float64 | float32] []T
	
	var s1 MySlice[int] = []int{1,2,3}
	fmt.Printf("%T\\n",s1) //main.Slice[int]
	var s2 MySlice[float64] = []float64{1,2,3}
	fmt.Printf("%T\\n",s2) // main.Slice[float64]
	var s3 MySlice[float32] = []float32{1,2,3}
	fmt.Printf("%T\\n",s3) // main.Slice[float32]
	
	// 泛系map
	type MyMap[Key int | string, Value int | string] map[Key]Value
	var m1 MyMap[string, int] = map[string]int {
		"sunday":0,
		"monday":1,
	}
	
	type MyInt[T int | string] int
	
	var a MyInt[int] = 1
	var b MyInt[string] = 1
	//var c MyInt[string] = "xx"  编译错误
	fmt.Printf("%T, %T\\n",a, b) // main.MyInt[int], main.MyInt[string]

	// 结构体泛型
	type Person[T int | string] struct {
		id T
		name string
	}
	
 // 接口泛型
	type PrintData[T int|string] interface {
		PrintFunc(data T)
	}
}

泛型方法和函数

type MySlice[T int | float64] []T

// 自定义泛型约束 ~ 表示当前类型的所有自定义类型也包含
type MyInt interface {
	int | int8 | ~int32
}

type MyInt32 int32

// 泛型方法  求和
func (arr MySlice[T]) Sum() T{
	var sum T
	for _, i := range arr {
		sum += i
	}
	return sum
}

// 泛型函数
func Add[T int | string | float64](a,b T) T {
	return a + b
}

// 泛型函数
func GetMax[T MyInt](a,b T) T {
	if a > b {
		return a
	}
	return b
}

func main() {
	var s1 MySlice[int] = []int{1,2,3,4,5}
	fmt.Println(s1.Sum())
	var s2 MySlice[float64] = []float64{1.1,2.2,3.3}
	fmt.Println(s2.Sum())
	
	// 调用泛型函数可以不声明类型
	fmt.Println(Add(2,3))
	fmt.Println(Add(2.2,3.3))
	
	var a int = 2
	var b int = 3
	fmt.Println(GetMax(a,b))

	var c MyInt32 = 12
	var d MyInt32 = 13
	fmt.Println(GetMax(c,d)) // 如果不加～ 这样会报错
}