Go1.18新特性之泛型使用三步曲(小结)

目录

• 01 Go中的泛型是什么
• 1.1 传统的函数编写方式
• 1.2 泛型函数编写方式
• 02 从泛型被加入之前说起
• 2.1 针对每一种类型编写一套重复的代码
• 2.2 使用空接口并通过类型断言来判定具体的类型
• 2.3 传递空接口并使用反射解析具体类型
• 2.4 通过自定义接口类型实现
• 03 深入理解泛型–泛型使用“三步曲”
• 3.1 第一步：类型参数化
• 3.2 第二步：给类型添加约束
• 3.3 第三步：类型参数实例化
• 04 泛型类型约束和普通接口的区别
• 总结

01 Go中的泛型是什么

众所周知，Go是一门静态类型的语言。静态类型也就意味着在使用Go语言编程时，所有的变量、函数参数都需要指定具体的类型，同时在编译阶段编译器也会对指定的数据类型进行校验。这也意味着一个函数的输入参数和返回参数都必须要和具体的类型强相关，不能被不同类型的数据结构所复用。

而泛型就是要解决代码复用和编译期间类型安全检查的问题而生的。这里给出我理解的泛型的定义：

泛型是静态语言中的一种编程方式。这种编程方式可以让算法不再依赖于某个具体的数据类型，而是通过将数据类型进行参数化，以达到算法可复用的目的。

下面，我们通过一个函数的传统编写方式和泛型编写方式先来体验一下。

1.1 传统的函数编写方式

例如，我们有一个函数Max，其功能是计算整型切片中的最大元素，则其传统的编写方式如下：

func Max(s []int) int {
	if len(s) == 0 {
		return 0
	}
	
	max := s[0]
	for _, v := range s[1:] {
		if v > max {
			max = v
		}
	}
	
	return max
}

m1 := Max([]int{4, -8, 15})

在该示例中，Max函数的输入参数和返回值类型已经被指定都是int类型，不能使用其他类型的切片（例如s []float）。如果想要获取float类型的切片中的最大元素，则需要再写一个函数：

func MaxFloat(s []float) float {
	//...
}

传统的编写方式的缺点就是需要针对每一种类型都要编写一个函数，除了函数的参数中的类型不一样，其他逻辑完全一样。

接下来我们看看使用泛型的写法。

1.2 泛型函数编写方式

为了能够使编写的程序更具有可复用性，通用编程（Generic programming）也应运而生。使用泛型，函数或类型可以基于类型参数进行定义，并在调用该函数时动态指定具体的类型对其进行实例化，以达到函数或类型可以基于一组定义好的类型都能使用的目的。我们通过泛型将上述Max函数进行改写：

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

func main() {
	m1 := Max[int]([]int{4, -8, 15})
	m2 := Max[float64]([]float64{4.1, -8.1, 15.1})
	
	fmt.Println(m1, m2)
}

// 定义泛型函数
func Max[T constraints.Ordered](s []T) T {
	var zero T
	if len(s) == 0 {
		return zero
	}
	var max T
	max = s[0]
	for _, v := range s[1:] {
		max = v
		if v > max {
			max = v
		}
	}
	
	return max
}

由以上示例可知，我们通过使用泛型改写了MaxNumber函数，在main函数中调用MaxNumber时，通过传入一个具体的类型就能复用MaxNumber的代码了。

好了，这里我们只是对泛型有了一个初探，至于泛型函数中的T和any等关键词暂时不用关系，在后面我们会详细讲解。

接下来我们从泛型被加入之前说起，从而更好的的理解泛型被加入的动机。

02 从泛型被加入之前说起

为了更好的理解为什么需要泛型，我们看看如果不使用泛型如何实现可复用的算法。还是以上面的返回切片中元素的最大值函数为例。

为了能够针对切片中不同的数据类型都可以复用，我们一般有以下几种方案：

• 针对每一种类型编写一套重复的代码
• 传递一个空接口interface{}，使用类型断言来判断是哪种数据类型
• 传递一个空接口interface{}，使用反射机制来判断是哪种数据类型
• 自定义接口类型，通过类型继承的方式实现具体逻辑

