共计 3329 个字符，预计需要花费 9 分钟才能阅读完成。
在最新的 go1.18 版中减少了期盼已久的泛型反对
什么是泛型
泛型是程序设计语言的一种格调或范式。泛型容许程序员在强类型程序设计语言中编写代码时应用一些当前才指定的类型，在实例化时作为参数指明这些类型。
为什么应用泛型
如果没有泛型，对于 golang 语言这种强类型语言，针对不同类型的函数解决形式：
- 每个类型别离实现一遍，代码简短，浏览性差。
- 通过 interface{}，须要反射类型判断及类型强转，这容易裸露谬误。
以 int64 和 int 类型为例：
func CompareInt64(a, b int64) bool {
if a >= b {return true}
return false
}
func CompareInt(a, b int) bool {
if a >= b {return true}
return false
}
func Compare(a, b interface{}) bool {switch a.(type) {
case int64:
a1 := a.(int64)
b1 := b.(int64)
if a1 >= b1 {return true}
return false
case int:
a1 := a.(int)
b1 := b.(int)
if a1 >= b1 {return true}
return false
default:
return false
}
} 应用泛型
golang 反对泛型函数和泛型类型
// 泛型函数
func F[T any](p T) (args T){...}[T any] 为类型束缚，any 示意任意类型，(args T) 为参数。
应用泛型实现上例
func Compare[T int64|int](a, b T) bool {
if a >= b {return true}
return false
}参数多的话也可这样
type TT interface {int | int64}
func Compare[T TT|int](a, b T) bool {
if a >= b {return true}
return false
}有了泛型后：
- 编译期间确定类型，保障类型平安
- 晋升可读性，从编码阶段就显式地晓得泛型汇合、泛型办法等
-
泛型合并了同类型的解决代码进步代码的重用率，减少程序的通用灵活性。
泛型应用示例
泛型切片
预申明标识符 any 是空接口的别名。它能够代替 interface{}
package main
import ("fmt")
// 泛型切片
type Name[T any] []T
type TestSilce [T int | float64] []T
func ListElem[T int | float64 | string](params []T) {
for _, elem := range params {fmt.Printf("类型 =%T，val=%+v\n", elem, elem)
}
return
}
func main() {v := Name[string]{"a", "b"}
fmt.Printf("类型 =%T，val=%+v\n", v, v)
ListElem(v)
l := TestSilce[int]{1, 2, 3}
fmt.Printf("类型 =%T，val=%+v\n", l, l)
ListElem(l)
}
泛型 map
预申明标识符 comparable 是一个接口，示意能够应用 ==or 进行比拟的所有类型的汇合!=。它只能用作（或嵌入）类型束缚。
package main
import "fmt"
type Number interface {int64 | float64}
type M[K string ,V any] map[K]V
func main() {
// Initialize a map for the integer values
ints := M[string, int64]{
"first": 34,
"second": 12,
}
// Initialize a map for the float values
floats := map[string]float64{
"first": 35.98,
"second": 26.99,
}
fmt.Printf("Generic Sums: %v and %v\n",
SumIntsOrFloats[string, int64](ints),
SumIntsOrFloats[string, float64](floats))
fmt.Printf("Generic Sums, type parameters inferred: %v and %v\n",
SumIntsOrFloats(ints),
SumIntsOrFloats(floats))
fmt.Printf("Generic Sums with Constraint: %v and %v\n",
SumNumbers(ints),
SumNumbers(floats))
}
// SumIntsOrFloats sums the values of map m. It supports both floats and integers
// as map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
var s V
for _, v := range m {s += v}
return s
}
// SumNumbers sums the values of map m. Its supports both integers
// and floats as map values.
func SumNumbers[K comparable, V Number](m map[K]V) V {
var s V
for _, v := range m {s += v}
return s
}泛型构造体
package main
import "fmt"
type Number interface {int64 | float64}
type Stack[V Number] struct {
size int64
value []V}
func (s *Stack[V]) Push(v V) {s.value = append(s.value, v)
s.size++
}
func main() {s := &Stack[int64]{}
s.Push(1)
fmt.Printf("%T and %v\n",s,s)
}
泛型通道
package main
import "fmt"
type Ch[T any] chan T
func main() {ch := make(Ch[int], 1)
ch <- 10
res := <-ch
fmt.Printf("类型 =%T，val=%+v", res, res)
}
以后的泛型实现具备以下已知限度：
- Go 编译器无奈解决泛型函数或办法中的类型申明。咱们心愿在将来的版本中提供对此性能的反对。
- Go 编译器不承受具备预申明函数 real、imag 和 complex 的类型参数类型的参数。咱们心愿在将来的版本中勾销此限度。
- 如果 m 由 P 的束缚接口显式申明，则 Go 编译器仅反对在类型参数类型为 P 的值 x 上调用办法 m。相似地，办法值 x.m 和办法表达式 P.m 也仅在 m 由 P 显式申明时才受反对，即便 m 可能因为 P 中的所有类型都实现 m 而位于 P 的办法集中。咱们心愿在将来的版本中勾销此限度。。
- Go 编译器不反对拜访构造字段 x.f，其中 x 是类型参数类型，即便类型参数的类型集中的所有类型都有字段 f。咱们可能会在将来的版本中删除此限度。
- 不容许将类型参数或指向类型参数的指针作为构造类型中的未命名字段嵌入。同样，不容许在接口类型中嵌入类型参数。目前尚不分明这些是否会被容许。
- 具备多个术语的联结元素可能不蕴含具备非空办法集的接口类型。目前尚不分明这是否会被容许。
总结
函数和 类型申明 的语法 当初承受 类型参数。
参数化函数和类型能够通过在它们前面加上方括号中的类型参数列表来实例化。
新标记~ 已增加到 运算符和标点符号集中。
预申明标识符 any 是空接口的别名。它能够代替 interface{}.
接口类型 的语法 当初容许嵌入任意类型（不仅仅是接口的类型名称）以及联结和~T 类型元素。此类接口只能用作类型束缚。一个接口当初定义了一组类型和一组办法。
预申明标识符 comparable 是一个接口，示意能够应用 ==or 进行比拟的所有类型的汇合!=。它只能用作（或嵌入）类型束缚。
退出泛型后对编译性能有影响，编译速度慢了 15%。
links
https://go.dev/doc/tutorial/g…
https://blog.csdn.net/Jcduhdt…
正文完
