Go 版本演进:从 1.0 到 1.26.5

package main

import "fmt"

func main() {
    // goroutine 与 channel
    ch := make(chan string)
    go func() {
        ch <- "Hello, Go 1.0!"
    }()
    fmt.Println(<-ch)
}

// go run -race main.go
package main

import "fmt"

func main() {
    m := make(map[string]int)

    // 竞态检测器可以发现这种并发写入
    go func() {
        m["a"] = 1
    }()
    m["a"] = 2

    fmt.Println(m["a"])
}

type Point struct{ X, Y int }

func (p Point) Distance() float64 {
    return float64(p.X*p.X + p.Y*p.Y)
}

func main() {
    p := Point{3, 4}
    f := p.Distance // 方法值
    println(f())
}

func main() {
    s := []int{0, 1, 2, 3, 4, 5}

    // 三索引切片: s[low:high:max]
    // 容量 = max - low
    t := s[1:3:4] // len=2, cap=3
    println(len(t), cap(t)) // 2 3
}

import "encoding"

// TextMarshaler 和 TextUnmarshaler 接口
var _ encoding.TextMarshaler   = (*myType)(nil)
var _ encoding.TextUnmarshaler = (*myType)(nil)

// 运行时改进，无需代码更改
func main() {
    // 大量 goroutine 现在使用更高效的栈管理
    for i := 0; i < 10000; i++ {
        go func(i int) {
            _ = i
        }(i)
    }
}

//go:generate stringer -type=Pill

package painkiller

type Pill int

const (
    Placebo Pill = iota
    Aspirin
    Ibuprofen
)

func main() {
    // 省略赋值变量
    for range []int{1, 2, 3} {
        println("hello")
    }
}

import "runtime"

func main() {
    // 默认等于 CPU 核心数
    println(runtime.GOMAXPROCS(0))
}

import "net/http"

func main() {
    // HTTP/2 默认启用（当服务端支持时）
    resp, err := http.Get("https://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    // 连接自动使用 HTTP/2
}

import (
    "context"
    "time"
)

func main() {
    // 带超时的 context
    ctx, cancel := context.WithTimeout(
        context.Background(),
        2*time.Second,
    )
    defer cancel()

    // 传递 context
    result := make(chan string)
    go func() {
        // 模拟耗时操作
        time.Sleep(1 * time.Second)
        result <- "done"
    }()

    select {
    case <-ctx.Done():
        println("超时:", ctx.Err())
    case res := <-result:
        println(res)
    }
}

import "testing"

func TestMath(t *testing.T) {
    tests := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {3, 4, 7},
        {0, 0, 0},
    }

    for _, tt := range tests {
        t.Run("加法", func(t *testing.T) {
            got := tt.a + tt.b
            if got != tt.want {
                t.Errorf("got %d, want %d", got, tt.want)
            }
        })
    }
}

import "sort"

func main() {
    s := []int{3, 1, 4, 1, 5}
    sort.Slice(s, func(i, j int) bool {
        return s[i] < s[j]
    })
    // s 变为 [1, 1, 3, 4, 5]
}

import (
    "context"
    "net/http"
    "os/signal"
    "syscall"
)

func main() {
    srv := &http.Server{Addr: ":8080"}

    // 优雅关闭
    ctx, stop := signal.NotifyContext(
        context.Background(),
        syscall.SIGINT, syscall.SIGTERM,
    )
    defer stop()

    go srv.ListenAndServe()
    <-ctx.Done()
    srv.Shutdown(context.Background())
}

package main

// 类型别名：MyInt 和 int 是完全相同的类型
type MyInt = int

func main() {
    var x int = 42
    var y MyInt = x // 不需要转换
    println(y)
}

import "math/bits"

func main() {
    // 统计二进制中 1 的个数
    println(bits.OnesCount8(0x0f)) // 4
    // 前导零计数
    println(bits.LeadingZeros16(0x00ff)) // 8
    // 旋转
    println(bits.RotateLeft8(0b10000001, 1)) // 0b00000011
}