下面我们看上面每一种实现方法都有哪些缺点。

2.1 针对每一种类型编写一套重复的代码

这种方法我们在第一节中已经实现了。针对int切片和float切片各自实现一个函数，但在两个函数中只有切片的数据类型不同，其他逻辑都相同。

这种方法的主要缺点就是大量的重复代码。这两个函数中除了切片元素的数据类型不同之外，其他都一样。同时，大量重复的代码也降低了代码的可维护性。

2.2 使用空接口并通过类型断言来判定具体的类型

另外一种方法是函数接收一个空接口的参数。在函数内部使用类型断言和switch语句来选择是哪种具体的类型。最后将结果再包装到一个空接口中返回。如下：

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
        return nil, errors.New("no values given")
    }
	
    switch first := s[0].(type) {
        case int:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(int)
                if v > max {
                    max = v
                }
            }
            return max, nil
		
        case float64:
            max := first
            for _, rawV := range s[1:] {
                v := rawV.(float64)
                if v > max {
                    max = v
                }
            } 
            return max, nil
		
         default:
             return nil, fmt.Errorf("unsupported element type of given slice: %T", first)
    }
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

这种写法的主要有两个缺点。第一个缺点是在编译期间缺少类型安全检查。如果调用者传递了一个不支持的数据类型，该函数的实现应该是返回一个错误。第二个缺点是这种实现的可用性也不是很好。因为无论是调用者处理返回值还是在函数内部的实现代码都需要将具体的类型包装在一个空接口中，并使用类型断言来判断接口里的具体的类型。

2.3 传递空接口并使用反射解析具体类型

在从空接口中解析具体的类型时，我们还可以通过反射替代类型断言。如下实现：

