Go 1.18 相比 Go 1.17 有哪些值得注意的改动？

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

Some Undocumented Changes in Go 1.18 and 1.19

Go 1.18 是 Go 语言发展史上的一个重要里程碑，它引入了备受期待的泛型，并包含了其他多项重要的更新和改进。以下是 Go 1.18 相比 Go 1.17 值得关注的改动概览：

泛型 (Generics): 根据类型参数提案 (Type Parameters Proposal)，实现了泛型功能。这是对语言的一次重大补充，但保持了完全的后向兼容性。不过，由于是新功能，在生产环境中的广泛测试尚不充分。
Bug 修复: 编译器现在能正确报告 print / println 中 rune 常量表达式（如 '1' << 32）的溢出错误，并修复了函数字面量 (function literal) 中声明但未使用的变量不会报错的长期问题。
模糊测试 (Fuzzing): 根据模糊测试提案 (fuzzing proposal)，在 Go 工具链中原生支持了模糊测试。
Go 命令: go get 命令不再用于构建和安装包（在模块感知模式下），而是专注于管理 go.mod 中的依赖项；引入了新的工作区模式 (Workspace mode)；构建时会默认嵌入版本控制和构建信息。
Vet: vet 工具更新以支持泛型代码的检查，并提升了部分现有检查器的准确性。
运行时 (Runtime): 垃圾回收器 (Garbage Collector, GC) 在决定运行频率时，现在会考虑非堆内存来源（例如栈扫描 (Stack scanning)）的 GC 工作量。
编译器与链接器: 基于寄存器传参的优化扩展到了 64 位 ARM、64 位 PowerPC 平台；链接器效率显著提升，生成更小的二进制文件并减少了重定位 (Relocations) 操作。
新包 debug/buildinfo: 提供访问嵌入在可执行文件中的构建信息（模块版本、版本控制信息、构建标志等）的能力。
新包 net/netip: 引入了新的 IP 地址类型 netip.Addr，它比 net.IP 更节省内存、不可变 (immutable) 且可比较 (comparable)，因此可以用作 map 的 key。

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

泛型 (Generics) 终于到来

Go 1.18 最大的亮点无疑是正式引入了泛型，实现了类型参数提案中的设计。这一特性为 Go 语言带来了更强的代码复用能力和类型安全性，但 Go 团队也强调，由于这是一项全新的、复杂的语言特性，其实现在生产环境中的验证还需要时间，鼓励开发者在采纳时保持谨慎。

核心特性：

类型参数 (Type Parameters): 函数和类型声明现在可以包含类型参数列表，使用方括号 [] 定义。

// 一个简单的泛型函数，打印任意类型的切片
func PrintSlice[T any](s []T) {
    // ...
}

// 一个泛型类型，持有某种类型的值
type Container[T any] struct {
    Value T
}

类型实例化: 使用方括号 [] 提供类型实参来实例化泛型函数或类型。

PrintSlice[int]([]int{1, 2, 3})
var c Container[string] = Container[string]{Value: "hello"}

类型约束 (Type Constraints): 接口类型得到了增强，可以用作类型约束，限制类型参数可以接受的类型范围。接口现在不仅定义方法集，还可以定义类型集。

可以嵌入任意类型（不仅仅是接口类型名）。
可以使用 | 来创建类型的联合 (Union)。
可以使用 ~T 来表示底层类型 (underlying type) 为 T 的所有类型。

// 定义一个约束，允许任何底层类型为 int 或 string 的类型
type IntOrString interface {
    ~int | ~string
}

func Process[T IntOrString](value T) {
    // value 只能是 int, string 或它们的别名类型
}

// 使用预定义的 comparable 约束
func FindIndex[T comparable](slice []T, target T) int {
    // T 必须是支持 == 和 != 操作的类型
    for i, v := range slice {
        if v == target {
            return i
        }
    }
    return -1
}

预定义标识符:

any: interface{} 的类型别名 (type alias)，使空接口的写法更简洁。
comparable: 一个接口，代表所有可以使用 == 或 != 进行比较的类型集合。它只能用作（或嵌入）类型约束。

