Go 1.10 相比 Go 1.9 有哪些值得注意的改动？

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

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

Go 1.10 值得关注的改动：

1. 语言层面 - 无类型常量位移（Untyped Constant Shifts） ： 明确了一个涉及无类型常量位移的边界情况。据此，编译器更新后允许 x[1.0 << s] 这样的索引表达式（其中 s 是无符号整数），这与 go/types 包的行为保持了一致。
2. 语言层面 - 方法表达式（Method Expressions） ： 放宽了方法表达式的语法，允许任何类型表达式作为接收者。例如，struct{io.Reader}.Read 这种虽然不常见但已被编译器接受的写法，现在在语言规范层面也被正式允许了。
3. 工具链 - 默认 GOROOT 与 GOTMPDIR ： 如果环境变量 $GOROOT 未设置，go 工具现在会尝试根据自身可执行文件的路径推断 GOROOT，然后再回退到编译时设置的默认值，使得二进制分发包解压后无需显式设置 $GOROOT 即可使用。新增了 $GOTMPDIR 环境变量，允许用户指定 go 工具创建临时文件和目录的位置，默认为系统临时目录。
4. 工具链 - 构建缓存（Build Cache） ： go build 命令引入了一个新的构建缓存机制，独立于 $GOROOT/pkg 或 $GOPATH/pkg 中的已安装包。这显著提高了未显式安装包或在不同源码版本间切换（如切换 git 分支）时的构建速度。因此，之前为了加速而推荐使用的 -i 标志（如 go build -i）已不再必要。
5. 工具链 - Cgo ： 出于安全考虑，通过 #cgo CFLAGS 等指令指定的选项现在会根据一个允许列表进行检查，防止恶意包利用 -fplugin 等选项在构建时执行任意代码。Cgo 现在使用 Go 的类型别名（type alias）来实现 C 的 typedef，使得对应的 Go 类型 C.X 和 C.Y 可以互换使用。同时，支持了无参数的函数式宏（niladic function-like macros）。此外，文档明确了 Cgo 导出的函数签名中不支持 Go 结构体和数组。新增了从 C 代码直接访问 Go 字符串值的能力，通过 _GoString_ 类型、_GoStringLen 和 _GoStringPtr 函数实现。
6. 核心库 - bytes 包切片行为变更 ： Fields, FieldsFunc, Split, SplitAfter 函数返回的子切片（subslice）现在其容量（capacity）将等于其长度（length），防止对子切片的 append 操作意外覆盖原始输入中的相邻数据。
7. 核心库 - database/sql/driver 接口增强 ： 驱动实现者应注意不再持有 driver.Rows.Next 提供的目标缓冲区并在调用之外写入。新增 Connector 接口和 sql.OpenDB 函数，方便驱动构建 sql.DB 实例。新增 DriverContext 接口的 OpenConnector 方法，允许驱动解析一次配置或访问连接上下文。实现了 ExecerContext 或 QueryerContext 的驱动不再强制要求实现对应的非 Context 版本接口。新增 SessionResetter 接口，允许驱动在复用连接前重置会话状态。

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

bytes 包：切片函数返回结果的容量调整

在 Go 1.10 中，bytes 包里的 Fields, FieldsFunc, Split, 和 SplitAfter 这几个函数有一个重要的行为变更：它们返回的子切片（subslice）的容量（capacity）现在被设置为与其长度（length）相等。这个改动主要是为了防止一个常见的陷阱：修改（尤其是 append 操作）返回的子切片时，意外地覆盖了原始字节切片（byte slice）中相邻的数据。

我们知道，Go 中的切片是对底层数组（underlying array）的一个视图，由指向数组的指针、切片长度（length）和切片容量（capacity）三部分组成。容量决定了在不重新分配内存的情况下，切片可以增长到的最大长度。

在 Go 1.9 及更早版本中，这些函数返回的子切片可能会共享底层数组，并且其容量可能大于其长度，指向原始数据中更靠后的部分。

Go 1.9 及更早版本的行为示例：

package main

import (
    "bytes"
    "fmt"
)