func Max(s []interface{}) (interface{}, error) {
    if len(s) == 0 {
	return nil, errors.New("no values given")
    }
	
    first := reflect.ValueOf(s[0])
	
    if first.Type().Name() == "int"  {
        max := first.Int()
        for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "int" {
                intV := v.Int()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }
	
    if first.Type().Name() == "float64" {
        max := first.Float()
	for _, ifV := range s[1:] {
            v := reflect.ValueOf(ifV)
            if v.Type().Name() == "float64" {
                intV := v.Float()
		if intV > max {
                    max = intV
		}
            }
	}
	return max, nil
    }
	
    return nil, fmt.Errorf("unsupported element type of given slice: %T", s[0])
}

// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})

在这种方法中，在编译期间不仅没有类型的安全检查，同时可读性也差。而且在使用反射时，性能通常也会比较差。

2.4 通过自定义接口类型实现

另外一种方法，我们可以通过给函数传递一个具体的，预定义好的接口来实现。该接口应该包含该函数要实现的功能的必备方法。只要实现了该接口的类型，该方法就都可以支持。我们还是以上面的MaxNumber函数为例，应该有获取元素个数的方法Len，比较大小的方法Less以及获取元素的方法Elem。我们来看看具体的实现：

type ComparableSlice interface {
    // 返回切片的元素个数.
    Len() int
    // 比较索引i的元素值是否比索引j的元素值要小
    Less(i, j int) bool
    // 返回索引i位置的元素
    Elem(i int) interface{}
}

func Max(s ComparableSlice) (interface{}, error) {
    if s.Len() == 0 {
        return nil, errors.New("no values given")
    }
	
    max := s.Elem(0)
    for i := 1; i < s.Len(); i++ {
        if s.Less(i-1, i) {
            max = s.Elem(i)
        }
    }
	
    return max, nil
}

type ComparableIntSlice []int

func (s ComparableIntSlice) Len() int { return len(s) }
func (s ComparableIntSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableIntSlice) Elem(i int) interface{} { return s[i] }

type ComparableFloat64Slice []float64

func (s ComparableFloat64Slice) Len() int { return len(s) }
func (s ComparableFloat64Slice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableFloat64Slice) Elem(i int) interface{} {return s[i]}

// Usage
m1, err1 := Max(ComparableIntSlice([]int{4, -8, 15}))
m2, err2 := Max(ComparableFloat64Slice([]float64{4.1, -8.1, 15.1}))

在该实现中，我们定义了一个ComparableSlice接口，其中ComparableIntSlice和ComparableFloat64Slice两个具体的类型都实现了该接口，分别对应int类型切片和float64类型切片。

该实现的一个明显的缺点是难以使用。因为调用者必须将数据封装到一个自定义的类型中（在该示例中是ComparableIntSlice和ComparableFloat64Slice），并且该自定义类型要实现已定义的接口ComparableSlice。

由以上示例可知，在有泛型功能之前，要想在Go中实现处理多种类型的可复用的函数，都会带来一些问题。而泛型机制正是避免上述各种问题的解决方法。

03 深入理解泛型–泛型使用“三步曲”

在文章第一节处我们已经提到过泛型要解决的问题–程序针对一组类型可进行复用。下面我们给出泛型函数的一般形式，如下图：

由上图的泛型函数的一般定义形式可知，使用泛型可以分三步，我将其称之为“泛型使用三步曲”。

3.1 第一步：类型参数化

在定义泛型函数时，使用中括号给出类型参数类型，并在函数所接收的参数中使用该类型参数，而非具体类型，就是所谓的类型参数化。还是以上面的泛型函数为例：

func Max[T constraints.Ordered](s []T) T {
    var zero T
    if len(s) == 0 {
	return zero
    }
    
    var max T
    max = s[0]
    for _, v := range s[1:] {
	max = v
	if v > max {
            max = v
	}
    }
	
    return max
}

其中T被称为类型参数，即不再是一个具体的类型值，而是需要在调用该函数时再动态的传入一个类型值（例如int，float64），以实例化化T。例如：Max[int](s[]int{4,-8,15})，那么T就代表的是int。

当然，类型参数列表中可以有多个类型参数，多个类型参数之间用逗号隔开即可。类型参数名也不一定非要用T，任何符合变量规则的名称都可以。

3.2 第二步：给类型添加约束

在上图中，any被称为是类型约束，用来描述传给T的类型值应该满足什么样的条件，不满足约束的类型传给T时会被报编译错误，这样就实现了类型的安全机制。当然类型约束不仅仅像any这么简单。

在Go中类型约束分两类，分别是Go官方支持的内建类型约束（包括内建的类型约束any、comparable和在golang.org/x/exp/constraints 包中定义的类型约束）和自定义类型约束。因为在Go中泛型的约束是通过接口来实现的，所以我们可以通过定义接口来自定义类型约束。

3.2.1 Go官方支持的内建类型约束

其中Go内建的类型约束和constraints包定义的类型约束我们统一成为Go官方定义的类型约束。之所以是在golang.org/x/exp/constraints包中，是因为该约束带有实验性质。

下面我们列出了Go官方支持的预定义的类型约束：

在上表中，我们看到的符号~。~T意思是说底层类型是T的类型。例如~int代表的是底层类型是int的类型。这个我们在下一节自定义类型约束一节有详细介绍和示例。

3.2.2 自定义类型约束

由上面可知，类型的约束本质上是一个接口。所以，如果官方提供的类型约束不满足自己的业务场景下，可以按照Go中泛型的语法规则自定义类型约束即可。类型约束的定义一般有两种形式：

• 定义成接口形式
• 直接定义在类型参数列表中

下面我们分别来看下各自的使用方法。

• 定义成接口形式

下面是定义成接口形式的类型约束示例：

// 自定义类型约束接口StringableFloat
type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}

// MyFloat 是满足StringableFloat类型约束的float类型。
type MyFloat float64 

// 实现类型约束中的String方法
func (m MyFloat) String() string {
    return fmt.Sprintf("%e", m)
}

//泛型函数，对类型参数T使用了StringableFloat约束
func StringifyFloat[T StringableFloat](f T) string {
    return f.String()
}
// Usage
var f MyFloat = 48151623.42

