golang.18泛型

非泛型版本:

写一段段冒泡排序的代码，但是这个bubbleSort函数参数类型只能为int64，也就是说我们只能传入一个类型为int64切片，如果我需要传入其他类型的数据，那么我们就需要重新写一个函数逻辑是相同的代码片段但是类型又不同，这就是没有泛型带来的痛苦.

package main

import "fmt"

func bubbleSort(sequence []int64) {
    for i := 0; i < len(sequence)-1; i++ {
        for j := 0; j < len(sequence)-1-i; j++ {
            if sequence[j] > sequence[j+1] {
                sequence[j], sequence[j+1] = sequence[j+1], sequence[j]
            }
        }
    }
}

func main() {
    var sequence = []int64{12, 11, 100, 99, 88, 23}
    bubbleSort(sequence)
    fmt.Println(sequence)
}

有时候在开发的时候，为了统一使用一个函数处理，没有泛型情况下，需要对类型进行断言处理，例如在某种情况下居然写出下面这样的代码：

func bubbleSortByInterface(sequence []interface{}) {
    switch sequence[0].(type) {

    case int64:

        var arr []int64
        for _, val := range sequence {
            arr = append(arr, val.(int64))
        }

        for i := 0; i < len(arr)-1; i++ {
          for j := 0; j < len(arr)-1-i; j++ {
                if arr[j] > arr[j+1] {
                    arr[j], arr[j+1] = arr[j+1], arr[j]
                }
          }
        }
        fmt.Println(arr)
    case float64:

        var arr []float64
        for _, val := range sequence {
            arr = append(arr, val.(float64))
        }

        for i := 0; i < len(arr)-1; i++ {
          for j := 0; j < len(arr)-1-i; j++ {
              if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
              }
          }
        }
        fmt.Println(arr)
    default:
        panic("type not support!!!")
    }
}

然后就可以使用interface:

func main() {
    var sequence = []interface{}{12.12, 1.1, 99.4, 99.2, 88.8, 2.3}
    bubbleSortByInterface(sequence)
    // [1.1 2.3 12.12 88.8 99.2 99.4]
}

泛型版本

接下来就是Go Generic的使用介绍了，Go支持泛型函数和泛型类型，首先我们看一下泛型函数，下面是一个标准的泛型函数标准模板：

// GenericFunc 一个标准的泛型函数模板
func GenericFunc[T any](args T) {
	  // logic code
}

函数签名里面多了[T any]部分，这就是Go泛型的参数列表，其中T就是参数，any为参数的约束。

跑起来这个泛型函数，可以正常运行，但是别急，我们写一个泛型加法函数试试：

这是为什么呢？可以看到提示说：Invalid operation: a + b (the operator + is not defined on []T)，这是因为我们的泛型声明T的类型约束在下面的逻辑代码里面进行数值运算符操作，如果大家写过Java里面的泛型都知道如果做数值比较操作，那我们的泛型类型参数还要写成<T extends Comparable>才能正常工作，这就是对不能进行数值运算符操作的类型进行规避操作，同理Go里面也是一样的。

为此Go语言在泛型中引入一个叫类型集合概念，下面我们改造一下代码：

type MyInt int8

// 注意看~int8
func add[T int64 | float64 | ~int8](a, b T) T {
	  return a + b
}

func main() {
    // 限制底层数据类型
    fmt.Println("MyInt 1 + 2 = ",add[MyInt](1,2))
}

可以看到上面可以正常运行得到正确的结果，但是有一个问题如果我们是通过内置的数据取一个类型别名怎么办？也就是以前我通过type xx int8这样的代码，泛型该如何限制呢？官方泛型里面映入一个~内置符号，这个符号会限制泛型参数底层是基于某种类型实现的变体或者别名，例如下面我这段代码：

func bubbleSortByGeneric[T int64 | float64](sequence []T) {
    for i := 0; i < len(sequence)-1; i++ {
        for j := 0; j < len(sequence)-1-i; j++ {
            if sequence[j] > sequence[j+1] {
                sequence[j], sequence[j+1] = sequence[j+1], sequence[j]
            }
        }
    }
}

好了，通过上面一通操作，就知道了Go泛型怎么玩了，下面我把刚刚最开始那个排序算法通过泛型改写一下如下：
 

