在引入泛型之前，有几种方法来实现支持不同数据类型的泛型函数：
方法 1：为每种数据类型实现一个函数
这种方式会导致代码极度冗余和维护成本高昂。任何修改都需要对所有函数执行相同的操作。而且，由于Go语言不支持同名函数重载，因此暴露这些函数供外部模块调用也不方便。
方法二：使用范围最大的数据类型
为了避免代码冗余，另一种方法是使用范围最大的数据类型，即方法2。典型的例子是math.Max，它返回两个数字中较大的一个。为了能够比较各种数据类型的数据，math.Max使用了Go中数值类型中范围最大的float64数据类型作为输入和输出参数，从而避免了精度损失。虽然这在一定程度上解决了代码冗余问题，但是任何类型的数据都需要先转换为float64类型。例如，当比较 int 和 int 时，仍然需要进行类型转换，这不仅会降低性能，而且显得不自然。
方法 3：使用接口{}类型
使用interface{}类型有效解决了上述问题。然而，interface{}类型引入了一定的运行时开销，因为它需要在运行时进行类型断言或类型判断，这可能会导致一些性能下降。另外，当使用interface{}类型时，编译器无法进行静态类型检查，因此某些类型错误可能只能在运行时发现。
Go 1.18 引入了对泛型的支持，这是 Go 语言开源以来的一个重大变化。
泛型是编程语言的一个特性。它允许程序员在编程中使用泛型类型而不是实际类型。然后在实际调用时通过显式传递或自动推导，替换泛型类型，达到代码复用的目的。在使用泛型的过程中，将要操作的数据类型指定为参数。这样的参数类型在类、接口和方法中分别称为泛型类、泛型接口和泛型方法。
泛型的主要优点是提高代码的可重用性和类型安全性。与传统的形式参数相比，泛型使得编写通用代码更加简洁灵活，提供了处理不同类型数据的能力，进一步增强了Go语言的表达能力和复用性。同时，由于泛型的具体类型是在编译时确定的，因此可以提供类型检查，避免类型转换错误。
在Go语言中，interface{}和泛型都是处理多种数据类型的工具。为了讨论它们的区别，我们先看一下interface{}和泛型的实现原理。
interface{} 是一个空接口，接口类型中没有方法。由于所有类型都实现了interface{}，因此它可用于创建可接受任何类型的函数、方法或数据结构。 interface{}在运行时的底层结构表示为eface，其结构如下所示，主要包含_type和data两个字段。
type eface struct {
_type *_type
data unsafe.Pointer
}
type type struct {
Size uintptr
PtrBytes uintptr // number of (prefix) bytes in the type that can contain pointers
Hash uint32 // hash of type; avoids computation in hash tables
TFlag TFlag // extra type information flags
Align_ uint8 // alignment of variable with this type
FieldAlign_ uint8 // alignment of struct field with this type
Kind_ uint8 // enumeration for C
// function for comparing objects of this type
// (ptr to object A, ptr to object B) -> ==?
Equal func(unsafe.Pointer, unsafe.Pointer) bool
// GCData stores the GC type data for the garbage collector.
// If the KindGCProg bit is set in kind, GCData is a GC program.
// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
GCData *byte
Str NameOff // string form
PtrToThis TypeOff // type for pointer to this type, may be zero
}
_type 是指向 _type 结构的指针，其中包含实际值的大小、种类、哈希函数和字符串表示等信息。 data 是指向实际数据的指针。如果实际数据的大小小于或等于指针的大小，则将数据直接存储到数据字段中；否则，数据字段将存储指向实际数据的指针。
当特定类型的对象被赋值给interface{}类型的变量时，Go语言会隐式执行eface的装箱操作，将_type字段设置为值的类型，将data字段设置为值的数据。例如，当执行语句 var i interface{} = 123 时，Go 会创建一个 eface 结构体，其中 _type 字段代表 int 类型，data 字段代表值 123。
当从interface{}中检索存储的值时，会发生一个拆箱过程，即类型断言或类型判断。此过程需要显式指定预期类型。如果interface{}中存储的值的类型与预期类型匹配，则类型断言将成功，并且可以检索该值。否则，类型断言将会失败，这种情况需要进行额外的处理。
var i interface{} = "hello"
s, ok := i.(string)
if ok {
fmt.Println(s) // Output "hello"
} else {
fmt.Println("not a string")
}
可以看出，interface{}通过运行时的装箱和拆箱操作，支持对多种数据类型的操作。
Go核心团队在评估Go泛型的实现方案时非常谨慎。共提交了三个实施方案：
Stenciling方案也是C、Rust等语言实现泛型所采用的实现方案。其实现原理是，在编译期间，根据调用泛型函数时的具体类型参数或约束中的类型元素，为每个类型参数生成泛型函数的单独实现，以保证类型安全和性能最优。然而，这种方法会减慢编译速度。因为当调用多种数据类型时，泛型函数需要为每种数据类型生成独立的函数，这可能会导致编译后的文件非常大。同时，由于CPU缓存未命中、指令分支预测等问题，生成的代码可能无法高效运行。
Dictionaries 方案只为泛型函数生成一个函数逻辑，但添加了一个参数 dict 作为函数的第一个参数。 dict 参数在调用泛型函数时存储类型参数的类型相关信息，并在函数调用期间使用 AX 寄存器（AMD）传递字典信息。这种方案的优点是减少了编译阶段的开销，并且不会增加二进制文件的大小。但增加了运行时开销，无法在编译阶段进行函数优化，并且存在字典递归等问题。
type eface struct {
_type *_type
data unsafe.Pointer
}
type type struct {
Size uintptr
PtrBytes uintptr // number of (prefix) bytes in the type that can contain pointers
Hash uint32 // hash of type; avoids computation in hash tables
TFlag TFlag // extra type information flags
Align_ uint8 // alignment of variable with this type
FieldAlign_ uint8 // alignment of struct field with this type
Kind_ uint8 // enumeration for C
// function for comparing objects of this type
// (ptr to object A, ptr to object B) -> ==?
Equal func(unsafe.Pointer, unsafe.Pointer) bool
// GCData stores the GC type data for the garbage collector.
// If the KindGCProg bit is set in kind, GCData is a GC program.
// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
GCData *byte
Str NameOff // string form
PtrToThis TypeOff // type for pointer to this type, may be zero
}
Go 最终综合了上述两种方案，提出了 GC Shape Stenciling 方案进行通用实现。它以类型的 GC Shape 为单位生成函数代码。具有相同 GC Shape 的类型重用相同的代码（类型的 GC Shape 指的是它在 Go 内存分配器/垃圾收集器中的表示）。所有指针类型都重用 *uint8 类型。对于具有相同 GC Shape 的类型，使用共享的实例化函数代码。该方案还会自动为每个实例化的函数代码添加一个dict参数，以区分具有相同GC Shape的不同类型。
var i interface{} = "hello"
s, ok := i.(string)
if ok {
fmt.Println(s) // Output "hello"
} else {
fmt.Println("not a string")
}
从interface{}和泛型的底层实现原理可以发现，它们的主要区别是interface{}支持在运行时处理不同的数据类型，而泛型支持在编译阶段静态处理不同的数据类型。实际使用中主要有以下区别：
(1) 性能差异：将不同类型的数据分配给接口{}或从接口{}检索不同类型的数据时执行的装箱和拆箱操作成本高昂，并会带来额外的开销。相比之下，泛型不需要装箱和拆箱操作，并且泛型生成的代码针对特定类型进行了优化，避免了运行时性能开销。
(2)类型安全：使用interface{}类型时，编译器无法进行静态类型检查，只能在运行时进行类型断言。因此，某些类型错误可能只能在运行时才能发现。相比之下，Go 的泛型代码是在编译时生成的，因此泛型代码可以在编译时获取类型信息，保证类型安全。
在Go语言中，类型参数是不允许与nil直接比较的，因为类型参数是在编译时进行类型检查的，而nil是运行时的一个特殊值。由于类型参数的底层类型在编译时是未知的，因此编译器无法确定类型参数的底层类型是否支持与 nil 进行比较。因此，为了维护类型安全并避免潜在的运行时错误，Go语言不允许类型参数与nil直接比较。
type eface struct {
_type *_type
data unsafe.Pointer
}
type type struct {
Size uintptr
PtrBytes uintptr // number of (prefix) bytes in the type that can contain pointers
Hash uint32 // hash of type; avoids computation in hash tables
TFlag TFlag // extra type information flags
Align_ uint8 // alignment of variable with this type
FieldAlign_ uint8 // alignment of struct field with this type
Kind_ uint8 // enumeration for C
// function for comparing objects of this type
// (ptr to object A, ptr to object B) -> ==?
Equal func(unsafe.Pointer, unsafe.Pointer) bool
// GCData stores the GC type data for the garbage collector.
// If the KindGCProg bit is set in kind, GCData is a GC program.
// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
GCData *byte
Str NameOff // string form
PtrToThis TypeOff // type for pointer to this type, may be zero
}
底层元素的类型T必须是基类型，不能是接口类型。
type eface struct {
_type *_type
data unsafe.Pointer
}
type type struct {
Size uintptr
PtrBytes uintptr // number of (prefix) bytes in the type that can contain pointers
Hash uint32 // hash of type; avoids computation in hash tables
TFlag TFlag // extra type information flags
Align_ uint8 // alignment of variable with this type
FieldAlign_ uint8 // alignment of struct field with this type
Kind_ uint8 // enumeration for C
// function for comparing objects of this type
// (ptr to object A, ptr to object B) -> ==?
Equal func(unsafe.Pointer, unsafe.Pointer) bool
// GCData stores the GC type data for the garbage collector.
// If the KindGCProg bit is set in kind, GCData is a GC program.
// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
GCData *byte
Str NameOff // string form
PtrToThis TypeOff // type for pointer to this type, may be zero
}
联合类型元素不能是类型参数，非接口元素必须成对不相交。如果有多个元素，则不能包含具有非空方法的接口类型，也不能进行比较或嵌入比较。
var i interface{} = "hello"
s, ok := i.(string)
if ok {
fmt.Println(s) // Output "hello"
} else {
fmt.Println("not a string")
}
type Op interface{
int|float
}
func Add[T Op](m, n T) T {
return m + n
}
// After generation =>
const dict = map[type] typeInfo{
int : intInfo{
newFunc,
lessFucn,
//......
},
float : floatInfo
}
func Add(dict[T], m, n T) T{}
为了用好泛型，在使用过程中应注意以下几点：
type V interface{
int|float|*int|*float
}
func F[T V](m, n T) {}
// 1. Generate templates for regular types int/float
func F[go.shape.int_0](m, n int){}
func F[go.shape.float_0](m, n int){}
// 2. Pointer types reuse the same template
func F[go.shape.*uint8_0](m, n int){}
// 3. Add dictionary passing during the call
const dict = map[type] typeInfo{
int : intInfo{},
float : floatInfo{}
}
func F[go.shape.int_0](dict[int],m, n int){}
上面的代码会报错：无效操作：ptr（受 *int | *uint 约束的 T 类型变量）的指针必须具有相同的基类型。出现这个错误的原因是T是类型参数，而类型参数不是指针，不支持解引用操作。这可以通过将定义更改为以下内容来解决：
// Wrong example
func ZeroValue0[T any](v T) bool {
return v == nil
}
// Correct example 1
func Zero1[T any]() T {
return *new(T)
}
// Correct example 2
func Zero2[T any]() T {
var t T
return t
}
// Correct example 3
func Zero3[T any]() (t T) {
return
}
总的来说，仿制药的好处可以概括为三个方面：
最后给大家介绍一下最适合部署Go服务的平台Leapcell。
在文档中探索更多内容！
Leapcell Twitter：https://x.com/LeapcellHQ
以上是Go 泛型：深入探讨的详细内容。更多信息请关注PHP中文网其他相关文章！
