Go语言进化之路：泛型的崛起与复用的新篇章

妖狐艹你老母 2024-03-02 08:56 9阅读 0赞

### **一、引言** ###

泛型编程在许多编程语言中都是一项非常强大的特性，它可以使程序更加通用、具有更高的重用性。然而，Go语言在很长一段时间内一直没有提供泛型功能。在过去的一些版本中，Go语言开发者试图引入泛型，但最终都因为各种原因被取消或搁置了。直到Go 1.18版本，终于引入了泛型功能。在本文中，将会介绍这项新特性及其使用方法。

### **二、什么是泛型？** ###

泛型是一种编程语言的特性，它可以将类型参数化，并以类型参数形式传递到不同的算法和数据结构中。泛型使得程序可以更加通用、安全且具有更高的重用性。不同的类型参数可以通过参数化类型类型来表示。例如，在Java中，可以使用ArrayList<Integer>来表示包含整数的动态数组，其中Integer是类型参数的类型。

在Go语言中，泛型的类型参数可以是任何类型，包括基本类型、引用类型、结构体和接口等。这些类型参数可以用在函数、方法、结构体、接口、通道和映射等语法结构中。

### **三、得一切从函数的形参和实参说起** ###

当谈到泛型编程时，我们需要了解两个重要的概念：类型形参和类型实参。

*  **类型形参（Type Parameters）：**类型形参是一种在泛型代码中使用的占位符类型。它们允许我们定义函数、方法或数据结构，这些代码可以处理多种类型的数据而不是特定的类型。在 Go 语言中，类型形参使用方括号 \[\] 包围，并且可以在函数、方法或结构体的名称后面定义。例如，func Test\[T any\](x T) 中的 \[T any\] 就是一个类型形参。在使用泛型函数或结构体时，我们需要提供实际的类型实参来替换类型形参的位置。
 *  **类型实参（Type Arguments）：**类型实参是在使用泛型代码时提供的具体类型。当我们调用泛型函数或实例化泛型结构体时，我们需要指定具体的类型实参，以替换泛型代码中的类型形参。类型实参可以是任何合法的类型，包括基本类型、结构体、接口类型等。例如，Test\[int\](3) 中的 \[int\] 就是一个类型实参。

使用类型形参和类型实参的一个典型例子是在泛型函数中定义类型形参，然后调用该函数时提供类型实参的类型。例如：

package main
    
    
    import "fmt"
    
    
    // 定义泛型函数
    func PrintType[T any](x T) {
        fmt.Printf("Type: %T\n", x)
    }
    
    
    func main() {
        // 调用泛型函数，类型实参为 int
        PrintType[int](42)
        // 调用泛型函数，类型实参为 string
        PrintType[string]("hello")
    }
    输出结果：
    Type: int
    Type: string

在上面的示例中，我们定义了一个名为 PrintType 的泛型函数，并使用 \[T any\] 声明了一个类型形参。然后，在调用该函数时，我们使用类型实参来具体化类型形参，例如使用 int 和 string。这样，在函数内部，我们就可以使用具体的类型信息来打印数据的类型。

类型形参和类型实参的使用为我们提供了更大的灵活性和通用性，使得我们可以编写可处理多种类型的泛型代码。

### **四、Go的泛型** ###

通过上面的代码，我们对Go的泛型编程有了最初步也是最重要的认识——类型形参 和类型实参。而Go 1.18也是通过这种方式实现的泛型，但是单纯的形参实参是远远不能实现泛型编程的，所以Go还引入了非常多全新的概念：

