编译器 - Tony Bai

标签编译器下的文章

Go 1.18中值得关注的几个变化

四月 20, 2022
2 条评论

本文永久链接 – https://tonybai.com/2022/04/20/some-changes-in-go-1-18

从3月23日开始，我居家办公了20+天。这期间我本来是应该有时间写下这篇综述类文章的，但是封了两天后，抢菜、带娃的事情就开始困扰着我。我实在没有下笔写下这篇文章的心思。4月13日终于解封了，上班后的气象就是不一样，人也精神了很多，于是这篇文章也被提上了日程。希望新冠疫情早日结束吧，希望每个人都能在晴朗的户外享受那春日的暖意。

2022年3月15日，Go团队在官方博客上官宣了Go 1.18正式版的发布。Go 1.18这个网红版本终于落地了。泛型的加入让Go 1.18成为继Go 1.0(首个正式版)、Go 1.5(实现自举、去C代码、新版GC)、Go 1.11(引入Go module)版本之后的又一里程碑版本。

泛型是Go语言开源以来最大的语法特性变化，其改动和影响都很大，Go核心团队尽管很努力了，但Go 1.18正式版本的发布时间还是延迟了一个月。不过好消息是加入泛型语法的Go 1.18继续保持了Go1兼容性，这本身就是Go团队的胜利，同样也是Go社区的幸运。

相较于之前的版本，Go 1.18版本改动很大，bug略多。好在发布一个月后，各种喧嚣都归于安静。笔者写稿时，Go 1.18.1已经发布，修正了许多问题，当然也包括一些与Go泛型有关的问题。

下面我们就来看看Go 1.18版本中值得关注的变化，我这里使用的版本为Go 1.18.1。

我们就先从泛型说起。

一. Go语法变化

1. 泛型：史上最复杂Go语法特性

以往Go发布大版本，Go语法变化一栏的内容总是寥寥无几，甚至是因没有变化而一笔带过。

更有甚者，从Go1.0到Go 1.17的语法变化屈指可数：

Go 1.1版本：增加“method value”语法；
Go 1.2版本：增加Full slice expression：a[low: high: max]；
Go 1.4版本：新增for range x {…}形式的for-range语法；
Go 1.5版本：支持省略map类型字面量（literal）中的key的类型；
Go 1.9版本：新增了type alias语法；
Go 1.13版本：增加以0b或0B开头的二进制数字字面量、以“0o”或“0O”开头的八进制数字字面量、以0x或0X开头是的十六进制形式的浮点数字面量以及支持在数字字面量中通过数字分隔符“_”提高可读性；
Go 1.17版本：支持从切片到数组指针的转换。

我们看到，十年来，Go在纯语法层面的变化只有上面这么几个。而Go 1.18引入的泛型的复杂性足以超过上述版本的语法变化之和。面对新增加的泛型特性，即便是有着多年Go编程经验的Gopher，也会有一种“二次学艺”的感觉。这是因为Go泛型是Go诞生以来最复杂、最难读和理解的语法特性，当然泛型的复杂性不仅仅对Go语言生效，对其他具有泛型语法特性的编程语言来说，泛型也都是最复杂的语法。有志者可以去挑战一下C++的泛型：template。还有那本尤为烧脑的Andrei Alexandrescu 的《C++设计新思维: 泛型编程与设计模式之应用》，英文书名是《Modern C++ Design: Generic Programming and Design Patterns Applied》。

同样也是因为泛型的复杂性，Go团队在Go 1.18的发布说明文档中保留了在将来的版本中因修复Go泛型bug而对Go 1.18版本编译的程序带来破坏的权力。当然Go团队也承诺将尽可能地减少任何此类破坏，但不能保证此类破坏为零。

另外，Go 1.18的泛型实现并非完全版，有很多使用上的约束。这些约束很大可能将在后续的Go版本中逐步取消掉。并且Go 1.18中的实现与Type Parameter Proposal的design文档有一定差异，Go官方建议以Go语言的规范为准。

2. 泛型的主要语法点

前面也说了，Go泛型是Go开源以来在语法层面最大的一次变动，Go泛型的最后一版技术提案长达数十页，我们要是把其中的细节都展开细讲，那都可以自成一本小册子了。在这篇综述类文章中，我仅对Go泛型的主要语法点做简要说明。在日后文章中，我们再深入到泛型的语法细节，做逐一细致剖析。

关于Go泛型的主要语法点，其实在Go官博的“Go泛型介绍”中都有提及：

泛型在Go语言中增加了三个新的重要内容：

函数和类型新增对类型形参(type parameters)的支持。
将接口类型定义为类型集合，包括没有方法的接口类型。
支持类型推导，大多数情况下，调用泛型函数时可省略类型实参(type arguments)。

下面我们分别来看看。

类型形参(type parameter)

类型形参是在函数声明、方法声明的receiver部分或类型定义的类型参数列表中，声明的（非限定）类型名称。类型参数在声明中充当了一个未知类型的占位符（placeholder），在泛型函数或泛型类型实例化时，类型形参会被一个类型实参(type argument)替换。

为了让你更好地理解类型参数究竟如何声明，它又起到了什么作用，我们以函数为例，对普通函数的参数与泛型函数的类型参数作一下对比：

我们知道，普通函数的参数列表是这样的：

func Foo(x, y aType, z anotherType)

