Go 1.8 相比 Go 1.7 有哪些值得注意的改动？

本系列旨在梳理 Go 的 release notes 与发展史，来更加深入地理解 Go 语言设计的思路。

https://go.dev/doc/go1.8

Go 1.8 值得关注的改动：

1. 结构体转换忽略标签 (struct tags) ：Go 1.8 起，在显式转换两个结构体类型时，字段标签 (field tags) 会被忽略，只要底层字段类型和顺序一致即可转换。
2. yacc 工具移除 ：Go 1.8 移除了 go tool yacc，该工具已不再被 Go 编译器使用，并已迁移至 golang.org/x/tools/cmd/goyacc。
3. 编译器工具链更新 ：Go 1.8 将基于 静态单赋值形式 (Static Single Assignment form, SSA) 的新编译器后端推广至所有支持的 CPU 架构，带来了更优的代码生成、更好的优化基础（如边界检查消除）以及显著的性能提升（尤其在 32 位 ARM 上提升 20-30%）。同时引入了新的编译器前端，并提升了编译和链接速度（约 15%）。
4. 默认 GOPATH 与 go get 行为变更 ：如果 GOPATH 环境变量未设置，Go 1.8 会为其提供一个默认值（Unix 上为 $HOME/go，Windows 上为 %USERPROFILE%/go）。go get 命令现在无论是否使用 -insecure 标志，都会遵循 HTTP 代理相关的环境变量。
5. 实验性插件 (Plugins) 支持 ：Go 1.8 引入了对插件的初步支持，提供了新的 plugin 构建模式和用于运行时加载插件的 plugin 包（目前仅限 Linux）。
6. sort 包新增便捷函数 ：sort 包添加了 Slice 函数，允许直接对切片使用自定义的比较函数进行排序，简化了排序操作。同时新增了 SliceStable 和 SliceIsSorted。

下面是一些值得展开的讨论：

结构体转换时忽略字段标签 (Struct Tags)

Go 1.8 引入了一个语言规范上的变化：在进行显式的结构体类型转换时，编译器将不再考虑结构体字段的标签 (tags)。这意味着，如果两个结构体类型仅仅是字段标签不同，而字段的名称、类型和顺序完全相同，那么它们之间可以进行直接的类型转换。

在此之前的 Go 版本中，如果两个结构体类型即使只有标签不同，也被认为是不同的类型，无法直接转换，需要手动进行逐个字段的赋值。

我们来看官方的例子：

package main

import "fmt"

func main() {
    type T1 struct {
        X int `json:"foo"`
    }
    type T2 struct {
        X int `json:"bar"`
    }

    var v2 T2 = T2{X: 10}
    // 在 Go 1.8 及以后版本，这行代码是合法的
    var v1 T1 = T1(v2) 

    fmt.Println(v1) // 输出: {10}
}

在这个例子中，T1 和 T2 结构体都拥有一个 int 类型的字段 X，它们唯一的区别在于 X 字段的 json 标签不同。在 Go 1.8 之前，T1(v2) 这样的转换会引发编译错误。但从 Go 1.8 开始，这个转换是合法的，因为编译器在检查类型转换的兼容性时忽略了标签。

这个特性有什么用呢？

它在处理不同数据表示层（例如数据库模型、API 请求/响应体、内部业务逻辑结构）之间的转换时非常有用。这些不同的结构体可能共享相同的核心数据字段，但需要不同的标签来服务于各自的目的（如 db 标签用于 ORM，json 标签用于序列化）。

考虑以下场景：我们有一个从数据库读取的用户模型和一个用于 API 输出的用户模型。

package main

import "fmt"

// 数据库模型
type UserDB struct {
    ID   int    `db:"user_id,omitempty"`
    Name string `db:"user_name"`
    Age  int    `db:"user_age"`
}

// API 输出模型
type UserAPI struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age,omitempty"`
}

func main() {
    // 假设这是从数据库查询得到的数据
    dbUser := UserDB{ID: 1, Name: "Alice", Age: 30}

    // 在 Go 1.8+ 中，可以直接转换
    apiUser := UserAPI(dbUser)

    fmt.Printf("DB User: %+v\n", dbUser)
    fmt.Printf("API User: %+v\n", apiUser) 

    // 反向转换同样合法
    dbUserConvertedBack := UserDB(apiUser)
    fmt.Printf("DB User Converted Back: %+v\n", dbUserConvertedBack)
}

在 Go 1.8 之前，你需要手动编写类似这样的转换代码：

