Go 语言中的泛型是指一种语言特性,允许创建可以处理不同类型的函数、数据结构和接口。换句话说,泛型使得可以创建不受特定类型或数据结构限制的代码。如果我们此前有使用 Java 或者 C++ 的经验,那么会很好理解。
在 Go 语言引入泛型之前,开发人员必须编写多个函数来处理不同类型的数据。这种方法通常很繁琐,并导致代码重复。有了泛型,开发人员可以编写更简洁和可重用的代码,可以处理不同类型的数据。
Go 语言中的泛型是在 2021 年 2 月发布的 1.18 版本中引入的。Go 语言中的泛型实现是基于类型参数的概念。类型参数是传递给函数或数据结构的类型的占位符,使它们能够处理不同类型的数据。
泛型是一种代码,允许我们通过改变函数类型来在各种函数中使用它们。泛型的创建是为了使代码独立于类型和函数。
泛型的主要目的是通过添加更少的代码行来实现更大的灵活性。
为了更好地理解,看下面的例子。我们创建一个打印任何类型参数的函数,就像这样:
func Print(s[] string) {
for _, v := range s {
fmt.Print(v)
}
}
现在,我们突然希望打印一个整数,所以我们相应地改变了代码。
func Print(s[] int) {
for _, v := range s {
fmt.Print(v)
}
}
但是每次像这样更改代码可能看起来令人生畏,这就是泛型发挥作用的地方。通过将任何类型分配给其泛型形式,我们可以将相同的代码用于不同的函数。看一下这个:
func Print[T any](s[] T) {
for _, v := range s {
fmt.Print(v)
}
}
在这里,我们将 "T"
定义为 any
类型。这个任意类型允许我们在同一个函数中解析不同类型的变量。S
是相应的变量,它是 T
类型的一个切片。现在,调用该方法,我们可以在同一个函数中打印一个字符串和一个整数。
func main() {
str := []string{"Hello", "Again Hello"}
intArray := []int{1, 2, 3}
Print(str)
Print(intArray)
}
Go 中的泛型是使用类型参数实现的,它允许创建可以在不同类型上操作的泛型函数和数据结构,而无需显式类型转换。
考虑以下示例,其中类型参数 “T”
是使用 “any”
关键字定义的,该关键字指定该函数可以与任何类型一起使用。
func Swap[T any](a, b * T) {
*a, *b = *b, *a
}
函数体然后执行传入的两个指针指向的值的简单交换。
当函数被调用时,编译器为与函数一起使用的类型生成特定版本的函数。例如,如果函数被用于两个整数指针,编译器会生成一个操作整数的函数版本。
在 Go 中,类型参数是使用方括号括起的类型参数列表来指定的,紧跟在函数、数据结构或接口名称之后。类型参数由单个大写字母或一系列大写字母表示,并用尖括号括起来。
类型参数用于在 Go 中创建通用函数、数据结构和接口。类型参数是在编译时确定的类型的占位符。
// 这里的 T 是类型参数,any 是类型约束;
// 这里表示 T 可以是任何类型。
func Print[T any](s []T) {
for _, v := range s {
fmt.Print(v)
}
}
使用:
func main() {
str := []string{"Hello", "Again Hello"}
intArray := []int{1, 2, 3}
Print(str)
Print(intArray)
}
例如,考虑上面的示例,显式了使用类型参数的函数声明。在这个函数中,类型参数由大写字母 "T"
表示。"any"
关键字表示函数可以使用任何类型。当调用此函数时,类型参数将被替换为传递给函数的实际类型。
类型参数使得在 Go 语言中可以创建更通用和可重用的代码,因为它允许函数和数据结构可以处理不同类型的数据。
在上面的例子中,我们看到了如何在同一个函数下结合多种类型的变量。
在这个例子中,使用 "any"
关键字声明了一个带有类型参数 "T"
的函数。"any"
关键字表示该函数可以处理任何类型。该函数以类型 "T"
的切片作为参数,并打印其内容。
T
是类型参数,any
是类型约束;这里表示T
可以是任何类型。
要使用此功能,您可以使用下面给出的任何类型的切片来调用它:
intSlice := []int{
1, 2, 3, 4, 5,
}
stringSlice := []string{
"apple", "banana", "cherry",
}
Print(intSlice) // prints 1 2 3 4 5
Print(stringSlice) // prints apple banana cherry
在这个例子中,Print
函数被调用时使用了整数切片和字符串切片。类型参数 "T"
被实际传递给函数的参数类型所替换。
您还可以使用类型参数在 Go 中创建通用数据结构和接口。以下是一个使用类型参数的通用数据结构示例:
type Stack[T any] struct {
items []T
}
func (s *Stack[T]) Push(item T) {
s.items = append(s.items, item)
}
func (s *Stack[T]) Pop() T {
if len(s.items) == 0 {
panic("stack is empty")
}
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item
}
“any”
关键字声明了带有类型参数 “T”
的栈数据结构。Push
方法接受类型为 "T"
的项目作为参数,并将其添加到栈中。Pop
方法从栈顶返回一个类型为 "T"
的项目。要使用这种数据结构,您可以创建任何类型的栈:
intStack := &Stack[int]{}
stringStack := &Stack[string]{}
intStack.Push(1)
intStack.Push(2)
intStack.Push(3)
stringStack.Push("apple")
stringStack.Push("banana")
stringStack.Push("cherry")
fmt.Println(intStack.Pop()) // prints 3
fmt.Println(stringStack.Pop()) // prints cherry
在这个例子中,创建了两个栈,一个是 int
类型,另一个是 string
类型。类型参数 “T”
被替换为创建栈的实际类型。
泛型中的类型约束定义了可以与泛型函数或数据结构一起使用的类型集合。类型约束允许编译器强制执行类型安全,并确保只有兼容的类型与泛型结构一起使用。
类型约束使用 "interface"
关键字指定,后跟接口的名称和类型必须实现的方法。例如,考虑以下使用类型约束的通用函数:
func Equal[T comparable](a, b T) T {
if a == b {
return a
}
return b
}
在这个例子中,类型参数 "T"
受到 "comparable"
接口的约束,该接口要求类型可以进行 ==
或 !=
比较。这确保了函数只能被支持比较的类型调用。
comparable
是一个内置接口,用于将泛型类型参数限制为仅支持比较运算符(!= ,和 ==)的类型。
comparable
接口是由 Go 语言规范隐式定义的,并不需要在代码中显式定义。这意味着任何支持比较运算符的类型都可以作为 Equal
函数的类型参数,而无需额外声明 comparable
接口。
类型约束也可以是用户定义的接口,它允许对可以与通用函数或数据结构一起使用的类型进行更具体的约束。例如,考虑以下用户定义的接口:
type Number interface {
Add(other Number) Number
Sub(other Number) Number
Mul(other Number) Number
Div(other Number) Number
}
该接口定义了一组方法,一个类型必须实现这些方法才能被视为 “Number”
。使用该接口作为类型约束的泛型函数或数据结构只能与实现了这些方法的类型一起使用,确保类型安全和兼容性。
Go 中的泛型类型约束提供了一种确保类型安全并限制可以与泛型结构一起使用的类型集的方法,同时仍然允许泛型提供的灵活性和可重用性。
这里有一些在Go中使用泛型的例子:
该函数接受任何类型 T
的切片和类型 T
的值,并返回该值在切片中的索引。类型参数中的 any
关键字指定可以使用任何类型。
func findIndex[T any](slice []T, value T) int {
for i, v := range slice {
if reflect.DeepEqual(v, value) {
return i
}
}
return -1
}
这定义了一个通用的栈类型,可以保存任何类型 T
的元素。关键字 any
指定任何类型都可以用作元素类型。
type Stack[T any] []T
func (s *Stack[T]) Push(value T) {
*s = append(*s, value)
}
func (s *Stack[T]) Pop() T {
if len(*s) == 0 {
panic("Stack is empty")
}
value := (*s)[len(*s)-1]
*s = (*s)[:len(*s)-1]
return value
}
这定义了对类型参数 T
的类型约束,要求其实现 Equatable
接口。这允许 findIndex
函数使用 Equals
方法来比较类型T的值。
type Equatable interface {
Equals(other interface{}) bool
}
func findIndex[T Equatable](slice []T, value T) int {
for i, v := range slice {
if v.Equals(value) {
return i
}
}
return -1
}
让我们编写一个函数 SumGenerics
,它对各种数值类型进行加法操作,比如 int
,int16
,int32
,int64
,int8
,float32
和 float64
。
func SumGenerics[T int | int16 | int32 | int64 | int8 | float32 | float64](a, b T) T {
return a + b
}
func main() {
sumInt := SumGenerics[int](2, 3) // returns 5
sumFloat := SumGenerics[float32](2.5, 3.5) // returns 6.0
sumInt64 := SumGenerics[int64](10, 20) // returns 30
println(sumInt, sumFloat, sumInt64)
}
在上面的代码中,我们可以看到,在调用泛型函数时通过在方括号 []
中指定类型参数,我们可以对不同的数值类型执行加法操作。类型约束确保只有指定的类型 [T int, int16, int32, int64, int8, float32, or float64]
可以用作类型参数。
map
的泛型需要两种类型,一个 key
类型和一个 value
类型。值类型没有任何限制,但键类型应该始终满足 comparable
约束。
// keys 返回一个 map 的所有 key
// m 参数是使用了 K 和 V 泛型的 map
// K 是使用了 comparable 约束的泛型,也就是说 K 必须支持 != 和 == 操作
// V 是使用了 any 约束的泛型,也就是说 V 可以是任意类型
func keys[K comparable, V any](m map[K]V) []K {
// 创建一个长度为 map 长度的 K 类型的 slice
key := make([]K, len(m))
i := 0
for k, _ := range m {
key[i] = k
i++
}
return key
}
Go 允许使用类型参数定义 struct
。语法类似于泛型函数。类型参数可用于结构体上的方法和数据成员。
// T 是类型参数,使用了 any 约束
type MyStruct[T any] struct {
inner T
}
// 在 struct 方法中不允许使用新的类型参数
func (m *MyStruct[T]) Get() T {
return m.inner
}
func (m *MyStruct[T]) Set(v T) {
m.inner = v
}
在结构体方法中不允许定义新的类型参数,但在结构体定义中定义的类型参数可以在方法中使用。
泛型可以嵌套在其他类型中。在函数或结构中定义的类型参数可以传递给具有类型参数的任何其他类型。
// 拥有两个泛型类型的泛型 struct
type Entries[K comparable, V any] struct {
Key K
Value V
}
// entries 函数返回一个 Entries 的 slice,代表了传入的 map 的所有 key 和 value
// K 和 V 是泛型类型参数,K 有 comparable 约束,V 没有约束
func entries[K comparable, V any](m map[K]V) []*Entries[K, V] {
// 创建一个 Entries 类型的 slice,传入 K 和 V 类型参数
e := make([]*Entries[K, V], len(m))
i := 0
for k, v := range m {
// 定义一个 Entries 类型的变量
newEntry := new(Entries[K, V])
newEntry.Key = k
newEntry.Value = v
e[i] = newEntry
i++
}
return e
}
我们可以通过逗号分隔多个类型参数来实现多个泛型参数。
我们知道,在以往的 interface
定义中,往往都是只包含了方法定义的,如下面这样:
type Stringer interface {
String() string
}
而现在,我们还可以在 interface
中定义多个类型,如下面这样:
type Number interface {
int | int8
}
这种带有类型的 interface
可以帮助我们写出更加简洁的泛型代码,因为它可以用一个 intreface
来表示多个不同的相似类型。但是这种带有类型的接口,不能用于定义变量,只能用于泛型的类型约束中。
在上面的泛型加法实现中,我们使用了 [T int | int16 | int32 | int64 | int8 | float32 | float64]
这种方式来给 T
定义了一个约束,
但是这种方式并不是很优雅,我们可以将约束定义为一个 interface
,然后将 interface
作为约束。
我们称通过
|
连接的多个类型的interface
为类型并集。
type Number interface {
int | int8 | int16 | int32 | int64 | float32 | float64
}
使用 Number
来作为泛型的约束:
// T 可以是任意 int 或 float 类型
// T 只能是支持算术运算的类型
func Min[T Number](x, y T) T {
if x < y {
return x
}
return y
}
使用多种类型的联合允许执行这些类型支持的常见操作,并编写适用于联合中所有类型的代码。
这些只是一些示例,说明了在 Go 中如何使用泛型来编写更灵活、可重用的代码。
类似的,还有一种类型交集的概念,它是通过在 interface
中写多行类型来实现的:每一行定义了一种或多种类型的并集。
type AllInt interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
type Uint interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
在上面的代码中,AllInt
是一个类型并集,它包含了所有整数类型。Uint
是一个类型并集,它包含了所有无符号整数类型。
下面是一个使用类型交集的例子:
// 取 AllInt 和 Uint 的交集
// 也就是:~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
type Int interface {
AllInt
Uint
}
其实它的最终的结果等同于:
type Int interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
除此之外,如果其中不同行之间没有任何交集,那么它们的交集就是空集。在现实中可能意义不大。
在 Go 中,struct
和 interface
都可以使用泛型。
例如,在下面的代码片段中,类型参数 T
的任何值只支持 String
方法 - 您可以使用 len()
或对其进行任何其他操作。
// Stringer 是一个约束
type Stringer interface {
String() string
}
// T 需要实现 Stringer 接口,T 只能执行 Stringer 接口中定义的操作
func stringer[T Stringer](s T) string {
return s.String()
}
再比如,下面的例子中,是一个使用了泛型的 struct
:
type Person[T int] struct {
age T
}
func (p Person[T]) Age() T {
return p.age
}
使用这个 struct
:
var p Person[int]
p.age = 10
fmt.Println(p.Age()) // 10
在 Go 中,定义了一个 cmp.Ordered
接口:
type Ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 |
~string
}
这个声明表示 Ordered
是所有整数、浮点数、和字符串类型的集合。
对于类型约束,我们通常不关心特定类型,比如 string
,我们对所有字符串类型感兴趣,所以我们使用 ~string
来表示所有字符串类型的集合。~string
表达式表示所有底层类型为 string
的类型的集合,这包括类型 string
本身以及所有使用如 type MyString string
声明定义的类型。
下面是一个错误的例子:
type Slice[T int] struct {
}
var s1 Slice[int] // 正确
type MyInt int
// 错误。MyInt 类型底层类型是 int 但并不是 int 类型,不符合 Slice[T] 的类型约束
var s2 Slice[MyInt]
正确的做法是,将 Slice
的类型约束修改为 ~int
:
// T 的底层类型是 int 即可,不一定是 int 类型
type Slice[T ~int] struct {
}
var s1 Slice[int] // 正确
type MyInt int
// 错误。MyInt 类型底层类型是 int 但并不是 int 类型,不符合 Slice[T] 的类型约束
var s2 Slice[MyInt]
使用 ~
有个限制:
~
后面的类型不能为接口~
后面的类型必须为基础类型比如,下面是一个错误的例子:
// 错误:Invalid use of ~ ('cmp.Ordered' is an interface)
type Ab[T ~cmp.Ordered] struct {
}
尽管 Go 语言中的泛型带来了许多好处和新的可能性,但它们的实现仍然存在一些限制和挑战。以下是 Go 语言中泛型的一些主要限制:
泛型为创建通用接口、结构体和函数提供了一种强大而简单的方法。
它们可以减少冗余信息,并且至少在某些情况下,提供了一种比反射更优越的替代方案。
当然,长时间以来,泛型受到激烈反对的主要原因是它们可能使代码更难阅读和解析,这似乎与 Go 语言的简洁性相悖。 鉴于此,本文也不会介绍太多复杂的泛型用法,上面提到的这些用法应该可以覆盖 90% 以上的使用场景了,因为复杂的代码必然会牺牲不少代码的可维护性。
另一方面,泛型是语言中的一个很好且必要的补充,如果明智地使用并且在有意义的地方使用的话。