func main() {
    data := []byte("Hello World Gopher")
    fmt.Printf("Original data: %s\n", data)

    // 使用 Split 切分字符串
    parts := bytes.Split(data, []byte(" ")) // 按空格切分

    // parts[0] 是 "Hello"
    // 在 Go 1.9 中，parts[0] 的 len 是 5，但 cap 可能是整个 data 的长度 (18)
    // 或者至少是到下一个分隔符之前的长度
    fmt.Printf("Part 0: %s, len=%d, cap=%d\n", parts[0], len(parts[0]), cap(parts[0]))

    // 尝试向第一个部分追加数据
    parts[0] = append(parts[0], '!', '!') // 追加 "!!"

    // 由于 parts[0] 的容量可能大于 5，append 操作可能会直接在底层数组上修改
    // 这可能会覆盖掉原始 data 中 " World" 的一部分
    fmt.Printf("After append to Part 0: %s\n", parts[0])
    fmt.Printf("Original data after append: %s\n", data) // 观察原始 data 是否被修改
}

在 Go 1.9 上运行上述代码，输出可能类似（具体容量取决于实现细节）：

Original data: Hello World Gopher
Part 0: Hello, len=5, cap=32
After append to Part 0: Hello!!
Original data after append: Hello!!orld Gopher

可以看到，对 parts[0] 的 append 操作因为其容量足够大，直接修改了底层数组，导致原始 data 的内容从 Hello World Gopher 变成了 Hello!!orld Gopher，这通常不是我们期望的行为。

Go 1.10 及之后版本的行为：

Go 1.10 通过将返回子切片的容量设置为等于其长度，彻底解决了这个问题。

使用相同的代码，在 Go 1.10 或更高版本上运行：

package main

import (
    "bytes"
    "fmt"
)

func main() {
    data := []byte("Hello World Gopher")
    fmt.Printf("Original data: %s\n", data)

    parts := bytes.Split(data, []byte(" "))

    // 在 Go 1.10+ 中，parts[0] 的 len 是 5，cap 也是 5
    fmt.Printf("Part 0: %s, len=%d, cap=%d\n", parts[0], len(parts[0]), cap(parts[0]))

    // 尝试向第一个部分追加数据
    parts[0] = append(parts[0], '!', '!') // 追加 "!!"

    // 由于 parts[0] 的 cap 等于 len，append 操作会触发底层数组的重新分配和复制
    // 新的底层数组与原始 data 无关
    fmt.Printf("After append to Part 0: %s\n", parts[0]) // parts[0] 变成了 "Hello!!"
    fmt.Printf("Original data after append: %s\n", data) // 原始 data 保持不变
}

输出将是：

Original data: Hello World Gopher
Part 0: Hello, len=5, cap=5
After append to Part 0: Hello!!
Original data after append: Hello World Gopher

可以看到，在 Go 1.10 中，对 parts[0] 进行 append 操作时，由于容量不足，Go 会分配一个新的底层数组来存放 Hello!!，而原始的 data 切片及其底层数组则完全不受影响。这使得代码行为更加健壮和可预测。

这个改动虽然细微，但对于依赖这些函数进行数据处理的场景，可以避免一些难以调试的 bug。开发者现在可以更放心地修改这些函数返回的子切片，而不必担心破坏原始数据。

database/sql/driver 包：接口改进与功能增强

Go 1.10 对 database/sql/driver 包进行了一系列改进，旨在提升数据库驱动（database driver）开发的灵活性、健壮性和易用性。这些改动主要面向驱动的开发者，但也间接影响了使用 database/sql 的应用开发者（例如通过更优化的驱动获得更好的性能或功能）。

主要的改进点包括：

1. driver.Rows.Next 的目标缓冲区使用规范

明确要求驱动实现者，在 driver.Rows.Next(dest []driver.Value) 方法返回后，不应再持有 dest 切片并向其中写入数据。同时，在关闭 driver.Rows 时，必须确保底层的缓冲区（如果被复用）不会被意外修改。这有助于防止数据竞争和状态混乱。

• 对比：之前虽然没有明确禁止，但持有并后续修改 dest 是不安全的做法。Go 1.10 在文档和预期行为上对此进行了强调。

2. 引入 Connector 接口和 sql.OpenDB 函数

允许数据库驱动提供一个 driver.Connector 对象，而不是强制将所有连接信息编码成一个 DSN（Data Source Name）字符串。应用可以通过 sql.OpenDB(connector) 来获取 sql.DB 实例。

• driver.Connector 接口

type Connector interface {
    Connect(context.Context) (Conn, error) // 创建一个新的数据库连接
    Driver() Driver                        // 返回关联的 Driver
}

• 对比 ：在 Go 1.10 之前，驱动通常只实现 driver.Driver 接口，应用通过 sql.Open(driverName, dataSourceName) 来创建 sql.DB。这意味着所有配置都需要序列化到 dataSourceName 字符串中，驱动在内部再解析。