*  **类型形参 (Type parameter)：**用于定义泛型类型、泛型函数等模板中，形参类型的占位符。在Go中用\[T any\]这样的方式表示。
 *  **类型实参(Type argument)：**在使用泛型类型或泛型函数的时候，为泛型中的类型参传递具体的类型实参。比如，如果一个结构体类型定义了一个字段类型是泛型类型 T，在使用这个结构体类型的时候可以指定 T 的类型实参，如 MyStruct\[int\]。
 *  **类型形参列表( Type parameter list)：**泛型函数、泛型类型等中声明的形参列表，语法形如：\[T any,U any\]
 *  **类型约束(Type constraint)：**为泛型类型参与约束其类型范围的限制，以确保对应的类型实具有部分或者接口关系后代等。仅在Go 1.18版本及更高版本中支持。
 *  **实例化(Instantiations)：**根据泛型类型的模板和类型实参生成具体类型的过程，本质上是传统意义下函数调用时的实参传递和函数执行的过程。
 *  **泛型类型(Generic type)：**包含一个或多个类型形参的类型。在定义时可以通过使用type关键字进行，例如 type MyStruct\[T any\] struct \{\}，表示定义了一个名为MyStruct的泛型结构体。
 *  **泛型接收器(Generic receiver)：**用于为泛型类型声明方法，可以通过定义泛型接收器来为泛型类型定义具有泛型类型参数的方法，实现代码复用的目的。
 *  **泛型函数(Generic function)：**包含一个或多个类型参参的函数，在调用时可以传递类型实参，确定具体类型的函数实例。在使用时，可以通过像调用普通函数一样调用它，但需要在函数名后面使用 \[T any\] 等形式声明其类型形参。