这里，x, y, z是形参（parameter）的名字，也就是变量，而aType，anotherType是形参的类型，也就是类型。

我们再来看一下泛型函数的类型参数（type parameter）列表：

func GenericFoo[P aConstraint, Q anotherConstraint](x,y P, z Q)

这里，P，Q是类型形参的名字，也就是类型，aConstraint，anotherConstraint代表类型参数的约束（constraint），我们可以理解为对类型参数可选值的一种限定。

在类型参数列表中修饰类型参数的就是约束（constraint）。那什么是约束呢？我们继续往下看。

约束（constraint）

约束（constraint）规定了一个类型实参（type argument）必须满足的条件要求。如果某个类型满足了某个约束规定的所有条件要求，那么它就是这个约束修饰的类型形参的一个合法的类型实参。

在Go泛型中，我们使用interface类型来定义约束。为此，Go接口类型的定义也进行了扩展，我们既可以声明接口的方法集合，也可以声明可用作类型实参的类型列表。

下面是一个约束定义与使用的示例：

type C1 interface {
    ~int | ~int32
    M1()
}

type T struct{}
func (T) M1() {
}

type T1 int
func (T1) M1() {
}

func foo[P C1](t P)() {
}

func main() {
    var t1 T1
    foo(t1)
    var t T
    foo(t) // 编译器报错：T does not implement C1
}

在这段代码中，C1是我们定义的约束，它声明了一个方法M1，以及两个可用作类型实参的类型(~int | ~int32)。我们看到，类型列表中的多个类型实参类型用“|”分隔。

在这段代码中，我们还定义了两个自定义类型T和T1，两个类型都实现了M1方法，但T类型的底层类型为struct{}，而T1类型的底层类型为int，这样就导致了虽然T类型满足了约束C1的方法集合，但类型T因为底层类型并不是int或int32而不满足约束C1，这也就会导致foo(t)调用在编译阶段报错。不过，我这里还要建议你：做约束的接口类型与做传统接口的接口类型最好要分开定义，除非约束类型真的既需要方法集合，也需要类型列表。

为了让大家更好理解这种对接口类型的扩展，Go引入了类型集合(type set)来解释这一切。“Go泛型介绍”中有对type set的图解，这里就不赘述了，大家可以点击链接移步阅读。

类型具化(instantiation)与类型推导(type inference)

像上面例子中main函数对foo(t1)的调用就利用到了类型具化和类型推导两个特性。

foo是一个泛型函数，它的函数声明中带有一个由C1约束的类型形参P，而用类型实参T1初始化P的过程就是类型具化。不过大家也注意到了，我们没有使用：foo[T1](t1)，而是省略了显式对P进行初始化，直接使用了foo(t1)，这就是Go类型推导带来的便利。Go编译器会根据传入的实参的类型，进行类型实参(type argument)的自动推导。自动类型推导使得人们在编写调用泛型函数的代码时可以使用一种更为自然的风格。

泛型类型(generic type)

除了函数可以携带类型参数变身为“泛型函数”外，类型也可以拥有类型形参而化身为“泛型类型”，比如下面代码就定义了一个向量泛型类型：

type Vector[T any] []T

这是一个带有类型参数的类型定义，类型参数位于类型名的后面，同样用方括号括起。在类型定义体中可以引用类型参数列表中的参数名（比如T）。类型参数同样拥有自己的约束，如上面代码中的any。

在Go 1.18中，any是interface{}的别名，也是一个预定义标识符，使用any作为类型参数的约束，代表没有任何约束。关于如何使用any以及使用any的注意事项，请移步到我之前的文章《切换到Go 1.18后的第一件事：将interface{}全部替换为any》。

下面是另一个泛型类型的定义：

type Tree[T interface{}] struct {
    left, right *Tree[T]
    value       T
}

func (t *Tree[T]) Lookup(x T) *Tree[T] { ... }

var stringTree Tree[string]

在上面这个例子中，泛型类型Tree存储了类型参数T的值。泛型类型也可以有方法，比如本例中的Lookup。为了使用一个泛型类型，它必须被实例化，比如：Tree[string]是一个用类型实参string来实例化Tree的例子。

当前泛型实现的不足

泛型对Go项目的影响是方方面面的，在一个版本迭代周期内将泛型的全部特性都实现的确难了一些。因此，Go 1.18当前的Go泛型实现尚不完整，尚有限制，根据Go 1.18的发布说明文档，限制包括下面几点：

Go编译器不能处理泛型函数或方法中的类型声明，Go团队希望在未来的版本中提供对该功能的支持。

func GenericsFoo[T any](s T) T {
    type bar int // type declarations inside generic functions are not currently supported
    var a bar
    println(a)
    return s
}

Go编译器不支持预定义的函数real、imag和complex处理泛型类型实参。Go团队希望在未来的版本中取消这一限制。

package main

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

func GenericsFoo[T constraints.Complex](s T) T {
    n := real(s) // s (variable of type T constrained by constraints.Complex) not supported as argument to real for go1.18 (see issue #50937
    println(n)

    i := complex(s, s) // invalid argument: arguments have type T, expected floating-point
    _ = i
    return s
}

func main() {
    var i = complex(1.0, 2.0) // 1+2i
    GenericsFoo(i)
}

