Go 中的闭包如何工作？

Question

Go 中的闭包如何工作？

Accepted Answer

**闭包**是一个函数，它引用其周围作用域中的变量，"关闭"这些变量——即使封闭函数返回后，该函数仍保持对这些变量的访问权限。Go 函数是一级值（first-class values），使得闭包成为一个常见而强大的工具。

## 基本的闭包

```go
func makeCounter() func() int {
    count := 0                  // a local variable
    return func() int {          // this inner function CLOSES OVER count
        count++                  // it can read AND modify count
        return count
    }
}

counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2 — count PERSISTS between calls (state is retained)

other := makeCounter()    // a NEW, independent closure with its own count
fmt.Println(other())     // 1 — separate state
```

返回的函数即使在 `makeCounter` 返回后仍保留对 `count` 的引用——因此状态在多次调用中保持不变。每次调用 `makeCounter` 都会创建一个新的、独立的 `count`。这是封装的私有状态。

## 闭包通过引用捕获变量（关键点）

```go
// closures capture the variable itself, not a snapshot of its value
x := 10
f := func() int { return x }
x = 20
fmt.Println(f())   // 20 — sees the CURRENT value of x, not 10
```

## 经典的循环变量问题

```go
// ⚠️ in Go versions BEFORE 1.22:
funcs := []func(){}
for i := 0; i < 3; i++ {
    funcs = append(funcs, func() { fmt.Println(i) })  // all close over the SAME i
}
for _, f := range funcs { f() }   // prints 3, 3, 3 (not 0, 1, 2)! — all share i

// the classic fix (pre-1.22): make a per-iteration copy
for i := 0; i < 3; i++ {
    i := i                          // shadow with a new variable each iteration
    funcs = append(funcs, func() { fmt.Println(i) })
}
// Note: Go 1.22+ changed loop semantics so each iteration gets a NEW variable — this bug is fixed.
```

这是一个著名的错误：循环中的闭包都捕获了*同一个*循环变量。（Go 1.22 修复了循环变量的作用域问题，但理解这个问题对旧代码和其他捕获的变量仍然很重要。）

## 闭包的常见用途

```go
// 1. as callbacks / handlers
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ... })

// 2. deferred functions capturing local state
defer func() { fmt.Println("cleanup with", localVar) }()

// 3. function factories (configured behavior)
func multiplier(factor int) func(int) int {
    return func(n int) int { return n * factor }
}
double := multiplier(2)   // double(5) → 10
```

## 为什么这很重要

闭包是一个强大的、频繁使用的 Go 特性，由一级函数（first-class functions）启用——它们让你创建能够携带私有、持久状态（计数器、生成器、通过工厂函数配置的行为）的函数，并且对于回调、HTTP 处理器、引用本地变量的延迟清理和函数式编程模式至关重要。

理解闭包通过**引用**（观察当前值、共享状态）而不是通过值来捕获变量这一点至关重要——既可以有效地使用它们（封装的可变状态），也可以避免**经典的循环变量捕获错误**（所有闭包共享一个变量，这是令人困惑的著名来源，虽然在 Go 1.22 中已修复，但对旧代码和非循环捕获仍然适用）。

闭包遍布习惯性 Go 和标准库 API，使其成为重要的实用知识和经常出现的面试话题。