import (
    "time"
)

func main() {
    start := time.Now()
    // ... 耗时操作
    elapsed := time.Since(start) // 使用单调时钟
    _ = elapsed
}

# 构建缓存默认启用
go build
go test -cache         # 查看缓存信息

go test ./...           # 首次运行
go test ./...           # 第二次运行（缓存命中）
go test -count=1 ./...  # 跳过缓存

// go.mod
module example.com/myproject

go 1.11

require (
    golang.org/x/text v0.3.0
)

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, WebAssembly!")
}

GOOS=js GOARCH=wasm go build -o main.wasm main.go

func main() {
    m := map[string]int{"b": 2, "a": 1, "c": 3}
    // Go 1.12 起，fmt.Println 按 key 排序输出 map
    println(m) // 已排序
}

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("not found")

func find(id int) error {
    return fmt.Errorf("查找 id=%d: %w", id, ErrNotFound)
}

func main() {
    err := find(42)
    if errors.Is(err, ErrNotFound) {
        println("匹配到 ErrNotFound")
    }

    // 解包
    unwrapped := errors.Unwrap(err)
    println(unwrapped.Error()) // "not found"
}

func main() {
    // 二进制字面量
    b := 0b1011 // 11

    // 数字分隔符（提升可读性）
    n := 1_000_000 // 一百万

    // 十六进制浮点数
    f := 0x1p-2 // 0.25

    _, _, _ = b, n, f
}

func sum(nums []int) int {
    // Go 1.14 中，defer 的性能开销极低
    defer func() {
        recover()
    }()
    // ... 业务逻辑
    return 0
}

import (
    "runtime"
    "time"
)

func main() {
    // Go 1.14 之前，这个 goroutine 不会让出 CPU
    go func() {
        for {
            // 异步抢占确保调度器可以中断此循环
        }
    }()
    time.Sleep(time.Second)
    println("现在可以到达这里了")
}

# 链接器改进——无缝体验
go build .  # 自动受益

import (
    _ "embed"
    "net/http"
)

//go:embed static/index.html
var indexHTML string

//go:embed static/*.css
var cssFiles embed.FS

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(indexHTML))
    })

    // 使用 embed.FS 提供静态文件
    http.Handle("/static/", http.FileServer(http.FS(cssFiles)))
}

import (
    "io"
    "os"
)

func main() {
    // 替代 ioutil.ReadAll
    data, _ := io.ReadAll(os.Stdin)
    _ = data

    // 替代 ioutil.ReadDir
    entries, _ := os.ReadDir(".")
    _ = entries
}

func main() {
    s := []int{1, 2, 3, 4, 5}

    // 切片转数组指针（如果切片太短会 panic）
    p := (*[3]int)(s)
    println(p[0], p[1], p[2]) // 1 2 3

    // 安全版本：先检查长度
    if len(s) >= 4 {
        p4 := (*[4]int)(s)
        _ = p4
    }
}

//go:build linux && amd64

package mypackage

// 仅在 linux/amd64 下编译

package main

import "fmt"

// 泛型函数：任何可比较类型的切片包含检查
func Contains[T comparable](elems []T, v T) bool {
    for _, e := range elems {
        if e == v {
            return true
        }
    }
    return false
}

// 泛型类型
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    v := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return v, true
}

// 泛型接口约束
type Number interface {
    ~int | ~float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(Contains([]string{"a", "b", "c"}, "b")) // true
    fmt.Println(Contains([]int{1, 2, 3}, 5))            // false

    s := Stack[string]{}
    s.Push("hello")
    s.Push("world")
    fmt.Println(s.Pop()) // world true

    fmt.Println(Sum([]int{1, 2, 3}))       // 6
    fmt.Println(Sum([]float64{1.5, 2.5})) // 4.0
}

