Go のクロージャはどのように機能しますか?

Question

Accepted Answer

**クロージャ** は、周囲のスコープから変数を参照する関数です。外側の関数から戻った後でも、その変数へのアクセスを保持します。Go の関数はファーストクラス値であるため、クロージャは一般的で強力なツールです。

## 基本的なクロージャ

```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 の機能です。プライベートで永続的な状態 (カウンタ、ジェネレータ、ファクトリ関数による設定動作) を持つ関数を作成でき、コールバック、HTTP ハンドラ、ローカル変数を参照する遅延クリーンアップ、および関数型パターンに不可欠です。

クロージャが変数を **参照で** 捕捉する (現在の値を見る、状態を共有する) ことを理解することは、値ではなく — 効果的に使用するため (カプセル化された可変状態) と **クラシックなループ変数捕捉バグ** (すべてのクロージャが 1 つの変数を共有する、有名な混乱の原因で、Go 1.22 で修正されましたが、古いコードと非ループキャプチャに関連) を回避するため — の両方で重要です。

クロージャはイディオマティックな Go と標準ライブラリ API 全体に現れるため、重要な実践的知識であり、インタビューで繰り返し出題されるトピックです。