实验性泛型包: 提供了三个实验性的泛型工具包，位于 golang.org/x/exp/ 下，它们的 API 不受 Go 1 兼容性保证：

constraints: 包含常用约束，如 constraints.Ordered。
slices: 操作任意类型切片的泛型函数集合。
maps: 操作任意键值类型 map 的泛型函数集合。

Go 泛型的设计理念（为什么如此“简单”？）：

你可能会注意到 Go 的泛型相比其他语言（如 C++, Java, Rust）显得更为“简陋”。这并非偶然，而是 Go 团队设计选择的结果。Go 语言的核心哲学之一是 保持简单性 。复杂的泛型系统（例如类型特化、高阶类型参数等）会显著增加语言的复杂度和编译器的实现难度。Go 团队的目标是提供一个 实用且足够强大 的泛型实现，解决最常见的代码复用问题，同时避免引入过多的复杂性。这种设计权衡旨在维持 Go 代码的 可读性和易维护性 。虽然当前实现有一些限制（见下文），但它们满足了许多核心需求，并为未来的迭代留下了空间。

已知限制：

目前的泛型实现存在一些限制，未来版本可能会改进：

编译器不支持在泛型函数或方法内部声明类型。
编译器不允许对类型参数类型的参数使用预定义的 real、imag 和 complex 函数。
方法调用（如 x.m）和字段访问（如 x.f）在 x 是类型参数类型时受到限制，通常要求方法或字段在约束接口中明确声明。
不允许将类型参数或其指针作为匿名字段嵌入结构体或接口中。
联合类型元素如果多于一项，则不能包含带有非空方法集的接口类型。

泛型的引入是对 Go 生态系统的一次重大变革，相关的工具、文档和库都需要时间来适应和完善。

编译器 Bug 修复与行为变更

Go 1.18 修正了一些长期存在的编译器 Bug，并明确了一些之前行为不一致的地方，使得编译器的行为更加符合语言规范。

