go 中的范型 - 技术栈

泛型是随着Go 1.18版本发布的。它基本上意味着参数化的类型，也就是说，它允许程序员在写代码时，类型可以稍后指定，因为类型在当时并不相关。换句话说，在编写一些代码时，你不提供数值的类型。这些类型的值会在以后传递。

其语法为：

func funcName[type_parameter type_constraint](... type_parameter) type_parameter {
 ...
}

func funcName[T any](... T) T {
 ...
}

func funcName[T interface{}](... T) T {
 ...
}

这里T是类型参数，any是类型约束，可以是任何接口，意味着无限的值，这里any代表一个空接口。

在下面的例子中，有两个函数，第一个returnFirst接受 any，意味着我们可以传递任何非特定的int或float，并且它返回第一个参数。第二个函数即returnFloatFirst只接受float64类型的参数，如果我们传递任何其他类型的参数，它就会抛出一个错误。在main函数中，你可以看到我们可以在不指定约束类型的情况下调用returnFirst函数，并且它是有效的，这是因为类型推理。

func returnFirst[T any](a T, b T) T {
  return a 
}

func returnFloatFirst[T float64](a T, b T) T {
  return a 
}

func main() {
  fmt.Println(returnFirst[int](1,3))
  fmt.Println(returnFirst(1,3))
  fmt.Println(returnFirst[float64](1.8,3.9))
  fmt.Println(returnFirst(1.8,3.9))
  fmt.Println(returnFirst("a","b"))
  fmt.Println(returnFloatFirst(1.2,3.4))
}

Go 1.18带有类型推理功能，可以帮助我们编写无需显式类型就能调用通用函数的代码。

让我们再举一个例子，比如说你要计算数组中所有元素的总和，现在如果我说每次改变数组存储的数据类型，那么函数的实现将保持不变，但你必须写一个单独的函数来适应不同的类型，所以让我们写一个通用函数，将数组中的元素相加并返回总和。

func sumAll[T any](arr []T) T {
  var s T
  for _, ele := range arr {
    s += ele
  }
  return s
}

func main() {
  fmt.Println("sum: ", sumAll([]int{1, 2, 3, 5, 6}))
}

当你运行上述代码时，会出现一个错误：

$ go run main.go
./main.go:6:9: invalid operation: operator + not defined on a (variable of type T constrained by any)

这是因为任何约束都可以持有任何值，在上面的例子中，它是int，但它可以是任何东西，而且有可能运算符对那个特定的类型不起作用，所以它抛出一个错误。为了解决这个问题，我们使用类型集，在接口的帮助下定义一个自定义约束，并在类型约束的地方使用它。我们为该约束声明一组类型，我们必须只使用这些类型。

定义自定义约束的语法是：

type customConstraint interface {
  type1 | type2 | type3 ...
} 

type cusConstraint interface {
  float64 | int | string
}

我们还可以使用约束包，它定义了一组有用的约束，可以与参数一起使用。

首先，我们必须安装约束包。

$ go get golang.org/x/exp/constraints

来自包的一些限制。

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

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

type Integer interface {
  Signed | Unsigned
}

type Float interface {
  ~float32 | ~float64
}

type Complex interface {
  ~complex64 | ~complex128
}

type Ordered interface {
  Integer | Float | ~string
}

所以现在让我们创建一个自定义约束，它可以支持float64和int类型的数据，并在任何约束的位置使用它。

type constraint interface {
  ~float64 | int
}

func sumAll[T constraint](arr []T) T {
  var s T
  for _, ele := range arr {
    s += ele
  }
  return s
}

func main() {
  fmt.Println("sum: ", sumAll([]int{1, 2, 3, 5, 6}))
  fmt.Println("sum: ", sumAll([]float64{1.2, 2.1, 3.8, 5.4}))
}