Go编译器只支持在参数类型为P的值x上调用方法m，前提是：m必须是由P的约束接口显式声明的。同样地，method valuex.m和method expression P.m也只有在P明确声明了m的情况下才会被支持。即使P类型集合中的所有类型都实现了m，但如果没有显示声明m，那么也不支持在x上调用m。Go团队希望在未来的版本中删除这一限制。

package main

type C interface {
    T | T1 // T和T1都实现了M1方法
}

func GenericsFoo[P C](p P) {
    p.M1() // p.M1 undefined (type P has no field or method M1)
}

type T struct{}

func (T) M1() {}

type T1 struct{}

func (T1) M1() {}

func main() {
    GenericsFoo(T{})
}

Go编译器目前不支持访问一个结构字段x.f，其中x是类型参数类型，即使类型参数的类型集合中的所有类型都有一个字段f。Go团队可能会在未来的版本中取消这一限制。

package main

type C interface {
    T | T1 // T和T1的类型定义中都包含名为Name的字段
}

func GenericsFoo[P C](p P) {
    _ = p.Name // p.Name undefined (type P has no field or method Name)
}

type T struct {
    Name string
}

type T1 struct {
    Name string
}

func main() {
    GenericsFoo(T{})
}

目前Go编译器不允许将类型参数或指向类型参数的指针作为结构体类型嵌入字段(未命名字段)。同样，也不允许在一个接口类型中嵌入一个类型参数。目前Go团队还不确定这些限制在未来版本是否会被放开。

package main

type F[T any, P any] struct {
    Name string
    *T //embedded field type cannot be a (pointer to a) type parameter
    P // embedded field type cannot be a (pointer to a) type parameter
}

type MyInterface interface{}

type GenericsInterface[I MyInterface] interface {
    M1()
    I // cannot embed a type parameter
}

func main() {
    var f F[string, string]
    _ = f
}

Go编译器不支持在包含1个以上类型元素的union类型定义中包含一个具有非空方法集的接口类型。这是否会在未来版本中被允许，Go团队目前还不确定。

package main

type MyInterface interface {
    M1()
}

type GenericsInterface interface {
    ~int | MyInterface | float64 // cannot use main.MyInterface in union (main.MyInterface contains methods)
}

func main() {
}

另外一个大家广为关注的是，普通类型的方法声明中不支持类型参数：

package main

type F struct{}

func (F) M1[T any](t T){} // syntax error: method must have no type parameters

func main() {
    var f F[string]
    f.M1("hello")
}

不过这不是实现层面的限制，而是Go泛型技术草案就是这么定的。至于后续是否能支持在方法中使用类型参数还不确定。不过上述问题可以通过带有类型参数的泛型类型来“缓解”。

泛型类型可以有自己的方法，在泛型类型的方法声明中receiver中使用与类型声明相同的类型参数，这个类型参数也可以在方法的普通参数列表中使用，如下面例子：

package main

type F[T any] struct{}

func (F[T]) M1(t T) {} // ok

func main() {
    var f F[string]
    f.M1("hello")
}

官方维护的泛型包

Go 1.18可以说仅提供了一个Go泛型的最小版本，除了语法，外加两个预定义类型：comparable和any。原本想在标准库中加入的constraints、slices和maps泛型包，因Go老父亲Rob Pike的一条comment而被暂时搁置了。Rob Pike的理由很简单，Go泛型是Go诞生以来最大的一次语言变化，Go 1.18版本承载了太多的change，容易出错。并且Go核心开发团队也没有使用新泛型的经验，他建议Go核心开发团队应该多等待、观察和学习，不要把步子迈得太大，Go应该按照自己的节奏稳步前进。

于是前面提到的三个包被放在了golang.org/x/exp下面了：

golang.org/x/exp/constraints
golang.org/x/exp/slices
golang.org/x/exp/maps

待时机成熟，这些包会像当年http2包一样进入到Go标准库中。

Go工具链对泛型语法的支持情况

Go泛型出炉后，Go官方维护的Go工具链上的工具都基本确定了支持泛型语法的计划。到Go 1.18发布时，gofmt/goimports、go vet、gopls(从v0.8.1版本开始支持)都实现了对泛型的支持。

不过这里除了gofmt是与Go安装包一起发布的，其他工具都需要自己安装和升级到最新版本。否则一旦使用到泛型语法或新增的像any、comparable等预定义标识符，你的编辑器就会给出各种错误提示。

如果你和我一样使用vim+vim-go+goimports+gopls，那么要想编辑器支持go 1.18，可使用下面命令升级工具版本来支持go 1.18的泛型：

$go install golang.org/x/tools/cmd/goimports@latest
$go install golang.org/x/tools/gopls@latest

当然Go社区还有很多工具尚未及时赶上步伐，这个要给Go社区一定的时间。

关于Go泛型语法的细节以及实现原理，我会逐渐在后续文章中进行专门讲解。

讲完泛型这个大部头儿后，接下来，我们再来看看Go编译器与Go module的变化。

二. Go编译器与Go module变化

1. 修正的语法bug

我们知道在Go函数内声明变量后，如果未使用，Go编译器会报错。但Go 1.18版本之前，Go编译器对于下面例子中的变量p是不会报错的，即便在main中没有使用。

Go 1.18修正了这个问题，如果用Go 1.18编译该例子，会出现注释中的编译器错误。

package main

func main() {
    p := true // go 1.18会报错：p declared but not used，但Go 1.18之前的版本不会。
    func() {
        p = true
    }()
}

同时，gopls和go vet也都会针对上述问题给出错误提示。

