閉包在Go語言中是一個能夠訪問并操作其外部作用域變量的函數，即使外部函數已經執行完畢。閉包由函數體和其引用的環境（外部變量）組成，及：閉包 = 函數 + 環境。

閉包的特性：

1. 捕獲外部變量：內部函數可訪問外部作用域的變量
2. 狀態保持：捕獲的變量生命周期延長
3. 隔離性：每次調用外部函數會創建新的閉包實例

示例說明

示例1：

package mainimport ("fmt"
)func Exp(n int) func() int {e := 1 // 閉包環境變量，在多次調用中保持狀態return func() int {temp := e    // 1. 保存當前值（閉包捕獲時的值）e *= n       // 2. 更新環境變量（n來自外部函數參數）return temp  // 3. 返回保存的舊值}
}func main() {grow := Exp(2) // 創建閉包實例，此時：// - n 被固定為2// - e 初始化為1，與閉包綁定// 每次調用grow()時的狀態變化：// 調用1: temp=1 → e=2 → return 1 (2^0)// 調用2: temp=2 → e=4 → return 2 (2^1)// 調用3: temp=4 → e=8 → return 4 (2^2)// ...for i := range 10 {fmt.Printf("2^%d=%d\n", i, grow())}
}

輸出：

2^0=1
2^1=2
2^2=4
2^3=8
2^4=16
2^5=32
2^6=64
2^7=128
2^8=256
2^9=512

內存狀態演變示意圖：

調用次數 | e值  | 返回值 | 對應指數
---------------------------------0    | 1    |   -    | 初始狀態1    | 2    |   1    | 2^02    | 4    |   2    | 2^1 3    | 8    |   4    | 2^2...10   | 1024 | 512    | 2^9

?Exp函數的返回值是一個函數，這里將稱成為grow函數，每將它調用一次，變量e就會以指數級增長一次。grow函數引用了Exp函數的兩個變量：e和n，它們誕生在Exp函數的作用域內，在正常情況下隨著Exp函數的調用結束，這些變量的內存會隨著出棧而被回收。但是由于grow函數引用了它們，所以它們無法被回收，而是逃逸到了堆上，即使Exp函數的生命周期已經結束了，但變量e和n的生命周期并沒有結束，在grow函數內還能直接修改這兩個變量，grow函數就是一個閉包函數。

示例2：帶參數的閉包（函數工廠）

func multiplier(factor int) func(int) int {return func(x int) int {return x * factor // 捕獲外部參數}
}func main() {double := multiplier(2)triple := multiplier(3)fmt.Println(double(5))  // 10 (2*5)fmt.Println(triple(5))  // 15 (3*5)// 修改外部變量factor := 4specialMulti := func(x int) int { return x * factor }factor = 5 // 閉包使用最新的值fmt.Println(specialMulti(10)) // 50 (5*10)
}

具體執行流程：

1. multiplier(2)?返回閉包時，捕獲了 factor=2
2. 當調用?double(5)?時：
   • 閉包接收參數 x=2
   • 執行計算 5 * 2（factor的值）
   • 返回結果10

后面的修改外部變量關鍵作用點：

1. 延遲綁定：閉包在調用時（而非定義時）獲取變量的當前值
2. 動態更新：展示閉包捕獲的變量可以響應外部修改
3. 引用捕獲：驗證Go的閉包捕獲的是變量引用，而非值拷貝

內存狀態變化示意圖：

初始狀態：
factor = 4
specialMulti閉包 → 指向factor的內存地址修改后：
factor = 5
specialMulti閉包 → 仍然指向同一個內存地址調用時計算：
10 * 5 = 50

示例3：狀態隔離（并發安全）

func main() {var wg sync.WaitGroup  // 1. 創建等待組for i := 0; i < 3; i++ {wg.Add(1)  // 2. 每次循環增加計數器go func(id int) {  // 3. 啟動goroutinedefer wg.Done()  // 5. 任務完成時減少計數器fmt.Printf("Goroutine %d\n", id)}(i)  // 4. 傳遞當前i的副本}wg.Wait()  // 6. 阻塞直到計數器歸零
}

輸出（可能順序不同）：

Goroutine 0
Goroutine 1
Goroutine 2

關鍵機制說明：

1.WaitGroup 三部曲：

• Add(1)：在啟動每個goroutine前增加計數器
• Done()：在每個goroutine完成時減少計數器（通過defer確保執行）
• Wait()：主goroutine阻塞等待所有任務完成

2.閉包參數傳遞：

go func(id int) { ... }(i)  // 傳遞i的當前值副本

?3.并發執行流程：

主goroutine        Goroutine 0      Goroutine 1      Goroutine 2
│─啟動循環─────────┐
│ wg.Add(1)       ├─→ 執行任務
│ 啟動goroutine 0─┤
│ wg.Add(1)       ├─────────────→ 執行任務
│ 啟動goroutine 1─┤
│ wg.Add(1)       ├───────────────────────────→ 執行任務
│ 啟動goroutine 2─┤
│ wg.Wait()───────┼─────────────────────────────────────┤
│                 │←───────────────────── Done() ───────┘

常見陷阱與解決方案

陷阱：循環變量捕獲

func main() {var funcs []func()for i := 0; i < 3; i++ {funcs = append(funcs, func() {fmt.Println(i) // 總是輸出3！})}for _, f := range funcs {f()}
}

輸出：

3
3
3

原因： 所有閉包共享同一個i的引用

解決方案1：參數傳遞

for i := 0; i < 3; i++ {j := i // 創建新變量funcs = append(funcs, func() {fmt.Println(j) // 正確輸出0,1,2})
}

解決方案2：立即執行

for i := 0; i < 3; i++ {func(i int) { // 參數隔離funcs = append(funcs, func() {fmt.Println(i)})}(i)
}

閉包的實際應用場景

1. 狀態封裝：私有計數器/計時器
2. 中間件：Web請求處理鏈

      func loggingMiddleware(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {log.Println(r.URL.Path)next.ServeHTTP(w, r)})}

3. 資源管理：文件操作自動關閉

      func readFile(name string) func() ([]byte, error) {f, err := os.Open(name)return func() ([]byte, error) {defer f.Close() // 捕獲文件句柄return io.ReadAll(f)}}

4. 函數柯里化：參數分解

      func add(a int) func(int) int {return func(b int) int {return a + b}}