未使用变量的错误报告: 之前，如果一个变量在函数字面量 (function literal) 内部被赋值（例如在闭包中捕获），但在该字面量内部从未被使用，编译器可能不会报告 "declared but not used" 错误。Go 1.18 修复了这个问题 (Issue #8560)。

package main

import "fmt"

func main() {
    vals := []int{1, 2, 3}
    var funcs []func()
    for _, val := range vals {
        valCopy := val // 在 Go 1.18 之前，如果下面的函数字面量不使用 valCopy，这里可能不会报错
        funcs = append(funcs, func() {
            // 如果这行注释掉，Go 1.18 会报 valCopy declared but not used 错误
            // fmt.Println(valCopy)
        })
        // 可以通过 _ = valCopy 来显式标记为已使用
    }
    // 执行 funcs 中的函数（这里只是为了让例子完整）
    for _, f := range funcs {
        f() // 如果 valCopy 未在内部使用，这并不会改变它是未使用变量的事实
    }
}

如果你的代码依赖了旧的错误行为，现在需要修正：要么使用该变量，要么用空白标识符 _ 赋值给它。由于 go vet 一直能检测到这类问题，受影响的代码可能不多。

print/println 中常量表达式溢出: 对于明显超出其类型表示范围的常量表达式（例如 '1' << 32，结果超出了 rune 的范围），在传递给内置函数 print 和 println 时，Go 1.18 编译器现在会正确报告溢出错误。这与用户自定义函数的行为保持了一致。

package main

func main() {
    // Go 1.18 会报错：overflows rune
    // println('1' << 32)

    // 修正：如果意图是 int64，需要显式转换
    println(int64('1') << 32)
}

字节切片 (slice of bytes) 转换的明确化: Go 规范允许 string 和“字节切片”之间进行转换。Go 1.18 明确了“字节切片”的定义为： 元素类型其底层类型为 byte 的任何切片类型 。之前版本的编译器在此处行为可能不一致。这意味着，像 type MyByte byte; type MyBytes []MyByte 这样的类型现在可以稳定地与 string 进行相互转换。

package main

type MyByte byte
type MyBytes []MyByte

func main() {
    s := "Hello"
    var b MyBytes

    // Go 1.18 及之后版本可以稳定工作
    b = MyBytes(s)
    s2 := string(b)
    _ = s2

    // 注意：截至 Go 1.19，reflect 包的 ConvertibleTo 可能还未完全同步此变更。
}

局部常量声明中 iota 的细微行为修正: 在 const 块中，如果省略了某个常量规范的表达式列表，它等同于重复使用 文本上 前一个非空的表达式列表。考虑以下代码：

package main

import "fmt"

func main() {
    const (
        iota = iota // 1. 声明局部常量 iota = 0
        Y           // 2. 等同于 Y = iota，此处的 iota 指的是第1步声明的局部 iota
    )
    fmt.Println(Y) // 输出 0
}

Go 1.18 之前的版本会错误地输出 1，似乎是将 iota 的递增行为应用到了第二行。Go 1.18 修正了这个 Bug (Issue #49157)，使其行为符合规范描述，输出 0。

类型别名 (type alias) 相关的比较 Bug 修正: Go 1.8 引入类型别名时也引入了一个比较相关的 Bug (Issue #24721)。当通过类型别名定义结构体，即使它们的字段名（在别名层级）不同，其实际底层结构可能相同。在将它们转换为空接口 interface{} 进行比较时，Go 1.17 及之前的版本可能会错误地返回 true。Go 1.18 修复了此问题，现在能正确区分这些类型，返回 false。

package main

import "fmt"

type T struct{}
type S = T // S 是 T 的别名

type A = struct{ T } // 底层是 struct{ T }，字段名为 T
type B = struct{ S } // 底层是 struct{ T }，字段名为 S

func main() {
    var a A
    var b B
    // A 和 B 虽然底层结构都是 { T }，但它们是不同的类型（由别名定义引入）
    // Go 1.18 之前接口比较错误地返回 true
    fmt.Println(interface{}(b) == interface{}(a)) // Go 1.18 输出 false
}

命名类型 (Named Type) 术语回归: 随着泛型的引入，之前在 Go 1.8 中为配合类型别名而被移除的“命名类型”术语在 Go 1.18 的规范中回归。现在，命名类型包括预声明类型、定义的非泛型类型、实例化的泛型类型以及类型参数。

原生模糊测试 (Fuzzing) 支持

Go 1.18 将模糊测试作为标准库和 go 命令的一部分引入。模糊测试是一种自动化的测试技术，它通过向代码提供大量随机或半随机的输入来寻找导致崩溃、失败断言或非预期行为的 Bug。

如何使用：

创建一个 *_test.go 文件。
定义一个以 Fuzz 开头的函数，例如 FuzzMyFunction，它接受 *testing.F 作为参数。
使用 f.Add(...) 添加一些初始的、有代表性的输入值，称为种子语料库 (seed corpus)。这些值应该是你测试函数预期能处理的合法输入。
调用 f.Fuzz(func(t *testing.T, args...) { ... })。这个内部函数是你的实际测试逻辑。它的参数第一个是 *testing.T，其余参数 args... 的类型和数量必须与 f.Add 添加的语料库值的类型和数量一致。模糊测试引擎会自动生成各种变异的 args 来调用这个内部函数。
在内部函数中，编写你的测试逻辑，通常包含一些检查不变量 (invariants) 或预期行为的代码。如果发现问题，调用 t.Fatal 或 t.Error。

运行 Fuzz 测试：

go test -fuzz={FuzzFunctionName} [-fuzztime={duration}]

例如： go test -fuzz=FuzzReverse -fuzztime=10s

简单示例：

假设我们有一个简单的 Reverse 函数，用于反转字符串。

// reverse.go
package main

import "unicode/utf8"

func Reverse(s string) (string, error) {
    if !utf8.ValidString(s) {
        return s, fmt.Errorf("input is not valid UTF-8") // 假设我们增加一个错误检查
    }
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r), nil
}

// reverse_test.go
package main

import (
    "testing"
    "unicode/utf8"
    "fmt"
)

func FuzzReverse(f *testing.F) {
    // 添加种子语料库
    testcases := []string{"Hello, world", " ", "!12345", "你好"}
    for _, tc := range testcases {
        f.Add(tc)
    }
    // 定义 Fuzz 目标函数
    f.Fuzz(func(t *testing.T, orig string) {
        // 调用被测试函数
        rev, err1 := Reverse(orig)
        if err1 != nil {
            // 如果原始输入就是无效UTF-8，那么返回错误是正常的，直接返回
            if !utf8.ValidString(orig) {
                return
            }
            // 否则，不应该出错
            t.Fatalf("Reverse(%q) failed: %v", orig, err1)
        }

        // 检查不变量 1: 再次反转应该得到原始字符串
        doubleRev, err2 := Reverse(rev)
        if err2 != nil {
            // 反转后的字符串应该总是有效的，所以再次反转不应出错
            t.Fatalf("Reverse(Reverse(%q)) failed: %v", orig, err2)
        }
        if orig != doubleRev {
            t.Errorf("Before: %q, after double reverse: %q", orig, doubleRev)
        }

        // 检查不变量 2: 如果原始字符串是有效的 UTF-8，反转后也应该是
        if utf8.ValidString(orig) && !utf8.ValidString(rev) {
            t.Errorf("Reverse produced invalid UTF-8 string %q from valid %q", rev, orig)
        }
    })
}

注意：

模糊测试可能会消耗大量 CPU 和内存。
模糊测试引擎会将能扩大覆盖率的输入保存在 $GOCACHE/fuzz 目录下的缓存中，这个缓存可能会增长得非常大，需要注意磁盘空间。可以使用 go clean -fuzzcache 清理缓存。

`go` 命令的变更与增强

Go 1.18 对 go 命令进行了多项重要调整和功能增强。

go get 的职责变化: 在模块感知模式 (module-aware mode) 下，go get 不再执行构建和安装操作。它的主要职责变成了 调整 go.mod 文件中的依赖项 。实际上，-d 标志（只下载不安装）现在总是隐式启用的。
- 要安装最新版本的可执行文件，应使用 go install example.com/cmd@latest (Go 1.16 引入)。
- 如果你的项目需要支持 Go 1.16 之前的版本，可能需要同时提供 go get (旧版) 和 go install (新版) 的安装说明。
- 在模块根目录之外（没有 go.mod 的地方）运行 go get 会报错。
- 在 GOPATH 模式 (GO111MODULE=off) 下，go get 行为不变，仍然会构建和安装。
go.mod/go.sum 自动更新的抑制: go mod graph, go mod vendor, go mod verify, go mod why 这些子命令不再自动修改 go.mod 和 go.sum 文件。需要更新时，应显式调用 go get, go mod tidy, 或 go mod download。
构建信息嵌入 (Build Information Embedding):
- go 命令现在默认会在构建可执行文件时嵌入更丰富的构建信息。
- 版本控制信息 (Version Control Information): 如果 go 命令在 Git, Mercurial, Fossil 或 Bazaar 仓库中执行，并且主包 (main package) 和其所属的主模块 (main module) 在同一个仓库内，那么当前签出的 修订版本号 (revision) 、 提交时间 (commit time) 以及是否有 未提交或未跟踪的文件 (dirty status) 等信息会被嵌入。可以使用 -buildvcs=false 标志禁用此功能。
- 构建标志等信息: 其他构建相关的设置，如构建标签 (-tags)、编译器/汇编器/链接器标志 (-gcflags, -asmflags, -ldflags)、cgo 是否启用以及相关的 CGO_* 环境变量等也会被嵌入。
- 读取信息: 可以通过以下方式读取这些嵌入的信息：
  - 命令行: go version -m <executable>
  - 运行时 (当前程序): runtime/debug.ReadBuildInfo()
  - 新包 (任意文件): debug/buildinfo.ReadFile(path) (详见后文)
go work 与工作区模式 (Workspace Mode):
- 引入了 go.work 文件和工作区模式，以 简化涉及多个相互依赖的本地模块的开发流程 。
- 当 go 命令在当前目录或父目录中找到 go.work 文件，或者通过 GOWORK 环境变量指定了 go.work 文件时，就会进入工作区模式。
- 在工作区模式下，go 命令使用 go.work 文件来确定模块解析的根（即主模块集合），而不是像以前那样只使用当前目录下的 go.mod 文件。
- go.work 文件示例

go 1.18

use (
    ./tools // 使用当前目录下的 tools 模块
    ./gopls // 使用当前目录下的 gopls 模块
    ../common // 使用上一级目录的 common 模块
)

// 如果需要替换某个依赖为本地版本（即使在 use 的模块中也是如此）
// replace example.com/original/lib => ../local/lib

这使得在一个模块中修改代码后，可以立即在依赖它的另一个本地模块中进行测试，而无需发布版本或复杂的 replace 指令。

go build -asan: go build 支持 -asan 标志，用于与使用地址消毒器 (Address Sanitizer, ASan, 通常是 C/C++ 编译器的 -fsanitize=address 选项) 编译的 C/C++ 代码进行互操作。
//go:build 行: Go 1.17 引入的 //go:build 作为更推荐的构建约束 (build constraints) 语法。由于 Go 1.18 发布意味着 Go 1.16 不再受支持，所有受支持的 Go 版本都理解 //go:build。因此，在 Go 1.18 中，如果 go.mod 文件声明了 go 1.18 或更高版本，go fix 命令现在会自动移除旧的 // +build 行。
gofmt 并行化: gofmt 现在会并发地读取和格式化输入文件，显著提高了在多核 CPU 上的执行速度。

`vet` 工具更新

静态分析工具 vet 进行了更新以更好地支持 Go 1.18 的新特性，尤其是泛型。

泛型支持: vet 现在能够理解并检查泛型代码。它的大致逻辑是：如果将泛型代码中的类型参数替换为其类型集中的某个具体类型后，代码会引发 vet 错误，那么 vet 就会报告这个潜在的错误。

package main

import "fmt"

// vet 会检查到，如果 T 被实例化为 string，"%d" 是错误的格式化指令
func PrintfExample[T ~int | ~string](val T) {
    fmt.Printf("%d\n", val) // vet warning: fmt.Printf format %d has arg val of wrong type string
}

func main() {
    PrintfExample(123)
    PrintfExample("hello") // 运行时会输出 %!d(string=hello)
}

现有检查器的精度改进: copylock, printf, sortslice, testinggoroutine, tests 等检查器的准确性得到了提升，可以覆盖更多的代码模式。这可能导致在现有代码中发现新的警告。例如，printf 检查器现在可以跟踪由字符串常量拼接而成的格式字符串。

package main

import "fmt"

func main() {
    x := 5
    // Go 1.18 的 vet 会警告：fmt.Printf formatting directive %d is being passed to Println
    fmt.Println("%d" + ` is the remainder` + "\n", x%2)
}

go/types 包更新: go/types 包（供静态分析工具使用）增加了大量 API 以支持泛型的类型检查，包括表示类型参数 (TypeParam)、类型集 (Union, Term)、实例化 (Instantiate) 等的结构和函数。同时增加了 Config.GoVersion 字段来指定要遵循的 Go 语言版本。

运行时 (Runtime) 调整

Go 1.18 对运行时，特别是 GC 和内存管理方面，进行了一些重要的内部调整。

GC 触发频率考虑非堆开销 (重点):
- 背景: 传统的 GC 触发（何时开始下一轮 GC）主要基于 堆内存分配量 相对于上次 GC 结束时活跃堆大小的增长比例（由 GOGC 控制）。
- Go 1.18 变更: 现在，GC 在决定何时触发时，除了考虑堆分配，还会将 其他与 GC 相关的、非堆分配的工作量 也纳入考量。其中最重要的就是 栈扫描 (Stack scanning) 的成本。当存在大量 goroutine 或者 goroutine 栈很深时，扫描所有栈以查找指针的 CPU 成本会非常显著。
- 影响: 这意味着，对于那些有大量栈扫描工作的应用程序（例如，大量 goroutine），GC 可能会比以前 更频繁 地运行，因为现在 GC 的“成本”中包含了这部分开销。这可能导致：
  - 应用程序的 CPU 时间中用于 GC 的比例增加。
  - 应用程序的总内存使用量（峰值或平均）可能会降低，因为 GC 更频繁地回收内存。
- 目的: 使 GC 的总开销（CPU 时间）更加 可预测 和平滑，而不是仅仅因为堆分配达到阈值才突然产生大量 GC 工作。
- 调整: 如果这种行为变化对你的应用产生了负面影响（例如，CPU 占用过高），官方建议的调整方法是 调整 GOGC 环境变量的值 。增大 GOGC 会降低 GC 频率，减少 CPU 占用，但可能增加内存使用量。
更积极的内存释放: 运行时向操作系统返还未使用内存的策略变得更加高效和积极。
栈跟踪信息改进: 对于通过寄存器传递的函数参数，如果在生成栈跟踪时其值可能不准确（例如，寄存器可能已被覆盖），Go 1.18 会在该值后面打印一个问号 ?，以提示开发者。
append 扩容策略微调: 内建函数 append 在需要为切片分配新的底层数组时，用于决定新容量的增长公式略有调整，旨在使容量增长的行为更加平滑，减少突变。

编译器与链接器优化

编译器和链接器在 Go 1.18 中也得到了重要的优化和功能扩展。

基于寄存器的调用约定扩展 (重点):
- Go 1.17 在部分 64 位 x86 (amd64) 平台上引入了新的函数调用约定，即通过寄存器而非栈来传递函数参数和返回值。Go 1.18 将这一优化 扩展到了更多平台 :
  - 64 位 ARM (GOARCH=arm64)
  - 64 位 PowerPC (大端 GOARCH=ppc64 和小端 GOARCH=ppc64le)
  - 所有操作系统上的 64 位 x86 (GOARCH=amd64)
- 性能提升: 在这些受支持的平台上，此变更通常能带来 10% 或以上 的性能提升。
- 兼容性: 这个改变不影响任何安全的 Go 代码功能，并且设计上对大多数汇编代码没有影响。
编译器优化:
- 编译器现在可以内联 (inline) 包含 range 循环或带标签的 for 循环的函数。
- 新增 -asan 编译器选项，以支持 go build -asan。
编译器错误信息: 由于支持泛型导致类型检查器被完全重写，一些错误信息的措辞可能与以前不同。Go 团队计划在 Go 1.19 中改进这些信息。
编译速度: 由于泛型相关的编译器内部变化，Go 1.18 的 编译速度可能比 Go 1.17 慢大约 15% 。这不影响编译后代码的执行速度。Go 团队计划在未来版本中改进编译速度。
链接器改进 (重点):
- 链接器现在产生的 重定位 (Relocations) 数量大大减少 。重定位是链接过程中用于确定符号（函数、变量）最终地址的信息。
- 效果: 这使得大多数代码库的 链接速度更快 ，链接时 需要的内存更少 ，并且生成的 二进制文件更小 。
- 工具兼容性: 处理 Go 二进制文件的工具（如调试器、符号分析器）应使用 Go 1.18 的 debug/gosym 包，它可以透明地处理新旧两种格式的二进制文件。
- 新增 -asan 链接器选项，以支持 go build -asan。

新包 `debug/buildinfo`

这个新包提供了一种标准方式来读取由 go build 命令嵌入到可执行文件中的构建信息。

主要功能：

ReadFile(path string) (*BuildInfo, error): 从指定路径的可执行文件中读取构建信息。
BuildInfo 结构体包含了 Go 版本、主模块信息 (Path, Version, Sum)、依赖模块列表 (Deps) 以及详细的构建设置 (Settings)。
Settings 是一个 []BuildSetting 切片，每个 BuildSetting 包含键 (Key) 和值 (Value)，例如：
- vcs.revision: 版本控制系统（如 Git）的修订版号。
- vcs.time: 修订版的时间戳。
- vcs.modified: 是否包含未提交的修改 ("true" 或 "false")。
- -compiler, -ldflags, -tags 等构建时使用的标志。
- CGO_ENABLED 以及相关的 CGO_* 环境变量。

使用示例 (读取自身信息):

package main

import (
    "fmt"
    "runtime/debug"
)

func main() {
    info, ok := debug.ReadBuildInfo()
    if !ok {
        fmt.Println("Failed to read build info")
        return
    }

    fmt.Printf("Go Version: %s\n", info.GoVersion)
    fmt.Printf("Main Module Path: %s\n", info.Path)
    if info.Main.Version != "" && info.Main.Version != "(devel)" {
        fmt.Printf("Main Module Version: %s\n", info.Main.Version)
    }

    fmt.Println("\nBuild Settings:")
    vcsRevision := "N/A"
    vcsTime := "N/A"
    vcsModified := "false"
    for _, setting := range info.Settings {
        fmt.Printf("  %s: %s\n", setting.Key, setting.Value)
        // 单独提取 VCS 信息
        if setting.Key == "vcs.revision" {
            vcsRevision = setting.Value
        }
        if setting.Key == "vcs.time" {
            vcsTime = setting.Value
        }
        if setting.Key == "vcs.modified" {
            vcsModified = setting.Value
        }
    }
    fmt.Printf("\nVCS Revision: %s\n", vcsRevision)
    fmt.Printf("VCS Time: %s\n", vcsTime)
    fmt.Printf("VCS Modified: %s\n", vcsModified)

    /* // 打印依赖信息 (可选)
    fmt.Println("\nDependencies:")
    for _, dep := range info.Deps {
        fmt.Printf("  %s@%s (Sum: %s)\n", dep.Path, dep.Version, dep.Sum)
    }
    */
}

// 构建命令示例 (在 git 仓库中):
// go build -ldflags="-X main.myVersion=1.2.3" main.go
// ./main

Go Version: go1.18
Main Module Path: command-line-arguments

Build Settings:
  -compiler: gc
  -ldflags: -X main.myVersion=1.2.3
  CGO_ENABLED: 1
  CGO_CFLAGS: 
  CGO_CPPFLAGS: 
  CGO_CXXFLAGS: 
  CGO_LDFLAGS: 
  GOARCH: amd64
  GOOS: linux
  GOAMD64: v1

VCS Revision: N/A
VCS Time: N/A
VCS Modified: false

这个包对于需要了解程序构建环境或进行构建产物分析的场景非常有用。

新包 `net/netip`

Go 1.18 引入了一个全新的网络 IP 地址处理包 net/netip，旨在提供比标准库 net 包中 net.IP 类型更优的替代方案。

核心类型:

netip.Addr: 代表一个 IPv4 或 IPv6 地址。
- 优点:
  - 内存高效: 它是一个小的值类型（内部使用一个 uint128 和一个 zone string 指针），相比 net.IP（底层是 []byte 切片）占用内存更少。
  - 不可变 (Immutable): 一旦创建，其值不能被修改，这使得在并发环境或作为 map key 时更安全。
  - 可比较 (Comparable): 支持 == 和 != 运算符，可以用作 map 的键。这是 net.IP 无法做到的。
netip.AddrPort: 代表一个 IP 地址和端口号的组合 (Addr + uint16)。同样是值类型、不可变、可比较。
netip.Prefix: 代表一个 CIDR (无类别域间路由) 网络前缀，例如 192.168.1.0/24。它包含一个网络地址 Addr 和前缀长度（比特数）。同样是值类型、不可变、可比较。

主要功能与优势:

提供了丰富的 解析函数 (ParseAddr, ParseAddrPort, ParsePrefix, 以及对应的 MustParse... 版本) 和 构造函数 (AddrFrom4, AddrFrom16, AddrFromSlice)。
提供了判断地址属性的方法，如 Is4(), Is6(), IsLoopback(), IsPrivate() 等。
Prefix 类型有 Contains(Addr) 方法用于判断地址是否属于该前缀，Masked() 方法获取规范化的网络地址等。
与 net 包集成:
- net.UDPConn 新增了 ReadFromUDPAddrPort, WriteToUDPAddrPort 等方法，它们使用 netip.AddrPort，可以实现 零分配 (allocation-free) 的 UDP 收发。
- net.Resolver 新增 LookupNetIP(network, host) 方法，返回 []netip.Addr。
- 提供了 net.TCPAddr/UDPAddr 与 netip.AddrPort 之间的转换函数 (TCPAddrFromAddrPort, UDPAddrFromAddrPort, TCPAddr.AddrPort, UDPAddr.AddrPort)。

使用示例:

package main

import (
    "fmt"
    "net/netip"
)

func main() {
    // 解析 IP 地址
    addr, err := netip.ParseAddr("198.51.100.1")
    if err != nil {
        panic(err)
    }
    fmt.Printf("Addr: %s, Is IPv4: %t\n", addr, addr.Is4())

    // 解析 IP 和端口
    addrPort, err := netip.ParseAddrPort("[2001:db8::1]:8080")
    if err != nil {
        panic(err)
    }
    fmt.Printf("AddrPort: Addr=%s, Port=%d\n", addrPort.Addr(), addrPort.Port())

    // 作为 map 的 key
    routingTable := make(map[netip.Prefix]netip.Addr)
    p1, _ := netip.ParsePrefix("192.168.0.0/24")
    p2, _ := netip.ParsePrefix("10.0.0.0/8")
    gw1, _ := netip.ParseAddr("192.168.0.1")
    gw2, _ := netip.ParseAddr("10.0.0.1")
    routingTable[p1] = gw1
    routingTable[p2] = gw2

    targetIP, _ := netip.ParseAddr("192.168.0.100")
    for prefix, gateway := range routingTable {
        if prefix.Contains(targetIP) {
            fmt.Printf("Route %s via %s (Prefix: %s)\n", targetIP, gateway, prefix)
            break
        }
    }

    // 比较
    addr1, _ := netip.ParseAddr("127.0.0.1")
    addr2 := netip.AddrFrom4([4]byte{127, 0, 0, 1})
    fmt.Printf("addr1 == addr2: %t\n", addr1 == addr2) // 输出 true
}

Addr: 198.51.100.1, Is IPv4: true
AddrPort: Addr=2001:db8::1, Port=8080
Route 192.168.0.100 via 192.168.0.1 (Prefix: 192.168.0.0/24)
addr1 == addr2: true

net/netip 包为 Go 开发者提供了一套更现代、更高效、更安全的 IP 地址处理工具，建议在新的代码中优先考虑使用。

Go 1.18 相比 Go 1.17 有哪些值得注意的改动？

泛型 (Generics) 终于到来

编译器 Bug 修复与行为变更

原生模糊测试 (Fuzzing) 支持

`go` 命令的变更与增强

`vet` 工具更新

运行时 (Runtime) 调整

编译器与链接器优化

新包 `debug/buildinfo`

新包 `net/netip`

user_zsXbv7Bi

引用和评论

我所理解的 Go 的 GPM 模型

腾讯 tRPC-Go 教学——（5）filter、context 和日志组件

大模型时代，后端程序员如何避免被AI卷死？

Go 1.24 相比 Go 1.23 有哪些值得注意的改动？

Go slice切片使用教程，一次通关！

腾讯 tRPC-Go 教学——（1）搭建服务

不愧是腾讯，面试的质量太高了

Go 1.18 相比 Go 1.17 有哪些值得注意的改动？

泛型 (Generics) 终于到来

编译器 Bug 修复与行为变更

原生模糊测试 (Fuzzing) 支持

go 命令的变更与增强

vet 工具更新

运行时 (Runtime) 调整

编译器与链接器优化

新包 debug/buildinfo

新包 net/netip

user_zsXbv7Bi

引用和评论

我所理解的 Go 的 GPM 模型

腾讯 tRPC-Go 教学——（5）filter、context 和日志组件

大模型时代，后端程序员如何避免被AI卷死？

Go 1.24 相比 Go 1.23 有哪些值得注意的改动？

Go slice切片使用教程，一次通关！

腾讯 tRPC-Go 教学——（1）搭建服务

不愧是腾讯，面试的质量太高了

`go` 命令的变更与增强

`vet` 工具更新

新包 `debug/buildinfo`

新包 `net/netip`