• 优势 ：

  • 类型安全 ：驱动可以定义自己的配置结构体，应用直接使用结构体配置，避免了 DSN 字符串解析的复杂性和易错性。
  • 灵活性 ：Connector 可以包含更复杂的状态或逻辑，比如管理连接池的策略、持有预初始化的资源等。

示例（驱动侧）

package mydriver

import (
    "context"
    "database/sql/driver"
)

type MyConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    // ... 其他配置
}

type myConnector struct {
    cfg    MyConfig
    driver *myDriver // 引用 Driver 实现
}

func (c *myConnector) Connect(ctx context.Context) (driver.Conn, error) {
    // 使用 c.cfg 中的配置信息建立实际的数据库连接
    // ... 返回一个实现了 driver.Conn 的连接对象
    return connectToDatabase(ctx, c.cfg)
}

func (c *myConnector) Driver() driver.Driver {
    return c.driver
}

// 驱动可以提供一个函数来创建 Connector
func NewConnector(cfg MyConfig) driver.Connector {
    return &myConnector{cfg: cfg, driver: &theDriver} // theDriver 是 MyDriver 的实例
}

// MyDriver 仍然需要实现 driver.Driver，但 Open 方法可能变得简单或不再是主要入口
type myDriver struct{}
func (d *myDriver) Open(name string) (driver.Conn, error) {
        // 可能仍然支持 DSN，或者返回错误提示使用 Connector
        cfg, err := parseDSN(name)
        if err != nil { return nil, err }
        return connectToDatabase(context.Background(), cfg)
}

var theDriver myDriver // Driver 实例

// connectToDatabase 和 parseDSN 是具体的实现细节
func connectToDatabase(ctx context.Context, cfg MyConfig) (driver.Conn, error) { /* ... */ return nil, nil }
func parseDSN(name string) (MyConfig, error) { /* ... */ return MyConfig{}, nil }

示例（应用侧）

package main

import (
    "database/sql"
    "log"

    "path/to/mydriver" // 引入你的驱动包
)

func main() {
    cfg := mydriver.MyConfig{
        Host:     "localhost",
        Port:     5432,
        Username: "user",
        Password: "password",
    }
    connector := mydriver.NewConnector(cfg)

    db := sql.OpenDB(connector) // 使用 Connector 打开数据库
    defer db.Close()

    err := db.Ping()
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Connected!")
    // ... 使用 db 进行数据库操作
}

3. DriverContext 接口与 OpenConnector 方法

如果驱动实现了 driver.DriverContext 接口（在 Go 1.8 引入），它可以额外实现新的 OpenConnector(name string) (Connector, error) 方法。这使得 sql.Open 在内部可以先尝试调用 OpenConnector 来获取一个 Connector。

• 优势 ：

  • 允许驱动只解析一次 DSN 字符串（在 OpenConnector 中），然后创建的 Connector 可以持有解析后的配置，供后续 Connect 调用使用，避免了每次建立新连接（driver.Conn）时都重新解析 DSN。
  • 使得基于 DSN 的 sql.Open 也能利用 Connector 的优势。
• 示例（驱动侧 DriverContext 实现）

package mydriver

import (
    "context"
    "database/sql/driver"
    "sync"
)

// 解析后的配置结构
type MyConfig struct {
    // 例如: host, port, user, password 等字段
}

// Connector 持有解析后的配置，实现 driver.Connector 接口
type myConnector struct {
    cfg    *MyConfig       // 关键：保存解析后的配置，供后续 Connect 使用
    driver driver.Driver   // 关联的驱动实例
}

func (c *myConnector) Connect(ctx context.Context) (driver.Conn, error) {
    // 使用预先解析好的 cfg 创建连接，无需再次解析 DSN！
    return connectToDatabase(ctx, c.cfg)
}

func (c *myConnector) Driver() driver.Driver {
    return c.driver
}

// 驱动实现 DriverContext 接口
type myDriver struct {
    // 可选：缓存 Connector，避免相同 DSN 重复解析（根据需求决定是否添加）
    connectors sync.Map // map[string]*myConnector
}

// 确保实现 DriverContext 接口
var _ driver.DriverContext = (*myDriver)(nil)