// Go 1.7 及更早版本的做法
func convertDBToAPI(dbUser UserDB) UserAPI {
    return UserAPI{
        ID:   dbUser.ID,
        Name: dbUser.Name,
        Age:  dbUser.Age,
    }
}
apiUser := convertDBToAPI(dbUser) 

Go 1.8 的这项改动使得这种仅标签不同的结构体之间的转换更加简洁和直接，减少了样板代码。当然，需要强调的是，字段的名称、类型和顺序 必须 完全一致，才能进行这种转换。

实验性的插件 (Plugin) 支持

Go 1.8 引入了一个备受期待但标记为实验性的功能：插件 (Plugins)。这个功能允许 Go 程序在运行时动态加载使用 Go 语言编写的共享库（.so 文件），并调用其中的函数或访问其变量。

核心概念：

1. 构建模式 plugin：通过 go build -buildmode=plugin 命令，可以将一个 main 包（或者未来可能支持其他包）编译成一个共享对象文件（通常是 .so 文件）。这个文件包含了编译后的 Go 代码和运行时信息。

2. plugin 包：Go 标准库新增了 plugin 包，提供了加载和使用插件的功能。

   • plugin.Open(path string) (*Plugin, error)：根据路径加载一个插件文件。它会执行插件代码中的 init 函数。
   • (*Plugin).Lookup(symName string) (Symbol, error)：在已加载的插件中查找导出的（大写字母开头的）变量或函数名。Symbol 是一个空接口类型 (interface{})。

基本用法示例：

假设我们有一个简单的插件，提供一个打招呼的功能。

1. 创建插件代码 (greeter/greeter.go)

package main // 插件必须是 main 包

import "fmt"

// 导出的函数，首字母必须大写
func Greet() {
    fmt.Println("Hello from the plugin!")
}

// 也可以导出变量
var PluginVersion = "1.0" 

// 插件不需要 main 函数，但可以有 init 函数
func init() {
    fmt.Println("Greeter plugin initialized!")
}

// 为了让编译器不报错，需要一个 main 函数，但它在插件模式下不会被执行
func main() {} 

2. 编译插件

在你的项目目录下执行（假设 greeter 目录在当前路径下）：

go build -buildmode=plugin -o greeter.so greeter/greeter.go

这会生成一个 greeter.so 文件。

3. 创建主程序 (main.go)

package main

import (
    "fmt"
    "log"
    "plugin"
)

func main() {
    // 1. 加载插件
    // 注意：路径根据实际情况调整
    p, err := plugin.Open("./greeter.so") 
    if err != nil {
        log.Fatalf("Failed to open plugin: %v", err)
    }
    fmt.Println("Plugin loaded successfully.")

    // 2. 查找导出的 'Greet' 函数
    greetSymbol, err := p.Lookup("Greet")
    if err != nil {
        log.Fatalf("Failed to lookup Greet symbol: %v", err)
    }

    // 3. 类型断言：将 Symbol 转换为期望的函数类型
    greetFunc, ok := greetSymbol.(func()) // 注意类型是 func()
    if !ok {
        log.Fatalf("Symbol Greet is not of type func()")
    }

    // 4. 调用插件函数
    fmt.Println("Calling Greet function from plugin...")
    greetFunc()

    // 5. 查找导出的 'PluginVersion' 变量
    versionSymbol, err := p.Lookup("PluginVersion")
    if err != nil {
        log.Fatalf("Failed to lookup PluginVersion symbol: %v", err)
    }
    
    // 6. 类型断言：将 Symbol 转换为期望的变量类型指针
    // 注意：查找变量得到的是指向该变量的指针
    versionPtr, ok := versionSymbol.(*string) 
    if !ok {
        log.Fatalf("Symbol PluginVersion is not of type *string")
    }
    
    // 7. 使用插件变量（需要解引用）
    fmt.Printf("Plugin version: %s\n", *versionPtr) 
}

4. 运行主程序

go run main.go 

你将会看到类似如下的输出：

Greeter plugin initialized!
Plugin loaded successfully.
Calling Greet function from plugin...
Hello from the plugin!
Plugin version: 1.0

Go 1.8 插件的限制和注意事项：

• 实验性：API 和行为在未来版本可能发生变化。
• 仅 Linux：在 Go 1.8 中，插件支持仅限于 Linux 平台。
• 依赖匹配：主程序和插件必须使用完全相同的 Go 版本编译，并且所有共享的依赖库（包括标准库和第三方库）的版本和路径都必须精确匹配。任何不匹配都可能导致加载失败或运行时崩溃。这在实践中是一个相当大的挑战。
• 包路径：插件和主程序对于共享依赖的 import 路径必须一致。
• main 包：插件源文件必须属于 package main，即使它不包含 main 函数的实际执行逻辑。

