1
// Go 1.21 及之前版本的问题代码
2
func main() {
3
    var funcs []func()
4

5
    for i := 0; i < 3; i++ {
6
        funcs = append(funcs, func() {
7
            fmt.Println("i =", i)  // 闭包捕获 i
8
        })
9
    }
10

11
    for _, f := range funcs {
12
        f()  // 输出什么？
13
    }
14
}

1
i = 3
2
i = 3
3
i = 3

1
// Go 1.21 编译器的视角
2
// for i := 0; i < 3; i++ { ... }
3
// 实际等价于：
4

5
i := 0      // 只创建一次
6
for ; i < 3; i++ {
7
    // i 是循环外定义的变量，所有闭包共享
8
    funcs = append(funcs, func() {
9
        fmt.Println("i =", i)  // 捕获的是同一个 i
10
    })
11
}

1
// 解决方案1：显式创建局部变量
2
for i := 0; i < 3; i++ {
3
    i := i  // 创建新的局部变量
4
    funcs = append(funcs, func() {
5
        fmt.Println("i =", i)
6
    })
7
}
8

9
// 解决方案2：闭包参数
10
for i := 0; i < 3; i++ {
11
    i := i
12
    funcs = append(funcs, func(i int) func() {
13
        return func() {
14
            fmt.Println("i =", i)
15
        }
16
    }(i))
17
}
18

19
// 解决方案3：使用 goroutine
20
for i := 0; i < 3; i++ {
21
    go func(i int) {
22
        fmt.Println("i =", i)
23
    }(i)
24
}

1
// Go 1.22+
2
func main() {
3
    var funcs []func()
4

5
    for i := 0; i < 3; i++ {
6
        funcs = append(funcs, func() {
7
            fmt.Println("i =", i)  // 每个闭包捕获的是不同的 i
8
        })
9
    }
10

11
    for _, f := range funcs {
12
        f()  // 现在输出 0, 1, 2
13
    }
14
}

1
i = 0
2
i = 1
3
i = 2

1
// Go 1.22 编译器的视角
2
// for i := 0; i < 3; i++ { ... }
3
// 现在等价于：
4
// 源码参考：https://github.com/golang/go/blob/go1.22.0/src/cmd/compile/internal/walk/range.go
5

6
for i := 0; i < 3; i++ {
7
    i := i  // 编译器自动在每次迭代创建新变量
8
    // ... 使用新的 i
9
}

1
// 同样适用于 range
2
func main() {
3
    var funcs []func()
4

5
    // 旧写法仍然有效，但不需要额外声明变量
6
    for _, v := range []int{10, 20, 30} {
7
        funcs = append(funcs, func() {
8
            fmt.Println("v =", v)  // Go 1.22+ 正常工作
9
        })
10
    }
11

12
    for _, f := range funcs {
13
        f()  // 输出 10, 20, 30
14
    }
15
}

1
// Go 1.23 支持直接对函数使用 range
2
func main() {
3
    // 模拟生成器
4
    gen := func(yield func(int) bool) {
5
        for i := 0; i < 5; i++ {
6
            if !yield(i) {
7
                return
8
            }
9
        }
10
    }
11

12
    for v := range gen {
13
        fmt.Println(v)  // 0, 1, 2, 3, 4
14
    }
15
}

1
import "iter"
2

3
func main() {
4
    seq := slices.Values([]int{1, 2, 3})
5

6
    for v := range seq {
7
        fmt.Println(v)
8
    }
9
}

1
// 旧代码（已经处理过）
2
for i := 0; i < 3; i++ {
3
    i := i  // 显式创建局部变量
4
    funcs = append(funcs, func() {
5
        fmt.Println("i =", i)
6
    })
7
}
8
// 在 Go 1.22 下仍然正确，只是多创建了一个不必要的变量

1
// 如果你在维护一个 Go 1.21 或更早版本的代码库
2
// 可以逐步迁移：
3

4
// 步骤1：识别所有可能的闭包陷阱
5
// 使用 go vet 检查
6
go vet ./...
7

8
// 步骤2：可选地删除冗余的变量声明
9
// 旧的 i := i 可以简化为直接使用 i
10

11
// 步骤3：测试！确保行为正确
12
go test ./...

1
// 如果你需要同时支持 Go 1.21 和 1.22
2
// 最安全的做法是保持显式变量声明
3

4
// 这段代码在 Go 1.21 和 1.22 下行为一致
5
for i := 0; i < 3; i++ {
6
    i := i  // 两种版本都兼容
7
    funcs = append(funcs, func() {
8
        fmt.Println("i =", i)
9
    })
10
}

1
import (
2
    "math/rand/v2"
3
)
4

5
func main() {
6
    // 新的随机数 API
7
    fmt.Println(rand.Int(rand.NewSource(42)))  // 种子
8
    fmt.Println(rand.N(100))                   // 0-99 随机
9
    fmt.Println(rand.Float[float64]())        // 0.0-1.0
10
}

1
import "slices"
2

3
func main() {
4
    // slices.Concat - 合并多个切片
5
    a := []int{1, 2}
6
    b := []int{3, 4}
7
    c := slices.Concat(a, b)  // []int{1, 2, 3, 4}
8

9
    // slices.Index - 查找元素
10
    idx := slices.Index(c, 3)  // 2
11

12
    // maps.DeleteFunc - 按条件删除
13
    m := map[string]int{"a": 1, "b": 2, "c": 3}
14
    maps.DeleteFunc(m, func(k string, v int) bool {
15
        return v < 2
16
    })  // m 现在只有 "b" 和 "c"
17
}

1
import (
2
    "net/http"
3
)
4

5
func main() {
6
    mux := http.NewServeMux()
7

8
    // Go 1.22 支持新的路由模式
9
    mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
10
        id := r.PathValue("id")
11
        w.Write([]byte("User: " + id))
12
    })
13

14
    mux.HandleFunc("GET /articles/{category}/{id}", func(w http.ResponseWriter, r *http.Request) {
15
        cat := r.PathValue("category")
16
        id := r.PathValue("id")
17
        w.Write([]byte("Article: " + cat + "/" + id))
18
    })
19

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

1
// Go 1.22+ 项目可以更自然地写并发代码
2
func ProcessItems(items []Item) error {
3
    var wg sync.WaitGroup
4
    errCh := make(chan error, len(items))
5

6
    for _, item := range items {
7
        wg.Add(1)
8
        go func(item Item) {
9
            defer wg.Done()
10
            if err := process(item); err != nil {
11
                errCh <- err
12
            }
13
        }(item)  // 仍然建议传递参数，避免混淆
14
    }
15

16
    wg.Wait()
17
    close(errCh)
18

19
    for err := range errCh {
20
        return err
21
    }
22
    return nil
23
}

1
// 迁移检查清单
2
// 1. 搜索所有 for 循环内的闭包
3
grep -r "func()" --include="*.go" .
4

5
// 2. 检查是否依赖循环变量的值
6
// 3. 运行测试
7
go test ./...
8

9
// 4. (可选) 简化代码，删除冗余的 i := i

1
// 建议：即使在 Go 1.22+ 中，对于复杂的闭包，仍然显式传递参数
2
// 这样代码意图更清晰
3

4
// 推荐：传递参数
5
for _, req := range requests {
6
    go func(req Request) {
7
        client.Do(req)
8
    }(req)  // 显式传递
9
}
10

11
//  可接受：依赖新语义
12
for _, req := range requests {
13
    go func() {
14
        client.Do(req)  // Go 1.22+ 没问题
15
    }()
16
}