//使用MyFloat类型对T进行实例化
s := StringifyFloat[MyFloat](f)

在该示例中，函数StringifyFloat是一个泛型函数，并使用StringableFloat接口来对T进行约束。MyFloat类型是一个满足StringableFloat约束的具体类型。

在泛型中，类型约束被定义成了接口，该接口中可以包含具体类型的集合和方法。在该示例中，StringfyFloat类型约束包含float32和float64两个类型以及一个String()方法。该约束允许任何满足该接口的具体类型都可以实例化参数T。

在上述示例中，我们还看到一个新的关键符号：~。~T代表所有的类型的底层类型必须是类型T。在这里类型MyFloat是一个自定义的类型，但其底层类型或叫做基础类型是float64。因此，MyFloat是满足StringifyFloat约束的。

另外，在定义类型约束接口中，也可以引入类型参数。如下示例中，在类型约束SliceConstraints中的切片类型引入了类型参数E，这样该约束就可以对任意类型的切片进行约束了。

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    r1 := FirstElem1[[]string, string]([]string{"Go", "rocks"})
    r2 := FirstElem1[[]int, int]([]int{1, 2})

    fmt.Println(r1, r2)
}

// 定义类型约束，并引入类型参数E
type SliceConstraint[E any] interface {
    ~[]E
}

// 泛型函数
func FirstElem1[S SliceConstraint[E], E any](s S) E {
	return s[0]
}

• 在类型参数列表中直接定义约束

下面的示例中，FirstElem2、FirstElem3泛型函数将类型约束直接定义在了类型参数列表中，我把它称之为匿名类型约束接口，类似于匿名函数。如下示例代码，三个泛型函数是等价的：

package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

func main() {
    s := []string{"Go", "rocks"}
    r1 := FirstElem1[[]string, string](s)
    r2 := FirstElem2[[]string, string](s)
    r3 := FirstElem3[[]string, string](s)

    fmt.Println(r1, r2, r3)
}

type SliceConstraint[E any] interface {
    ~[]E
}

func FirstElem1[S SliceConstraint[E], E any](s S) E {
    return s[0]
}

func FirstElem2[S interface{ ~[]E }, E any](s S) E {
    return s[0]
}

func FirstElem3[S ~[]E, E any](s S) E {
    return s[0]
}

3.3 第三步：类型参数实例化

在调用泛型函数时，需要给函数的类型参数指定具体的类型，叫做类型实例化。在类型实例化过程中有时候是不需要指定的具体的类型，这时在编译阶段，编译器会根据函数的参数自动推导出来T的实际参数值。如下：

类型参数实例化就比较简单了，就是在调用泛型函数时要给泛型函数的类型参数传递一个具体的类型。就像第一步中调用Max函数时指定的一样：r2 := Max[int]([]int{4, 8, 15})，这里Max后面中括号中的int就是类型实参，这样Max函数就能知道处理的切片元素的具体类型了。

这里还有一点需要注意，在类型参数实例化时，还有方式是不需要指定具体的类型，这时在编译阶段，编译器会根据函数的参数自动推导出来T的实际参数值： r3 := Max([]float64{4.1, -8.1, 15.1})。这里Max后面并没有给出中括号以及对应的具体类型，但Go编译器能根据切片元素类型自动推断出是float64类型。

04 泛型类型约束和普通接口的区别

首先二者都是接口，都可以定义方法。但类型约束接口中可以定义具体类型，例如上文中自定义的StringableFloat类型约束接口中的类型约束：~float32 | ~float64

type StringableFloat interface {
    ~float32 | ~float64 // 底层是float32或float64的类型就能满足该约束
    String() string
}

当接口中存在类型约束时，这时该接口就只能被用于泛型类型参数的约束。

总结

泛型在Go1.18中才被加入实际上是有其原因的。之前一直都有泛型的提案，但一直没被加入到该语言中，其中一个很重要的原因就是因为之前的泛型提案不够简单。而Go又是以简单著称的语言，所以只有泛型的实现方案足够简单，同时对Go之前的版本又兼容时才被加入进来。