import (
    "testing"
    "unicode/utf8"
)

func FuzzReverse(f *testing.F) {
    testcases := []string{"Hello, world", " ", "!12345"}
    for _, tc := range testcases {
        f.Add(tc) // 种子语料库
    }

    f.Fuzz(func(t *testing.T, orig string) {
        rev := ReverseString(orig)
        doubleRev := ReverseString(rev)
        if orig != doubleRev {
            t.Errorf("反转两次不相等: %q -> %q -> %q", orig, rev, doubleRev)
        }
        if !utf8.ValidString(orig) {
            t.Errorf("产生无效 UTF-8: %q", orig)
        }
    })
}

func ReverseString(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

// go.work
go 1.18

use (
    ./myapp
    ./mylib
)

import "net/netip"

func main() {
    ip, err := netip.ParseAddr("192.0.2.1")
    if err == nil {
        println(ip.Is4(), ip.Is6(), ip.String())
    }

    prefix, _ := netip.ParsePrefix("10.0.0.0/8")
    println(prefix.Contains(ip)) // false
}

import "runtime/debug"

func main() {
    // 设置软内存限制：当 GC 堆达到此阈值时更积极回收
    debug.SetMemoryLimit(512 * 1024 * 1024) // 512 MB
}

import "sync/atomic"

func main() {
    var b atomic.Bool
    b.Store(true)
    println(b.Load()) // true

    var c atomic.Int64
    c.Add(42)
    c.CompareAndSwap(42, 100)
    println(c.Load()) // 100

    var p atomic.Pointer[string]
    hello := "hello"
    p.Store(&hello)
    println(*p.Load())
}

// Package example 展示了 Go 1.19 的文档注释改进。
//
// # 这是一个标题
//
// 支持列表:
//   - 项目 1
//   - 项目 2
//
// 链接: [net/http] 或 [自定义链接](https://example.com)
package example

// 这个函数有 [特殊含义].
//
// [特殊含义]: https://example.com
func Foo() {}

# 1. 收集性能分析
go test -bench=. -cpuprofile cpu.pprof

# 2. 使用 PGO 编译（默认查找 default.pgo）
go build -pgo=auto    # 使用 default.pgo（如果有）
go build -pgo=cpu.pprof

import (
    "context"
    "errors"
)

func main() {
    causeErr := errors.New("自定义取消原因")
    ctx, cancel := context.WithCancelCause(context.Background())
    cancel(causeErr)

    // 获取取消原因
    err := context.Cause(ctx)
    println(err.Error()) // "自定义取消原因"
}

import "errors"

func main() {
    err1 := errors.New("错误 1")
    err2 := errors.New("错误 2")

    // 合并多个错误
    combined := errors.Join(err1, err2)
    println(combined.Error())

    // 检查是否包含任一错误
    println(errors.Is(combined, err1)) // true
}

import "strings"

func main() {
    s := "hello world"
    // Clone 返回 s 的一个独立副本
    cloned := strings.Clone(s)
    _ = cloned
}

func main() {
    // min / max
    println(min(3, 7, 2, 9))   // 2
    println(max(3.14, 2.72))   // 3.14
    // 字符串按字典序比较
    println(min("abc", "abd")) // "abc"

    // clear — 清空 map 或切片元素
    m := map[string]int{"a": 1, "b": 2}
    clear(m)
    println(len(m)) // 0

    s := []int{1, 2, 3, 4}
    clear(s) // 将所有元素置零
    println(s[0], s[1], s[2], s[3]) // 0 0 0 0
}

import (
    "cmp"
    "log/slog"
    "maps"
    "slices"
)

func main() {
    // slices 包
    s := []int{3, 1, 4, 1, 5}
    slices.Sort(s)
    println(slices.BinarySearch(s, 4)) // 3 true

    // maps 包
    m1 := map[string]int{"a": 1, "b": 2}
    m2 := map[string]int{"b": 3, "c": 4}
    maps.Copy(m1, m2) // m1: {"a": 1, "b": 3, "c": 4}

    // cmp 包
    r := cmp.Compare(3, 5)
    println(r) // -1

    // log/slog — 结构化日志
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    logger.Info("用户登录", "user", "alice", "ip", "192.168.1.1")
}

GOOS=wasip1 GOARCH=wasm go build -o main.wasm main.go

// Go 1.21 及之前的问题版本
func main() {
    var funcs []func()

    for _, v := range []int{1, 2, 3} {
        // Go 1.21: 所有闭包捕获同一个 v
        // Go 1.22: 每个迭代有独立的 v
        funcs = append(funcs, func() {
            print(v)
        })
    }

    for _, f := range funcs {
        f() // Go 1.22: 1 2 3
    }
}

func main() {
    // 直接迭代整数
    for i := range 5 {
        println(i) // 0 1 2 3 4
    }
}

import "net/http"

func main() {
    mux := http.NewServeMux()

    // 方法路由
    mux.HandleFunc("GET /users", listUsers)
    mux.HandleFunc("POST /users", createUser)
    mux.HandleFunc("PUT /users/{id}", updateUser)
    mux.HandleFunc("DELETE /users/{id}", deleteUser)

    // 路径参数
    mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id") // 获取路径参数
        w.Write([]byte("user: " + id))
    })

    // 通配符
    mux.HandleFunc("GET /files/{path...}", func(w http.ResponseWriter, r *http.Request) {
        path := r.PathValue("path")
        w.Write([]byte("file: " + path))
    })

    http.ListenAndServe(":8080", mux)
}

