在 Go 语言中,“泛型类型(Generic Types)” 指的是带有类型形参的自定义数据类型,主要包括泛型结构体、泛型切片和泛型 Map。
前面我们学习了给泛型函数添加 [T any] 来复用计算逻辑。同样地,当多个数据结构内部的组成形式完全相同、仅仅是保存的数据类型不同时,我们也可以把它们定义成泛型类型。
Go 泛型结构体
在实际开发中,泛型结构体是最常用的一种泛型类型。与普通的结构体相比,泛型结构体就像一份 “预留了类型空位的模具”。我们在定义时先使用 T 给字段类型占个位置,使用时填入 [int] 就是存放整数的结构体,填入 [string] 就变成了存放字符串的结构体,如下图所示。

语法:
type 结构体名[T 类型约束] struct {
字段名 T
}说明:
定义泛型结构体时,我们只需要在结构体名称后面加上方括号(如 [T any]),随后在花括号内部就可以直接把 T 当作普通的数据类型来声明字段了。
需要特别注意的是,Go 语言目前只支持对泛型函数自动推断类型,不支持对泛型类型自动推断类型。因此在创建泛型结构体变量时,我们必须在结构体名称后面显式写出具体类型(如 Box[int]),不能省略方括号。
示例 1:定义并使用泛型结构体
package main
import "fmt"
// 定义通用的盒子结构体
type Box[T any] struct {
Value T
}
func main() {
// 创建存放 int 类型的 Box
intBox := Box[int]{Value: 100}
fmt.Println(intBox.Value)
// 创建存放 string 类型的 Box
strBox := Box[string]{Value: "Hello, Go"}
fmt.Println(strBox.Value)
}运行结果如下。
100
Hello, Go分析:
type Box[T any] struct 定义了一个泛型结构体 Box,内部的 Value 字段类型为 T。
在 main() 函数中,Box[int]{Value: 100} 将 T 指定为 int,此时 intBox.Value 就是整数类型。而 Box[string]{Value: "Hello, Go"} 将 T 指定为 string,此时 strBox.Value 就是字符串类型。
很多初学的小伙伴在创建泛型结构体变量时,容易像调用泛型函数那样把 [int] 省掉。需要注意,下面这种省略方括号的写法是错误的。
// 正确方式
intBox := Box[int]{Value: 100}
// 错误方式
intBox := Box{Value: 100}为什么上面的错误方式无法通过编译呢?因为 Box 本身只是一个结构体模板,只有传入具体类型写成 Box[int] 后,才算是一个完整可用的数据类型,这一步在 Go 语言中叫做 “实例化”。
如果我们直接写 Box{Value: 100},编译时就会报错 “cannot use generic type Box[T any] without instantiation”,提示泛型类型必须先指定具体类型才能使用。
如果一个结构体内部有多个不同字段的类型需要灵活指定,我们也可以在方括号中同时声明多个类型形参。下面来看一个包含两个类型形参的例子。
示例 2:包含多个类型形参的结构体
package main
import "fmt"
// 包含 K 和 V 两个类型形参的结构体
type Pair[K, V any] struct {
Key K
Val V
}
func main() {
p1 := Pair[string, float64]{Key: "苹果", Val: 12.6}
p2 := Pair[string, int]{Key: "香蕉", Val: 5}
fmt.Printf("%s:%.1f\n", p1.Key, p1.Val)
fmt.Printf("%s:%d\n", p2.Key, p2.Val)
}运行结果如下。
苹果:12.6
香蕉:5分析:
上面代码中,Pair[K, V any] 定义了一个包含 Key 和 Val 两个字段的泛型结构体。创建变量 p1 时,我们通过 Pair[string, float64] 按顺序将 K 指定为 string、将 V 指定为 float64。而在创建 p2 时,则将 V 指定为 int。
提示: 在实际后端开发中,泛型结构体经常用来定义统一的接口返回格式。比如定义一个 Response[T any] 结构体,把状态码 Code 固定为 int、提示信息 Msg 固定为 string,数据字段 Data T 则按需装入用户信息或商品列表。
为泛型结构体绑定方法
在 Go 语言中,我们同样可以为泛型结构体绑定专属的方法。编写方法时,只需要在接收者的结构体名称后面带上类型形参 [T] 即可。
语法:
func (接收者变量 结构体名[T]) 方法名(参数列表) 返回值类型 {
// 方法体
}
func (接收者变量 *结构体名[T]) 方法名(参数列表) 返回值类型 {
// 方法体
}说明:
泛型结构体的方法既可以使用值接收者(如 (b Box[T])),也可以使用指针接收者(如 (b *Box[T]))。不管采用哪一种,接收者类型名称后面都必须带上 [T],随后在方法的参数列表、返回值以及方法体内部就能直接使用这个 T 了。
示例 3:为泛型结构体绑定方法
package main
import "fmt"
type Box[T any] struct {
Value T
}
// 获取盒子中的值(值接收者)
func (b Box[T]) Get() T {
return b.Value
}
// 修改盒子中的值(指针接收者)
func (b *Box[T]) Set(v T) {
b.Value = v
}
func main() {
b := Box[int]{Value: 10}
fmt.Println(b.Get())
b.Set(20)
fmt.Println(b.Get())
}运行结果如下。
10
20分析:
在这个例子中,我们为 Box[T] 结构体绑定了 Get() 和 Set() 两个方法。其中 Set() 方法需要修改结构体内部字段的值,因此接收者使用了指针类型 *Box[T]。
当变量 b 被指定为 Box[int] 类型后,调用 b.Get() 返回的就是 int 类型,调用 b.Set(20) 时也只能传入 int 类型的数值。
注意:
- 接收者后面不重复写类型约束:编写方法时,接收者小括号里只能写
(b Box[T])或(b *Box[T]),不能在T后面重复写上约束,写成(b *Box[T any])会引发编译报错。 - 方法不能新增独立的类型形参:方法只能使用接收者已有的
T,不能在方法名后再声明新形参(如func (b *Box[T]) Convert[U any]()会报错)。如果需要引入新形参,改写成独立泛型函数(如func convert[T, U any](b Box[T]) U)即可。
泛型切片与泛型 Map
除了定义泛型结构体之外,我们还可以使用 type 关键字配合类型形参,定义自定义的 “泛型切片” 或 “泛型 Map” 类型。
为什么要定义自定义泛型切片呢?因为 Go 语言不允许直接给内置切片 []T 绑定方法,但只要通过 type List[T any] []T 将它定义为自定义泛型类型,我们就可以像结构体一样为它绑定专属的方法了。下面来看具体写法。
示例 4:定义泛型切片并绑定方法
package main
import "fmt"
// 定义泛型切片类型
type List[T any] []T
// 为泛型切片绑定添加元素的方法
func (l *List[T]) Add(v T) {
*l = append(*l, v)
}
func main() {
nums := List[int]{10, 20}
nums.Add(30)
fmt.Println(nums)
words := List[string]{"Hello"}
words.Add("Go")
fmt.Println(words)
}运行结果如下。
[10 20 30]
[Hello Go]分析:
type List[T any] []T 定义了一个自定义泛型切片类型 List[T]。由于使用 append() 追加元素会改变切片自身的长度,甚至触发底层扩容,因此我们在绑定 Add(v T) 方法时必须使用指针接收者 *List[T],具体原因和前面学过的值接收者与指针接收者一样。
与结构体访问字段会自动解引用不同,这里我们要替换的是整个切片本身。由于接收者 l 是一个指向切片的指针,因此需要先通过 *l 取出原切片传给 append(*l, v),再把追加元素后的新切片重新赋回给 *l。
采用同样的方式,我们也可以定义自定义的泛型 Map 类型并为其绑定实用方法。不过需要注意,Go 语言的 Map 要求键(Key)必须支持使用 == 判断是否相等,而 any 包含的切片、函数等类型是无法比较相等的。
因此在定义泛型 Map 时,键的约束不能写成 any,而应该使用内置的 comparable 来限定键必须可判等。关于它的更多细节,我们会在下一节 “Go 泛型约束” 中展开介绍,下面先来看具体的代码。
示例 5:定义泛型 Map 并绑定方法
package main
import "fmt"
// 定义泛型 Map 类型
type Dict[K comparable, V any] map[K]V
// 判断指定的键是否存在
func (d Dict[K, V]) Has(key K) bool {
_, ok := d[key]
return ok
}
func main() {
// 键为 string、值为 int 的 Map
scores := Dict[string, int]{
"Jack": 95,
"Lucy": 88,
}
fmt.Println(scores["Jack"], scores.Has("Jack"))
// 键为 int、值为 string 的 Map
users := Dict[int, string]{
1001: "Jack",
1002: "Lucy",
}
fmt.Println(users[1001], users.Has(1003))
}运行结果如下。
95 true
Jack false分析:
type Dict[K comparable, V any] map[K]V 定义了一个自定义泛型 Map 类型 Dict。其中键 K 使用 comparable 限定为可判等的类型(如 string、int),而值 V 没有这个限制,继续使用 any 允许存入任意类型的数据。
为它绑定 Has(key K) bool 方法后,不管是键为 string 的 scores 还是键为 int 的 users,我们都能直接调用 Has() 来判断某个键是否存在,不用每次都手动写 _, ok := m[key] 了。小伙伴们也可以试着再给它补充一个 Keys() 方法来练练手。