func bubbleSortByGeneric[T int64 | float64](sequence []T) {
    for i := 0; i < len(sequence)-1; i++ {
        for j := 0; j < len(sequence)-1-i; j++ {
            if sequence[j] > sequence[j+1] {
                sequence[j], sequence[j+1] = sequence[j+1], sequence[j]
            }
        }
    }
}

其实这个排序算法已经改写成了泛型版本，并且约束了参数的数据类型也可以认为类型的行为特征约束：

func main() {
    var sequence1 = []int64{100, 23, 14, 66, 78, 12, 8}
    bubbleSortByGeneric(sequence1)
    fmt.Println(sequence1)
    var sequence2 = []float64{120.13, 2.3, 112.3, 66.5, 78.12, 1.2, 8}
    bubbleSortByGeneric(sequence2)
    fmt.Println(sequence2)
}

结果为下图：

上面编写的泛型示例都是基于泛型函数进行的，但是我们有时候编程需要定义一些复合数据类型的数据结构，例如一个stack结构就是内部的value值类型不一样，如下的代码：

type Element interface {
	  int64 | float64 | string
}

type Stack[V Element] struct {
    size  int
    value []V
}

上面的代码我们就通过泛型编程定义一个value类型只能为Element类型集合的Stack结构，Stack[V Element]的中括号里面的就是泛型约束条件。

接着给Stack添加行为方法，方法签名上的s *Stack[V]就代表是一个泛型的Stack结构。

func (s *Stack[V]) Push(v V) {
    s.value = append(s.value, v)
    s.size++
}

func (s *Stack[V]) Pop() V {
    e := s.value[s.size-1]
    if s.size != 0 {
        s.value = s.value[:s.size-1]
        s.size--
    }
    return e
}

使用就和函数泛型差不多，在中括号里面指定泛型类型：

func main() {

    // INT STACK
    strS := Stack[int64]{}
    strS.Push(1)
    strS.Push(2)
    strS.Push(3)
    fmt.Println(strS.Pop())
    fmt.Println(strS.Pop())
    fmt.Println(strS.Pop())

    // FLOAT STACK
    floatS := Stack[float64]{}
    floatS.Push(1.1)
    floatS.Push(2.2)
    floatS.Push(3.3)
    fmt.Println(floatS.Pop())
    fmt.Println(floatS.Pop())
    fmt.Println(floatS.Pop())

}

另外一种就是特殊比较约束，也就是上面我所的Java里面的<T extends Comparable>，比如有时候我们需要限制某个参数是否可以比较或者支持某特征某个行为，例如可比较comparable关键字：

func SumNumbers[K comparable, V Number](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

func whoisMin[T Number](a, b T) T {
    if a < b {
       return a
    }
    return b
}

func main() {
    // Initialize a map for the integer values
    ints := map[string]int64{
        "first":  34,
        "second": 12,
    }

    // Initialize a map for the float values
    floats := map[int8]float64{
        -128: 35.98,
        127:  26.99,
    }

    fmt.Printf("Generic Sums with Constraint: %v and %v\n",
        SumNumbers(ints),
        SumNumbers(floats))

    fmt.Println(whoisMin[int64](100, 1000))
}

上面的comparable关键字就可以限制map的Key的类型是否为可比较的，说到这里我估计过不了多久某些卷王肯定又要跑去分析一下comparable底层实现了，我其实挺反感这样的卷王的，我不知道某些没事做的就跑去分析一下底层代码实现卷王有什么优越感？？？除了面试八股一下，难到你要去实现GO编译器吗？

不用分析了，我顺带说一下，其实comparable底层实现也就是基于一个interface的，只是里面有一个行为方法而已，Go内置的可比较数据类型在更新之后会默认实现comparable，这个如果大家使用其他编程语言的泛型，想一想也就知道怎么实现了，当前一些开发集成环境还没有更好支持，可能格式化代码存在一些问题，不过可以忽略，泛型程序写起来还是挺流畅的，其实我感觉泛型参数指定的时候使用<T>比较好一点，用[T]这种在某种情况下给人一种从map里面运行函数调用一样，不过这个我猜测可能和底层实现有点关系，把生成的通用代码放到map里面，而泛型约束就是map的键.

本文章实例代码仓库:

• GitHub - auula/go_generic_code: Generic programming in Go.