type MySlice[T int|float32|float64 ] []T
    
    
    var mySlice MySlice[int]
    上面这段代码定义了一个具有类型约束的泛型类型MySlice，T为类型参，必须是int、float32或float64之一，表示只能用这个明确的类型代替T。MySlice[T]表示一个元素类型为T切片类型。
    T 就是类型形参(Type parameter)，类似一个占位符
    int|float32|float64 就是类型约束(Type constraint)，中间的 | 就是或的意思，表示类型形参 T 只接收 int 或 float32 或 float64 这三种类型的实参
    中括号里的 T int|float32|float64 这一整串因为定义了所有的类型形参(在这个例子里只有一个类型形参T），所以我们称其为 类型形参列表(Type parameter list)
    在使用MySlice时，如MySlice[int]表示元素类型为int切片类型，int 就是类型实参(Type argument)
    上面只是个最简单的例子，实际上类型形参的数量可以远远不止一个，如下：
    // CostMap类型定义了两个类型形参 KEY 和 VALUE。分别为两个形参指定了不同的类型约束
    // 这个泛型类型的名字叫：CostMap[KEY, VALUE]
    type CostMap[KEY int | string, VALUE float32 | float64] map[KEY]VALUE  
    
    
    // 用类型实参 string 和 flaot64 替换了类型形参 KEY 、 VALUE，
    // 泛型类型被实例化为具体的类型：CostMap[string, float64]
    var a CostMap[string, float64] = map[string]float64{
        "dept1_cost": 8913.34,
        "dept2_cost": 4295.64,
    }

**用上面的例子重新复习下各种概念：**

*  KEY和VALUE是类型形参。
 *  int|string 是KEY的类型约束， float32|float64 是VALUE的类型约束。
 *  KEY int|string, VALUE float32|float64 整个一串文本因为定义了所有形参所以被称为类型形参列表。
 *  Map\[KEY, VALUE\] 是泛型类型，类型的名字就叫 Map\[KEY, VALUE\]。
 *  var a CostMap\[string, float64\] 中的string和float64是类型实参，用于分别替换KEY和VALUE，实例化出了具体的类型 CostMap\[string, float64\]。

**用如下一张图就能简单说清楚：**

![图片][d7dd9856bf620208143771d9c20a1a47.jpeg]

### 五、Go泛型实现方式 ###

在Go语言中，泛型的实现方式是使用类型参数化函数和类型参数化结构体。类型参数化函数是一种函数，接受类型参数作为输入，并根据这些类型参数返回不同的结果。类型参数化结构体是一种结构体，其中一些或全部成员字段由类型参数确定。

**以下是一个用于从切片中查找元素并返回其索引的类型参数化函数的代码示例：**

func Find[T comparable](slice []T, value T) int {
        for i, v := range slice {
            if v == value {
                return i
            }
        }
        return -1
    }

这个函数接收一个任意类型的切片和一个具有相同类型的值，并返回第一次出现该值的索引。类型参数T必须是“comparable”类型，也就是说，它必须是可比较的类型，这是Go泛型的一个限制。

以下是一个用于实现一个类型安全的栈的类型参数化结构体代码示例：

type Stack[T any] struct {
        data []T
    }
    
    
    func (s *Stack[T]) Push(v T) {
        s.data = append(s.data, v)
    }
    
    
    func (s *Stack[T]) Pop() (t T, err error) {
       if len(s.data) == 0 {
          return t, errors.New("stack is empty")
       }
       res := s.data[len(s.data)-1]
       s.data = s.data[:len(s.data)-1]
       return res, nil
    }
    
    
    func main() {
       var stack Stack[int]
       stack.Push(1)
       stack.Push(2)
       stack.Push(3)
       item, err := stack.Pop()if err != nil {
          fmt.Println("Error:", err)
       } else {
          fmt.Println("Pop item:", item)
       }
       item, err = stack.Pop()if err != nil {
          fmt.Println("Error:", err)
       } else {
          fmt.Println("Pop item:", item)
       }
    }

这个结构体表示栈，其中T是元素类型，并且在Push和Pop函数中使用。注意，这里的类型参数T没有任何限制，因此可以传递任何类型。var stack Stack\[int\] 在初始化实例时，就把类型设置好了。

以上是一些示例代码，展示了Go泛型的使用。在复杂的程序中，泛型的使用可以使代码更加通用、易于阅读、安全且具有更高的重用性。

### **六、Go语言和其他语言在泛型上的对比** ###

Go语言的泛型实现与其他编程语言（如Java、C++、C\#等）的泛型实现有一些不同的地方。以下是它们在一些方面的对比：

1.  **语法：**Go泛型的语法相对简单，采用了类似接口的方式声明泛型类型参数，用\[Tany\]这样的方式表示。而其他语言的泛型语法则比较复杂，涉及到泛型类、泛型型式方法等多个方面。
2.  **实现方式：**Go泛型的实现方式采用了代码生成（代码生成）的方式，即在编译时自动生成特定类型的代码。而其他语言则采用了编译时静态类型检查的方式，即在编译时对泛型类型参数进行类型检查，并生成相应的代码。
3.  **类型限制：**泛型的类型限制比较广泛，可以使用任意类型作为泛型类型参数。而其他语言则通常需要对泛型类型参数进行限制，以确保其满足特定的类型要求（如继承关系、实现接口等）。
4.  **性能：**Go泛型的性能比其他的泛型实现要低一些，因为其采用了代码生成的方式，在运行时需要额外生成和加载对应的代码。而其他语言则采用了预编译的方式，在编译时已经生成了相应的代码，运行时不需要再进行额外的操作。

总的来说，Go泛型的实现方式比较简单、灵活，但在性能方面有些损失。但同时，Go语言也在持续地改进其泛型实现，以提高其性能，并加入更多的功能特性。

### **七、Go的实战应用** ###

以下代码是Go中用泛型实现Set无序集合，包含了添加，删除，是否存在，转成列表等方法。

type Set[T comparable] struct {
       m map[T]struct{}
    }
    
    
    func (s *Set[T]) Add(t T) {
       s.m[t] = struct{}{}
    }
    
    
    func (s *Set[T]) Remove(t T) {
       delete(s.m, t)
    }
    
    
    func (s *Set[T]) Exist(t T) bool {
       _, ok := s.m[t]
       return ok
    }
    
    
    func (s *Set[T]) List() []T {
       t := make([]T, len(s.m))
       var i int
       for k := range s.m {
          t[i] = k
          i++
       }
       return t
    }
    
    
    func (s *Set[T]) ForEach(f func(T)) {
       for k, _ := range s.m {
          f(k)
       }
    }

### **八、Go泛型的优势** ###

Go泛型的出现，使得我们可以更加通用、安全且具有更高的重用性。它的出现具有以下优势：

1.  **更加通用：**泛型使得我们可以创建能够操作任何类型的数据结构和算法，从而使得代码可以更加通用。
2.  **安全性**：类型参数化函数和类型参数化结构体使得编译器可以对代码进行更严格的类型检查，从而减少了许多类型相关的运行时错误。
3.  **可读性**：类型参数化使得代码可以更加清晰、简洁和易于阅读。在不同的数据结构和算法中，使用相同的代码模板可以减少代码量。

### **九、总结** ###

在Golang中，泛型功能的引入提高了Go的通用性、可读性和安全性。使用类型参数化的方式，我们可以编写出可以处理任何类型的代码。尽管Go泛型的实现方式略有不同于其他语言，但仍然可以为程序员提供实用的工具和功能，使代码更加通用、安全、易读和易于维护。

[d7dd9856bf620208143771d9c20a1a47.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/0a46137fe98e498ab797c339fe2f0acd.png