2. 在AMD64平台上引入architectural level

众所周知，Go语言在目标代码的优化上还有很大的提升空间。在Go 1.18版本中，Go引入一个算是优化的措施，即在AMD64平台上引入architectural level的概念。level越高，可用指令越新，编译出的使用新指令的代码的性能可能有一定提升。

Go 1.18通过GOAMD64这个环境变量来指示编译器采用的level，默认使用v1版本。这个版本在生产的代码中使用了所有x86-64 cpu都支持的指令。说白了，就是使用最基本的指令，兼容性好，但性能也是最差的。

GOAMD64环境变量的另外三个候选值为v2、v3、v4。版本越高，兼容性越差，但性能可能因使用新指令而得到提升。

GOAMD64=v2: 所有v1版指令, 外加CMPXCHG16B, LAHF, SAHF, POPCNT, SSE3, SSE4.1, SSE4.2, SSSE3；
GOAMD64=v3: 所有v2版指令, 外加AVX, AVX2, BMI1, BMI2, F16C, FMA, LZCNT, MOVBE, OSXSAVE；
GOAMD64=v4: 所有v3版指令, 外加AVX512F, AVX512BW, AVX512CD, AVX512DQ, AVX512VL。

在优化的道路，Go团队一直在努力，这不Go编译器现在还可以inline带有range循环或带有label的循环语句的函数了。

3. 丰富了SBOM信息

这些年来，关于软件供应链的安全问题频发，软件供应链已然成为IT安全领域的一个热点。Go作为云原生平台、中间件以及服务的头部开发语言，其自身安全性以及构建出的软件的安全性就变得至关重要了。Go在安全方面的投入也是逐渐增大，手段也在逐渐增多与丰富。SBOM(软件物料清单)作为缓解软件供应链攻击的重要防护手段，Go在1.13版本就提供了相关支持，在Go 1.18版本中，Go更是丰富了提供的SBOM信息，这方面的详情可参见之前的文章：《聊聊Go语言的软件供应链安全》。

4. Go泛型给compiler带来的负面影响

Go泛型的引入增加了Go语言的表达力，但也对Go编译器带来了不小的负面影响，其中最大的影响就是编译速度。从Go 1.18发布说明文档来看，Go 1.18的编译速度要比Go 1.17版本下降15%，并且即便你在代码中完全没有使用泛型语法，这个性能下降也是有的。所以这也是Go团队在Go 1.19中要重点解决的问题。

5. go module变化

从Go 1.16版本开始，Go module已进入成熟期。不过依然有一些小问题需要修复，其中一个就是go.mod和go.sum究竟哪个命令有权修改。Go 1.18明确了能修改go.mod, go.sum的命令只有三个：go get, go mod tidy和go mod download。这样开发人员就可以放心的在项目根目录下执行go工具链提供的其他命令了。

6. 引入Go workspace(工作区)

Go module的引入大大改善了Go包依赖与构建问题。但目前Go module在软件协作开发过程中仍存在导致体验差的两个问题，并且这两个问题在原有go module机制下面很难得到根本解决。这两个问题是：

对依赖包进行自行修改，并基于本地修改后的依赖包进行构建；
依赖本地尚未发布的module。

原有的go module replace机制在协作的情况下，体验较差，给开发人员带去一定额外的心智负担。于是Go开发者Michael Matloob在2021年4月提出的一个名为“Multi-Module Workspaces in cmd/go”的proposal。这个proposal引入一个go.work文件用于开启Go工作区模式。go.work通过use指示符设置一些本地路径，这些路径下的go module构成一个工作区(workspace)，Go命令可以操作这些路径下的go module，也会优先使用工作区中的go module。同时，go.work是本地环境相关的，无需提交到代码仓库中，每个开发者可以根据自己的开发环境设置拥有仅属于自己的go.work文件。

关于Go工作区机制，我在《Go 1.18新特性前瞻：Go工作区模式》一文中有详细介绍，大家可以移步到那篇文章认真阅读。不过那篇文章是在Go 1.18 beta1版发布之前写的，当时的一些go.work的内容，比如像directory指示符在Go 1.18正式版中已经发生了变化，这个大家要注意一下。

看完编译器，我们再来简单说说其他工具链。

三. Go工具链变化

1. go fuzzing

Go工具链侧最大的变化莫过于引入对fuzzing的原生支持。Fuzzing，又叫fuzz testing，中文叫做模糊测试或随机测试。其本质上是一种自动化测试技术，更具体一点，它是一种基于随机输入的自动化测试技术，常被用于发现处理用户输入的代码中存在的bug和问题。

在具体实现上，Fuzzing不需要像单元测试那样使用预先定义好的数据集作为程序输入，而是会通过数据构造引擎自行构造或基于开发人员提供的初始数据构造一些随机数据，并作为输入提供给我们的程序，然后监测程序是否出现panic、断言失败、无限循环等。这些构造出来的随机数据被称为语料(corpus)。另外Fuzz testing不是一次性执行的测试，如果不限制执行次数和执行时间，Fuzz testing会一直执行下去，因此它也是一种持续测试的技术。