// OpenConnector 实现 DriverContext 接口，仅解析一次 DSN
func (d *myDriver) OpenConnector(name string) (driver.Connector, error) {
    // 可选：缓存 Connector（根据业务需求）
    if v, ok := d.connectors.Load(name); ok {
        return v.(*myConnector), nil
    }

    // 解析 DSN（仅在此处执行一次）
    cfg, err := parseDSN(name)
    if err != nil {
        return nil, err
    }

    // 创建 Connector 并缓存（可选）
    connector := &myConnector{cfg: cfg, driver: d}
    d.connectors.Store(name, connector)
    return connector, nil
}

// Open 方法仅用于兼容旧版本，实际使用 DriverContext 时不会被调用
func (d *myDriver) Open(name string) (driver.Conn, error) {
    // 当驱动未实现 DriverContext 时，sql.Open 会调用此方法
    // 此处逻辑仅为兼容，实际可简化或报错
    connector, err := d.OpenConnector(name)
    if err != nil {
        return nil, err
    }
    return connector.Connect(context.Background()) // 复用 Connect 逻辑
}

// --- 辅助函数 ---
func parseDSN(name string) (*MyConfig, error) {
    // 具体解析逻辑（例如解析连接字符串为 MyConfig）
    return &MyConfig{}, nil
}

func connectToDatabase(ctx context.Context, cfg *MyConfig) (driver.Conn, error) {
    // 使用 cfg 创建真实连接（例如 TCP 连接、认证等）
    return &myConn{}, nil
}

// 实现 driver.Conn 的空结构（具体方法需实现）
type myConn struct{ 
    driver.Conn 
    // 实现 Query, Exec, Close 等方法...
}

// 全局驱动实例
var theDriver myDriver

应用侧 ：仍然使用 sql.Open("mydriver", dsnString)，database/sql 包会自动检测并优先使用 OpenConnector 。

4. Context 相关接口的简化

如果驱动实现了带有 Context 参数的接口，如 ExecerContext, QueryerContext, ConnPrepareContext, ConnBeginTx，那么它不再需要强制实现对应的无 Context 版本接口（Execer, Queryer, Prepare, Begin）。database/sql 包会优先使用 Context 版本，如果驱动未实现，则会回退到无 Context 版本（如果存在）。

• 对比：在 Go 1.10 之前，即使实现了 ExecerContext，也必须同时实现 Execer，否则 Context 版本会被忽略。
• 优势：简化了驱动的实现，驱动开发者只需实现更现代、功能更强的 Context 版本接口即可。

5. SessionResetter 接口

允许驱动在连接被归还到连接池后、再次被取出复用之前，执行一些清理或状态重置操作。如果 driver.Conn 实现了 SessionResetter 接口，database/sql 会在复用连接前调用其 ResetSession(ctx context.Context) error 方法。

• SessionResetter 接口

type SessionResetter interface {
    ResetSession(ctx context.Context) error
}

• 应用场景 ：例如，重置会话变量、清除临时表、回滚未完成的事务（虽然 database/sql 自身有事务管理，但这提供了一个额外的保险层或用于处理驱动特定的会话状态）。
• 优势 ：提高了连接池中连接复用的安全性，更好地隔离了不同用户或请求之间的会话状态。
• 示例（驱动侧 Conn 实现）

package mydriver

import (
    "context"
    "database/sql/driver"
)

type myConn struct {
    // ... 连接相关的字段 ...
    sessionInitialized bool
    tempData           string
}

// 确保 myConn 实现了 SessionResetter
var _ driver.SessionResetter = (*myConn)(nil)

func (c *myConn) ResetSession(ctx context.Context) error {
    // 在连接被复用前调用
    if c.sessionInitialized {
            // 执行清理操作，例如：
            // _, err := c.exec("RESET SESSION VARIABLES", nil) // 假设有这样的 SQL
            // if err != nil { return err }
            c.tempData = "" // 清理会话相关的临时状态
            c.sessionInitialized = false
            // log.Printf("Session reset for connection %p", c)
    }
    return nil
}

// ... 其他 driver.Conn 接口方法的实现 ...
func (c *myConn) Prepare(query string) (driver.Stmt, error) { /* ... */ return nil, nil }
func (c *myConn) Close() error { /* ... */ return nil }
func (c *myConn) Begin() (driver.Tx, error) { /* ... */ return nil, nil }

// 在执行某些操作后，可能会设置会话状态
func (c *myConn) doSomethingThatSetsSessionState() {
    c.sessionInitialized = true
    c.tempData = "some session specific data"
}

总结来说，Go 1.10 对 database/sql/driver 的改进使得驱动开发更加现代化和灵活，特别是在配置管理、上下文处理和连接池管理方面提供了更好的支持，有助于构建更健壮、高性能的数据库驱动。