潜在应用场景：

尽管有诸多限制，插件机制为构建可扩展的应用程序提供了可能，例如：

• 允许用户或第三方开发者扩展核心应用功能。
• 实现某些类型的热更新（尽管依赖匹配问题使得这很复杂）。
• 开发可定制化的工具或系统。

总的来说，Go 1.8 的插件是向动态加载 Go 代码迈出的第一步，虽然在当时还很初步且有平台限制，但为 Go 生态的发展开辟了新的方向。

sort 包：更便捷的切片排序方式

Go 1.8 之前的版本中，要对一个自定义类型的切片进行排序，通常需要实现 sort.Interface 接口，该接口包含三个方法：Len()、Less(i, j int) bool 和 Swap(i, j int)。这需要为每种需要排序的切片类型定义一个新的类型（通常是该切片类型的别名），并实现这三个方法。虽然不复杂，但略显繁琐，尤其是对于只需要一次性排序的场景。

Go 1.8 在 sort 包中引入了 Slice 函数，极大地简化了对任意类型切片的排序：

func Slice(slice interface{}, less func(i, j int) bool)

sort.Slice 函数接受两个参数：

1. slice: 需要排序的切片，类型为 interface{}。
2. less: 一个比较函数，签名必须是 func(i, j int) bool。这个函数定义了排序的规则：当索引 i 处的元素应该排在索引 j 处的元素之前时，返回 true。

这个函数利用反射 (reflection) 来操作传入的切片，并使用用户提供的 less 函数进行元素的比较和交换，从而避免了开发者手动实现 sort.Interface 的三个方法。

示例对比：

假设我们有一个 Person 结构体切片，需要按年龄升序排序。

package main

import (
    "fmt"
    "sort"
)

type Person struct {
    Name string
    Age  int
}

// 用于打印切片
func printPeople(people []Person) {
    for _, p := range people {
        fmt.Printf("  %+v\n", p)
    }
}

// --- Go 1.7 及更早版本的做法 ---
// 1. 定义一个新类型
type ByAge []Person
// 2. 实现 sort.Interface
func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }


func main() {
    people := []Person{
        {"Bob", 31},
        {"Alice", 25},
        {"Charlie", 31}, // 与 Bob 同龄
        {"David", 22},
    }

    fmt.Println("Original slice:")
    printPeople(people)

    peopleCopy1 := make([]Person, len(people))
    copy(peopleCopy1, people) // 复制一份用于演示旧方法

    sort.Sort(ByAge(peopleCopy1))
    fmt.Println("\nSorted using sort.Sort (Go 1.7 style):")
    printPeople(peopleCopy1)


    // --- Go 1.8 的新做法 ---
    peopleCopy2 := make([]Person, len(people))
    copy(peopleCopy2, people) // 复制一份用于演示新方法

    sort.Slice(peopleCopy2, func(i, j int) bool {
        // 直接在闭包中定义比较逻辑
        return peopleCopy2[i].Age < peopleCopy2[j].Age 
    })

    fmt.Println("\nSorted using sort.Slice (Go 1.8 style):")
    printPeople(peopleCopy2)
}

输出：

Original slice:
  {Name:Bob Age:31}
  {Name:Alice Age:25}
  {Name:Charlie Age:31}
  {Name:David Age:22}

Sorted using sort.Sort (Go 1.7 style):
  {Name:David Age:22}
  {Name:Alice Age:25}
  {Name:Bob Age:31}
  {Name:Charlie Age:31}

Sorted using sort.Slice (Go 1.8 style):
  {Name:David Age:22}
  {Name:Alice Age:25}
  {Name:Bob Age:31}
  {Name:Charlie Age:31}

可以看到，使用 sort.Slice 显著减少了为排序而编写的样板代码。我们不再需要定义 ByAge 类型及其三个方法，只需提供一个简单的比较闭包即可。

新增的其他函数：

• sort.SliceStable(slice interface{}, less func(i, j int) bool)：与 sort.Slice 类似，但它执行稳定排序。稳定排序保证了相等元素（根据 less 函数判断为不小于也不大于彼此的元素）在排序后的相对顺序与排序前保持一致。在上面的例子中，如果使用 SliceStable，Bob 会始终排在 Charlie 前面，因为他们在原始切片中的顺序就是如此。
• sort.SliceIsSorted(slice interface{}, less func(i, j int) bool) bool：检查切片是否已经根据 less 函数定义的顺序排好序。

sort.Slice 及其相关函数的引入，使得在 Go 中对切片进行自定义排序变得更加方便和直观。