import (
    mathrand "math/rand/v2"
)

func main() {
    // 简化 API，不再需要 seed
    n := mathrand.IntN(100) // 0-99 随机数
    println(n)

    // 64 位随机
    x := mathrand.Uint64()
    println(x)
}

import "iter"

// 向后迭代切片
func Backward(s []int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(s[i]) {
                return
            }
        }
    }
}

func main() {
    s := []int{1, 2, 3, 4, 5}

    // 使用自定义迭代器
    for v := range Backward(s) {
        println(v) // 5 4 3 2 1
    }
}

// Seq2 示例 — 遍历 map
func MapEntries[K comparable, V any](m map[K]V) iter.Seq2[K, V] {
    return func(yield func(K, V) bool) {
        for k, v := range m {
            if !yield(k, v) {
                return
            }
        }
    }
}

import (
    "iter"
    "unique"
)

// unique 包 — 字符串驻留（interning）
func main() {
    h1 := unique.Make("hello")
    h2 := unique.Make("hello")
    println(h1 == h2)   // true
    println(h1.Value()) // "hello"
}

// structs 包 — 结构体布局控制
import "structs"

type MyStruct struct {
    _ structs.HostLayout // 指示使用 C 结构体布局
    X int64
    Y float64
}

// 无需代码更改，现有 map 自动受益
func main() {
    m := make(map[string]int)
    // 性能提升 10-50%，取决于使用模式
    for i := range 1000000 {
        m["key"+string(rune(i))] = i
    }
}

package main

// 泛型类型别名
type Vector[T any] = []T

func main() {
    v := Vector[int]{1, 2, 3}
    println(v[0]) // 1

    // 带约束的别名
    type OrderedSlice[T cmp.Ordered] = []T
    var s OrderedSlice[int] = []int{3, 1, 2}
    slices.Sort(s)
}

import "encoding/json"

type Config struct {
    Name    string `json:"name,omitzero"`
    Timeout int    `json:"timeout,omitzero"` // 零值时省略
}

func main() {
    c := Config{} // Timeout 为零值
    data, _ := json.Marshal(c)
    println(string(data)) // 不包含 timeout
}

import "crypto/rand"

func main() {
    // 生成安全的随机字符串（Base64 编码，22 字符）
    token, err := rand.Text()
    if err == nil {
        println(token) // 例如 "aB3x...（22字符）"
    }
}

