Go 泛型类型

在 Go 语言中,“泛型类型(Generic Types)” 指的是带有类型形参的自定义数据类型,主要包括泛型结构体、泛型切片和泛型 Map。

前面我们学习了给泛型函数添加 [T any] 来复用计算逻辑。同样地,当多个数据结构内部的组成形式完全相同、仅仅是保存的数据类型不同时,我们也可以把它们定义成泛型类型。

Go 泛型结构体

在实际开发中,泛型结构体是最常用的一种泛型类型。与普通的结构体相比,泛型结构体就像一份 “预留了类型空位的模具”。我们在定义时先使用 T 给字段类型占个位置,使用时填入 [int] 就是存放整数的结构体,填入 [string] 就变成了存放字符串的结构体,如下图所示。

Go 泛型结构体传入具体类型生成实例

语法:

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() 方法来练练手。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号