Go 1.18将fuzz testing纳入了go test工具链，与单元测试、性能基准测试(https://www.imooc.com/read/87/article/2439)等一起成为了Go原生测试工具链中的重要成员。

go fuzzing test的测试用例与普通的测试用例(TestXxx)、性能基准测试(BenchmarkXxx)等一样放在xx_test.go中，只不过用例对应的函数名样式换为了FuzzXxx了。一个简单的Fuzzing test用例如下：

func FuzzXxx(f *testing.F) {
    // 设置种子语料(可选)

    // 执行Fuzzing
    f.Fuzz(func(t *testing.T, b []byte) {
        //... ...
    })
}

关于Go Fuzzing test，我在《Go 1.18新特性前瞻：原生支持Fuzzing测试》有十分全面系统的说明，大家可以移步到那篇文章阅读了解。

这里需要大家额外注意的是，Fuzzing测试虽然写法上与单元测试、benchmark test很像，也很简单，但Fuzzing测试是持续运行的，不会停下来的，因此就像Go 1.18版本说明中提示的那样：Fuzzing测试会消耗大量的内存，在运行时可能会影响你的机器性能。还要注意的是，在运行时，模糊引擎会将扩大测试范围的数值写入\$GOCACHE/fuzz内的模糊缓存目录。目前对写入模糊缓存的文件数量或总字节数没有限制，所以它可能会占用大量的存储空间（可能是几个GB甚至更多）。因此建议找一台专门的高配机器来跑fuzzing test。

2. go get

在Go module构建模式下，go get回归本职工作，专注于获取go module以及对应的依赖module。不再执行编译和安装工作。这样一来，原本被go get剥夺了光环的go install在module-aware模式下重新拿回本属于自己的职能：安装指定版本或latest版本的module和可执行文件。

最后，我们再来看看其他的一些小变化。

四. 其他的minor变化

1. gofmt支持并发

“gofmt的代码风格不是某个人的最爱，而是所有人的最爱”。gofmt代码风格已经成为Go开发者的一种共识，融入到Go语言的开发文化当中了。Go 1.18为Go开发人员带来了支持并发的gofmt，毫无疑问，其最大的好处就是快，尤其是在多核cpu上，gofmt可以利用更多的算力快速完成代码风格的格式化。

2. 内置函数append对切片的扩容算法发生变化

我们都知道append操作切片时，一旦切片已满(len==cap)，append就会重新分配一块更大的底层数组，然后将当前切片元素copy到新底层数组中。通常在size较小的情况下，append都会按2倍cap扩容，size大的情况，比如已经是1024了，那么Go 1.17不会double分配。Go 1.18中的算法有一定变化，目的是使得在一个门槛值前后的变化更丝滑。具体算法大家看下面\$GOROOT/src/runtime/slice.go中的growslice函数中的部分逻辑：

func growslice(et *_type, old slice, cap int) slice {
    ... ...

    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        const threshold = 256
        if old.cap < threshold {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                // Transition from growing 2x for small slices
                // to growing 1.25x for large slices. This formula
                // gives a smooth-ish transition between the two.
                newcap += (newcap + 3*threshold) / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }
    ... ...
}

另外从代码来看，和Go 1.17以1024作为大小分界不同，Go 1.18使用256作为threshold。这个大家要注意。

3. 新增net/netip包

Go 1.18标准库在net下面新增加了netip包。这源于原Go核心开发者Brad Fitzpatrick在其创业项目tailscale中遇到的问题。Brad发现标准库中现有的表示IP相关信息的net.IP有如下这么多不足：

于是Brad提议新增一个占用较少的内存、不可变的并且是可比较的、可作为map key的IP的新表示，这就是netip.Addr以及围绕netip.Addr的一系列类型与方法。

关于netip包的内容还不少，大家可以查看netip包的ref来详细了解这个包。

4. 两个重要的安全变化

安全问题日益严重，Go标准库也在紧跟安全趋势的步伐。

在Go 1.18中，tls client默认将使用TLS 1.2版本。当然如果你要显式将Config.MinVersion设置为VersionTLS10，TLS 1.0和1.1依然可以使用。

此外，Go 1.18中crypto/x509包默认将拒绝使用SHA-1哈希函数签名的证书(自签发的除外)。通过GODEBUG=x509sha1=1可以临时支持SHA-1，但从Go 1.19版本开始，SHA-1将被永久踢出。

5. strings包和bytes包新增Cut函数

strings包和bytes包都增加了实用函数Cut(注：strings和bytes包保持API一致性的传统由来已久)。以字符串为例，Cut函数的语义就是将一个输入字符串中的某一段字符串“切掉”。Cut函数的原型如下：

func Cut(s, sep string) (before, after string, found bool)

如果没找到要切掉的部分，则最后的返回值为false，before为原字符串s，而after则为”"。

var s = "hello, golang"

b, a, f := strings.Cut(s, "java")
fmt.Printf("before=%s, after=%s, found=%t\n", b, a, f) // before=hello, golang, after=, found=false

如果找到了要切掉的部分，则最后的返回值为true，before为“被切掉部分”的前面的字符串，after则为“被切掉部分”的后面的字符串。

b, a, f = strings.Cut(s, "lang")
fmt.Printf("before=%s, after=%s, found=%t\n", b, a, f) // before=hello, go, after=, found=true

如果输入字符串中有多个与要切掉的部分匹配的字串，Cut函数只会切掉第一个匹配的字串。

b, a, f = strings.Cut(s, "o")
fmt.Printf("before=%s, after=%s, found=%t\n", b, a, f) // before=hell, after=, golang, found=true

6. runtime/pprof精确性提升

Go 1.18 runtime/pprof在Linux上采用每线程定时器来驱动采样，目的就是提升在高负荷下采样数据的精确性，减少数据丢失或不准的情况。

7. sync包新增Mutex.TryLock, RWMutex.TryLock和RWMutex.TryRLock

Go团队在社区的强烈要求下，还是在sync包中加上了Mutex.TryLock, RWMutex.TryLock和RWMutex.TryRLock。但说实话，我个人尚未遇到非要使用TryLock的场景。Go团队在TryLock方法的注释中也给出了使用提示：请注意，虽然TryLock的正确使用确实存在，但它们是罕见的，而且使用TryLock的使用往往是mutex在特定使用中更深层次问题的标志。

尽量不要用就完了！

五. 小结

从上面内容来看，Go 1.18还真是一个大改动的版本。很多变化都值得后续细致学习和探索。Go 1.18由于引入泛型，我个人还是建议暂缓将其用于生产环境。就像go module引入后，经历go 1.11~go 1.16才逐渐成熟，Go泛型的成熟想必也要至少2-3个版本。在这个阶段，先把精力放在对泛型的学习上以及如何利用泛型改善我们的代码上，但也要注意：泛型大幅提高了代码的复杂性，使用泛型的代码在可读性方面必然有下降，大家不要滥用泛型，更不要显然像c++ template使用的那种奇技淫巧中去。那就与Go语言的设计哲学背道而驰了。

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！2022年，Gopher部落全面改版，将持续分享Go语言与Go应用领域的知识、技巧与实践，并增加诸多互动形式。欢迎大家加入！

img{512x368}

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展；短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

微博：https://weibo.com/bigwhite20xx
微信公众号：iamtonybai
博客：tonybai.com
github: https://github.com/bigwhite
“Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go泛型介绍[译]

三月 25, 2022
1 条评论

本文永久链接 – https://tonybai.com/2022/03/25/intro-generics

Go核心团队在官博上发布了一篇名为《An Introduction To Generics》的文章，该文章基于Robert Griesemer和Ian Lance Taylor在2021年GopherCon大会上的演讲，这是Go团队发布Go 1.18版本后官博发表的首篇有关Go泛型的文章，值得大家认真阅读，这里将全文做一下翻译，供大家参考。

简介

这篇博文是基于我们在2021年GopherCon上的演讲。

Go 1.18版本增加了对泛型的支持。泛型是我们自Go语言开源以来对Go做出的一次最大的变更。在这篇文章中，我们将介绍这个新的语言特性。我们不会面面俱到的讲解泛型语法特性的所有细节，但我们会介绍所有我们认为重要的内容。关于Go泛型语法更为详细的描述以及示例，请看Go泛型的提案文件。关于语言变化的更精确描述，请看更新后的Go语言规范。(请注意，实际的1.18实现对提案文件所允许的内容施加了一些限制；现阶段，更新后的语言规范应该是更准确的。未来的Go版本可能会取消Go 1.18实现中的某些限制）。

泛型是一种编程范式，这种范式与特定的类型无关，泛型允许在函数和类型的实现中使用某个类型集合中的任何一种类型。

泛型在Go语言中增加了三个新的重要内容：

函数和类型新增对**类型形参(type parameters)的支持。
将接口类型定义为类型集合，包括没有方法的接口类型。
支持类型推导，大多数情况下，调用泛型函数时可省略类型实参(type arguments)。

类型形参(Type Parameters)

现在，函数和类型被允许拥有类型形参(Type Parameters)。一个类型形参列表看起来和普通的函数形参列表一样，只是它使用的是方括号而不是小括号。

为了说明这一点，让我们先看一个用于浮点值的基本的、非泛型的Min函数：

func Min(x, y float64) float64 {
    if x < y {
        return x
    }
    return y
}

我们可以通过添加一个类型形参列表来使这个函数泛型化，以使其适用于不同的类型。在这个例子中，我们添加了一个仅有一个类型形参T的类型形参列表，并用T替换float64的使用。

func GMin[T constraints.Ordered](x, y T) T {
    if x < y {
        return x
    }
    return y
}

现在我们可以像下面代码那样，用一个类型实参(Type argument)来调用这个函数了：

x := GMin[int](2, 3)

向GMin函数提供类型实参，在本例中是int，称为实例化(instantiation)。实例化分两步进行。首先，编译器在整个泛型函数或泛型类型中把所有的类型形参替换成它们各自的类型实参。第二，编译器验证每个类型实参是否满足各自的约束条件。我们很快就会知道这意味着什么，但是如果第二步失败，实例化就会失败，程序也会无效。

在成功的实例化之后，我们就有一个非泛型的函数了，它可以像其他普通函数一样被调用。比如下面的代码：

fmin := GMin[float64]
m := fmin(2.71, 3.14)

GMin[float64]的实例化产生了一个与Min函数等效的函数，我们可以在函数调用中使用它。

类型参数也可以与类型一起使用。

type Tree[T interface{}] struct {
    left, right *Tree[T]
    value       T
}

func (t *Tree[T]) Lookup(x T) *Tree[T] { ... }

var stringTree Tree[string]

在上面这个例子中，泛型类型Tree存储了类型参数T的值。泛型类型也可以有方法，比如本例中的Lookup。为了使用一个泛型类型，它必须被实例化；Tree[string]是一个用类型实参string来实例化Tree的例子。

类型集合(Type sets)

让我们深入了解一下可以用来实例化一个类型形参的类型实参。

一个普通函数的每个值形参(译注：value parameter，相对于类型形参type parameter)都有一个对应的类型；该类型定义了一组值。例如，上面的非泛型函数Min有一个float64类型的形参，那么函数Min允许的实参值集合就是可以由float64类型表示的浮点值集合。

同样地，类型形参列表中的每个类型形参都有一个类型。因为类型形参本身就是一个类型，所以类型形参的类型定义了类型的集合。这种元类型(meta-type)被称为类型约束(type constraint)。

在泛型函数GMin中，类型约束是从constraints包中导入的。Ordered约束描述了所有类型的集合，这些类型的值可以被排序，或者换句话说，用<运算符（或<= , > , 等）进行比较。该约束确保只有具有可排序值的类型才能被传递给GMin。这也意味着在GMin的函数体中，该类型参数的值可以被用于<运算符的比较。

在Go中，类型约束必须是接口。也就是说，一个接口类型可以作为一个值类型使用，也可以作为一个元类型(meta-type)使用。接口定义了方法，所以显然我们可以使用要求某些方法存在的类型约束。但是constraints.Ordered也是一个接口类型，而且<操作符也不是一个方法。

为了使其发挥作用，我们以一种新的方式来看待接口。

直到最近(译注：该演讲发生在Go 1.18发布之前，这里的最近是Go 1.18发布之前的某个时间点)，Go规范说，一个接口定义了一个方法集合，大略就是接口中列举的方法集合。任何实现了所有这些方法的类型都实现了该接口。

但另一种看法是，接口定义了一个类型集合(type set)，即实现这些方法的类型。从这个角度来看，任何属于接口定义的类型集合中的元素的类型都实现了该接口。

这两种观点殊途同归。对于每个方法集合，我们可以想象出实现这些方法的类型组成的类型集合，这就是接口所定义的类型集合。

不过对于我们的目的来说，类型集合的观点比方法集合的观点更有优势：我们可以明确地将类型添加到集合中，从而以新的方式控制类型集合。

我们已经扩展了接口类型的语法，以使其发挥作用。例如，interface{ int|string|bool }定义了包含int、string和bool的类型集合。

另一种说法是，这个接口只被int、string或bool所满足。

现在我们来看看contraints.Ordered的实际定义。

type Ordered interface {
    Integer|Float|~string
}

这个声明说的是，Ordered接口是所有整数、浮点和字符串类型的集合。竖线表达了类型（或者说这里是类型集合）的联合(union)。Integer和Float是接口类型，在constraints包中也有类似的定义。注意，Ordered接口没有定义任何方法。

对于类型约束，我们通常不关心某一个特定的类型，比如字符串；我们对所有的字符串类型感兴趣。这就是~标记的作用。表达式~string意味着底层类型(underlying type)为string的所有类型的集合。这包括string类型本身，以及所有用类似type MyString string声明的类型。

当然，我们仍然想在接口中指定方法，而且我们想向后兼容。在Go 1.18中，一个接口可以像以前一样包含方法和嵌入接口，但它也可以嵌入非接口类型、联合体(union)和底层类型的集合。

当作为类型约束使用时，由接口定义的类型集合准确地指定了允许作为各自类型形参的类型实参的类型。在一个泛型函数体中，如果一个操作数的类型是带有约束C的类型形参P，那么如果操作被C的类型集合中的所有类型所允许，那么这些操作就是允许的（目前这里有一些实现限制，但是普通代码不太可能遇到这些限制）。

用作约束的接口可以被赋予名称（比如Ordered），也可以是内联到类型形参列表中的接口字面值，比如下面代码：

[S interface{~[]E}, E interface{}]

这里S必须是一个切片类型，切片的元素类型可以是任何类型。

因为这是一种常见的情况，所以对于处于约束位置的接口，用作包围的interface{}可以被省略，我们可以简单地写成下面这样：

[S ~[]E, E interface{}]

因为空接口在类型形参列表中很常见，在普通的Go代码中也是如此，Go 1.18引入了一个新的预声明的标识符any作为空接口类型的别名。这样一来，我们就得到了下面这段符合惯用法的代码：

[S ~[]E, E any]

作为类型集合的接口是一种强大的新机制，是使类型约束在Go中发挥作用的关键。目前，使用新语法形式的接口只能作为约束使用。但不难想象，显式指明类型约束的接口在一般情况下是多么有用。

类型推导(Type inference)

最后一个主要的语言新特性是类型推导。在某些方面，这是语言最复杂的变化，但它很重要，因为它让人们在编写调用泛型函数的代码时使用一种更为自然的风格。

函数实参类型推导(Function argument type inference)

有了类型形参，我们就需要传递类型实参，这可能使代码变得冗长。回到我们的泛型GMin函数：

func GMin[T constraints.Ordered](x, y T) T { ... }

类型形参T用于指定普通non-type参数x和y的类型。正如我们前面所看到的，我们可以用一个显式类型实参来调用它：

var a, b, m float64
m = GMin[float64](a, b) // 显式传递类型实参

在许多情况下，编译器可以从普通参数中推导出T的类型实参。这使得代码更短，同时保持清晰：

var a, b, m float64
m = GMin(a, b) // 没有传入类型实参

其原理是将实际参数a和b的类型与形式参数x和y的类型相匹配。

这种从函数的实参类型推导出类型实参的推导方式，被称为函数实参类型推导。

函数实参类型推导只适用于在函数参数中使用的类型形参的情况，不适用于只在函数返回值中使用的类型形参或只在函数主体中使用的类型形参的情况。例如，它不适用于像MakeTT any T这样的函数，它只在返回值参数列表中使用了类型形参T。

约束类型推导(Constraint type inference)

Go语言还支持另一种类型推导，即约束类型推导。为了说明这类推导，让我们从下面这个缩放整数切片的例子开始：

// Scale返回一个s的副本，每个元素都乘以c。
// 这个实现有一个问题，正如我们将看到的。
func Scale[E constraints.Integer](s []E, c E) []E {
    r := make([]E, len(s))
    for i, v := range s {
        r[i] = v * c
    }
    return r
}

这是一个泛型函数，适用于任何整数类型的切片。

现在，假设我们有一个多维的Point类型，其中每个Point只是一个表示该点坐标的整数列表。自然，这个类型会有一些方法。

type Point []int32

func (p Point) String() string {
    // 实现细节不重要
}

有时我们想对一个点进行缩放。因为一个点是一个整数切片，我们可以使用我们之前写的Scale函数。

// ScaleAndPrint将一个点加倍并打印出来。
func ScaleAndPrint(p Point) {
    r := Scale(p, 2)
    fmt.Println(r.String()) // 无法通过编译
}

不幸的是，这无法通过编译，编译器将给出r.String undefined (type []int32 has no field or method String) 这样的错误。

问题在于Scale函数返回一个[]E类型的值，其中E是参数切片的元素类型。当我们用一个Point类型的值调用Scale时，它的底层类型是[]int32，我们得到的是一个[]int32类型的值，而不是Point类型。这是由泛型代码的写法决定的，但这并不是我们想要的。

为了解决这个问题，我们必须改变Scale函数，使其使用一个类型参数来表示分片类型。

// Scale returns a copy of s with each element multiplied by c.
func Scale[S ~[]E, E constraints.Integer](s S, c E) S {
    r := make(S, len(s))
    for i, v := range s {
        r[i] = v * c
    }
    return r
}

我们引入了一个新的类型参数S，用于表示切片参数的类型。我们对它进行了约束，使其底层类型是S而不是[]E，返回值类型现在是S。由于E被约束为一个整数，其效果与之前一样：第一个参数必须是某个整数类型的切片。该函数主体的唯一变化是，现在我们在调用make时传递S，而不是[]E。

如果我们用一个普通的切片来调用它，新函数的作用和以前一样，但是如果我们用Point类型来调用它，我们现在得到一个Point类型的值。这就是我们想要的。有了这个版本的Scale，早先的ScaleAndPrint函数将如我们所期望的那样编译和运行。

但你可能会问：为什么调用Scale时不显式传递类型实参也可以呢？也就是说，为什么我们可以写Scale(p, 2)，没有类型实参，而不是必须写Scale[Point, int32](p, 2)？我们的新Scale函数有两个类型参数，S和E。在不传递任何类型实参的Scale调用中，上面描述的函数实参类型推导让编译器推导出s的类型实参是Point。但该函数还有另外一个类型形参E，编译器推导出E的类型实参是切片的元素类型的过程被称为约束类型推导。

约束类型推导是从类型形参约束中推导出类型实参。当一个类型形参的约束的定义中包含另一个类型形参时，它就会被使用。当这些类型形参中的一个的类型实参是已知的时候，该约束被用来推导另一个类型形参的类型实参。

约束类型推导通用用于当一个约束对某些类型使用~type的形式时，该type是用其他类型形参写的。我们在Scale的例子中看到了这一点。S是~[]E，~后面的类型[]E用另一个类型形参E来写成的。如果我们知道S的类型实参，我们就可以推导出E的类型实参。S是一个切片类型，而E是该切片的元素类型。

这只是对约束类型推导的一个介绍。完整的细节请参见提案文档文件或语言规范。

类型推导实践

类型推导的工作原理细节很复杂，但使用它并不复杂：类型推导要么成功要么失败。如果它成功了，类型实参可以被省略，调用泛型函数看起来与调用普通函数没有什么不同。如果类型推导失败，编译器会给出一个错误信息，在这些情况下，我们可以直接提供必要的类型实参。

在向语言添加类型推导时，我们试图在推导能力和复杂性之间取得平衡。我们想确保当编译器推导出类型时，这些类型永远不会令人惊讶。我们试图小心翼翼地站在未能推导出类型的一边，而不是站在推导出错误类型的一边。我们可能没有完全做到这一点，而且我们可能会在未来的版本中继续完善它。其效果是，更多的程序可以无需显式提供类型实参。今天不需要类型实参的程序，明天也不会需要。

小结

泛型是1.18中一个很大的新语言特性。这些新的语言变化需要大量的新代码，这些代码还没有在生产环境中进行过大量的测试。这只会随着越来越多的人编写和使用泛型代码而发生。我们相信这个功能实现得很好，质量很高。然而，与Go的大多数方面不同，我们无法用现实世界的经验来支持这一信念。因此，虽然我们鼓励在有意义的地方使用泛型，但在生产中部署泛型代码时，请使用适当的谨慎措施。

除此以外，我们很高兴能提供泛型，并希望它们能使Go程序员的工作效率更高。