Go 1.18新特性之泛型的全面讲解

背景介绍

在软件开发过程中，我们经常需要使用数据结构（如列表、树、哈希表等）和算法（如排序、查找、遍历等）。在现有的编程语言中，使用这些数据结构和算法都需要我们重复编写许多相似的代码，这不仅浪费时间，也容易引入bug。因此，一种可以重复使用的通用代码块，也就是“泛型”，成为了程序员们迫切需要的功能之一。

在Go语言的早期版本中，它并不支持泛型，在某种程度上约束了Go语言在编写通用代码块方面的能力。不过，Go 1.18版本带来了一种全新的泛型实现方式，这使得在Go语言中编写更高效、更简洁、更易维护的通用代码变得更加容易和自然。

泛型的基本概念

泛型是指一种通用的编程方式，它可以使不同的数据类型和算法共用相同的代码结构，从而达到重复使用、减少代码冗余、提高代码复用性等目标。一种常见的泛型编程方式是使用类型参数，以此来表示不确定的类型，比如：

func Swap[T any](a,b *T) {
    tmp := *a
    *a = *b
    *b = tmp
}

该函数使用了类型参数T，并且T继承了any类型，表示它可以是任意类型。在调用该函数时，编译器会根据实际的参数类型来推断T的具体类型。例如：

a := 1
b := 2
Swap(&a, &b) // a = 2, b = 1

c := "hello"
d := "world"
Swap(&c, &d) // c = "world", d = "hello"

从中可以看到，我们不用在编写不同类型的swap函数时重复编写相似的代码，只需在同一个函数中通过泛型实现即可，更加简洁易懂。

泛型的特性

Go 1.18版本中提供的泛型支持具有以下特性：

1. 类型参数：可以在函数或结构体定义中定义类型参数，使用时根据实际情况传递具体类型。

2. 接口约束：类型参数可以约束为只接受实现了特定接口的类型。

3. 类型约束：类型参数可以约束为只接受特定类型，可以使用int、string和任意已知的类型、也可以使用其他泛型类型参数作为约束。

4. 泛型函数：支持定义泛型函数，并使用类型参数来推断和调用该函数。

5. 泛型结构体：支持定义泛型结构体，并使用类型参数来推断和初始化结构体。

示例说明

泛型函数

在下面的示例中，我们使用LinkNode泛型类型来实现一个通用的链表，其中使用NewList函数来创建链表，使用Append函数来添加元素。相比于在旧版本的Go语言中，需要分别编写int和string类型的链表，使用泛型实现可以显著提高代码复用性。

package main

import "fmt"

type LinkNode[T any] struct {
    Value T
    next *LinkNode[T]
}

func NewList[T any]() *LinkNode[T] {
    return nil
}

func Append[T any](node *LinkNode[T], value T) *LinkNode[T] {
    if node == nil {
        return &LinkNode[T]{Value: value, next: nil}
    }
    node.next = Append(node.next, value)
    return node
}

func main() {
    list := NewList[int]()
    for i := 0; i < 10; i++ {
        list = Append(list, i)
    }
    for node := list; node != nil; node = node.next {
        fmt.Println(node.Value)
    }
}

泛型结构体

在下面的示例中，我们使用Stack泛型结构体来实现一个通用的栈，Push用来添加元素，Pop用来弹出元素。其中T是泛型类型参数，表示栈中存储的元素类型。相比于在旧版本的Go语言中，需要分别编写int和string类型的栈，使用泛型实现可以显著提高代码复用性。

package main

import "fmt"

type Stack[T any] struct {
    top  int
    data []T
}

func NewStack[T any]() *Stack[T] {
    return &Stack[T]{0, make([]T, 10)}
}

func (s *Stack[T]) Push(value T) {
    if s.top >= len(s.data) {
        // 栈已满，扩容
        newdata := make([]T, s.top+10)
        for i, v := range s.data {
            newdata[i] = v
        }
        s.data = newdata
    }
    s.data[s.top] = value
    s.top++
}

func (s *Stack[T]) Pop() T {
    if s.top <= 0 {
        panic("stack is empty")
    }
    s.top--
    return s.data[s.top]
}

func main() {
    intstack := NewStack[int]()
    intstack.Push(10)
    intstack.Push(20)
    fmt.Printf("%d, %d\n", intstack.Pop(), intstack.Pop())

    stringstack := NewStack[string]()
    stringstack.Push("hello")
    stringstack.Push("world")
    fmt.Printf("%s, %s\n", stringstack.Pop(), stringstack.Pop())
}

结论

泛型作为一种通用的编程方式，在Go语言中得以完美落地，能够显著提高代码复用性，降低编程难度和维护成本。并且，由于Go语言泛型的实现方式与其它语言有所不同，因此也能够避免类型装箱、拆箱等转换过程，性能表现尤为卓越。在Go语言的未来开发中，泛型将成为Go语言编程的核心能力之一。