import _ "crypto/tls/fipsonly"

func main() {
    // 启用 FIPS 140-3 模式
    // 只使用经 FIPS 认证的加密实现
}

import "runtime"

func main() {
    // 在 Kubernetes 等容器环境中，
    // 如果 cgroup 限制了 CPU，GOMAXPROCS 自动适配
    println(runtime.GOMAXPROCS(0))
    // 无需手动设置，运行时自动调整
}

# 编译时启用
GOEXPERIMENT=greenteagc go build .

// 目前需要通过 GOEXPERIMENT=jsonv2 启用
// import "encoding/json/v2"

import "runtime/trace"

func main() {
    fr := trace.NewFlightRecorder()
    fr.Start()

    // ... 业务逻辑 ...

    // 发生重要事件时保存最近的 trace 数据
    if true { // 假设发生错误
        snap, _ := fr.Snapshot()
        // 保存快照到文件进行分析
        // snap 包含最近几秒的 trace 数据
        _ = snap
    }

    fr.Stop()
}

import "sync"

func main() {
    var wg sync.WaitGroup

    // 简化 goroutine 创建和计数
    wg.Go(func() {
        // 自动调用 wg.Add(1) 和 wg.Done()
        println("工作中的 goroutine")
    })

    wg.Wait()
}

import (
    "testing"
    "testing/synctest"
)

func TestConcurrent(t *testing.T) {
    synctest.Run(func() {
        // 在隔离的"气泡"中运行
        // 使用虚拟化时间，无需真实等待
        ch := make(chan int)
        go func() {
            ch <- 42
        }()
        result := <-ch
        if result != 42 {
            t.Errorf("expected 42, got %d", result)
        }
    })
}

go doc -http :6060
# 在浏览器中打开 http://localhost:6060

go build -ldflags='-w' .  # DWARF 5 默认启用

# Green Tea GC 默认启用
go build .

# 如需关闭（仅限 1.26）
GOEXPERIMENT=nogreenteagc go build .

// Go 1.26 之前需要辅助函数
func ptr[T any](v T) *T { return &v }

func main() {
    // Go 1.26: 内联创建指针
    p := new(int64(300))
    println(*p) // 300

    // 更加简洁
    config := new(Config{Name: "example", Port: 8080})
    println(config.Name)

    // 与泛型结合
    items := []*int{new(1), new(2), new(3)}
    for _, item := range items {
        println(*item)
    }
}

type Config struct {
    Name string
    Port int
}

import "errors"

type MyError struct {
    Msg  string
    Code int
}

func (e MyError) Error() string { return e.Msg }

func doSomething() error {
    return MyError{"请求失败", 404}
}

func main() {
    err := doSomething()

    // Go 1.26: 编译时安全的泛型版本
    if myErr, ok := errors.AsType[MyError](err); ok {
        println(myErr.Code) // 404
    }

    // 旧的方式
    var target MyError
    if errors.As(err, &target) {
        println(target.Code)
    }
}

// 递归类型约束：支持链式表达式的泛型接口
type Adder[A Adder[A]] interface {
    Add(A) A
}

// 具体实现
type MyInt int

func (m MyInt) Add(other MyInt) MyInt {
    return m + other
}

func main() {
    a := MyInt(5)
    b := a.Add(MyInt(3))
    println(b) // 8
}

import (
    "crypto/hpke"
    "crypto/rand"
)

func main() {
    // 生成密钥对
    sk, pk, _ := hpke.GenerateKey(rand.Reader)

    // 使用 HPKE 加密
    info := []byte("应用程序信息")
    plaintext := []byte("秘密消息")
    ciphertext, _ := hpke.Seal(pk, info, nil, plaintext)

    // 解密
    decrypted, _ := hpke.Open(sk, info, nil, ciphertext)
    println(string(decrypted))
}