Golang中泛型的使用：

注意：泛型的使用Go 1.18 或更高版本

1、golang中不使用泛型的情况：

//计算values为int64位类型的数据：
func SumInts(m map[string]int64) int64 {
	var s int64
	for _, v := range m {
		s += v
	}
	return s
}
//计算values为float64 位类型的数据：
func SumFloats(m map[string]float64) float64 {
	var s float64
	for _, v := range m {
		s += v
	}
	return s
}

func TestName001(t *testing.T) {
	ints := map[string]int64{
		"first":  34,
		"second": 12,
	}
	floats := map[string]float64{
		"first":  35.98,
		"second": 26.99,
	}
	fmt.Printf("Non-Generic Sums: %v and %v\n",
		SumInts(ints),
		SumFloats(floats))
}

2、golang中使用泛型的情况：

// Sum
// comparable在 Go 中预先声明了约束。它允许任何类型的值可以用作比较运算符==和的操作数!=。Go 要求映射键具有可比性
func Sum[K comparable, V int64 | float64 | int32](m map[K]V) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}


func TestName002(t *testing.T) {
	int32s := map[string]int32{
		"first":  35,
		"second": 26,
	}
	
	floats := map[string]float64{
		"first":  35.98,
		"second": 26.99,
	}
	
	//对比下方（泛型调用简化）：
	//同在许多情况下您可以省略这些类型参数 （[string, int32]），因为编译器可以推断它们。
	sum1 := Sum[string, int32](int32s)
	fmt.Println(sum1)
	//可以简化为当前样子：
	sum2 := Sum(floats)
	fmt.Println(sum2)
}

3、泛型统一定义：（代码复用）

// 把之前定义的约束移到它自己的接口中，以便您可以在多个地方重用它。以这种方式声明约束有助于简化代码，例如当约束更复杂时
//定义接口泛型约束：
type Number interface {
    int64 | float64 | int32
}
//此时 `Number` 的作用 和 `int64 | float64 | int32` 一致
func SumNumbers[K comparable, V Number](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

官网链接:
https://go.dev/doc/tutorial/generics