基本介紹

閉包(Closure)是Go語言中一個重要的特性，它允許函數(shù)訪問并操作其外部作用域中的變量。閉包在Go中廣泛用于實現(xiàn)函數(shù)式編程模式、狀態(tài)保持和回調等場景。

基本概念

閉包是一個函數(shù)值，它引用了函數(shù)體之外的變量。這個函數(shù)可以訪問并修改這些外部變量，也就是說函數(shù)"綁定"了這些變量。這個函數(shù)和這些變量共同組成閉包。

閉包示例

func main() {x := 10// 這是一個閉包，它捕獲了外部變量xadd := func(y int) int {return x + y}fmt.Println(add(5)) // 輸出15x = 20fmt.Println(add(5)) // 輸出25，閉包能看到x的變化
}

閉包的核心特性

1、變量捕獲：閉包可以捕獲并持有外部作用域的變量。

2、狀態(tài)保持：被捕獲的變量在閉包調用間保持其狀態(tài)。

3、獨立實例：每次創(chuàng)建閉包都會生成一個新的獨立環(huán)境。

閉包的典型使用場景

1. 計數(shù)器/生成器模式

counter代碼解析：定義了一個名為counter的函數(shù)，沒有參數(shù)，返回值為fun() int。

func counter() func() int {i := 0return func() int {i++return i}
}func main() {c1 := counter()fmt.Println(c1()) // 1fmt.Println(c1()) // 2c2 := counter()fmt.Println(c2()) // 1 (新的實例)
}

2. 函數(shù)工廠

兩個實例，兩個閉包的string不相互影響。

func makeGreeter(prefix string) func(string) string {return func(name string) string {return prefix + ", " + name}
}func main() {hello := makeGreeter("Hello")hi := makeGreeter("Hi")fmt.Println(hello("Alice")) // Hello, Alicefmt.Println(hi("Bob"))      // Hi, Bob
}

3.中間件模式

func loggerMiddleware(next http.HandlerFunc) http.HandlerFunc {return func(w http.ResponseWriter, r *http.Request) {start := time.Now()next(w, r)log.Printf("%s %s took %v", r.Method, r.URL.Path, time.Since(start))}
}

閉包捕獲的外部變量存儲位置

在Go語言中，被閉包函數(shù)捕獲的外部變量存儲在堆(heap)上，而不是棧(stack)上。這是Go閉包實現(xiàn)的一個重要特性。

存儲機制詳解

Go編譯器會進行逃逸分析，確定變量的存儲位置。當變量被閉包引用時，編譯器會判定它"逃逸"到了堆上。這是為了保證變量的生命周期能夠延長到閉包的使用期。
編譯器會將被捕獲的變量和閉包函數(shù)打包成一個結構體，這個結構體會分配在堆內存中閉包函數(shù)通過這個結構體來訪問被捕獲的變量。

被閉包捕獲的外部變量的修改影響范圍

被閉包捕獲的外部變量的修改是否會影響所有實例，取決于閉包的創(chuàng)建方式。具體分為兩種情況：
1、多個閉包共享同一個外部變量（會影響）。
2、每次調用生成獨立的閉包實例（不會影響）。

1. 多個閉包共享同一個外部變量（會影響）

當多個閉包捕獲的是同一個外部變量時，修改該變量會影響所有相關的閉包實例。

func main() {var i int = 0// 兩個閉包捕獲同一個i變量incr := func() { i++ }get := func() int { return i }fmt.Println(get()) // 0incr()fmt.Println(get()) // 1 (兩個閉包看到的是同一個i)
}

2. 每次調用生成獨立的閉包實例（不會影響）

當每次函數(shù)調用都創(chuàng)建新的變量和閉包時，各個閉包實例擁有自己的變量副本，互不影響。

func counter() func() int {i := 0 // 每次調用counter()都會創(chuàng)建新的ireturn func() int {i++return i}
}func main() {c1 := counter() // 有自己的ic2 := counter() // 有另一個獨立的ifmt.Println(c1()) // 1 (c1的i)fmt.Println(c1()) // 2fmt.Println(c2()) // 1 (c2的i，不受c1影響)fmt.Println(c1()) // 3 (c1的i繼續(xù)獨立遞增)
}

3.關鍵區(qū)分點

情況	變量聲明位置	影響范圍	示例
共享變量	閉包外部聲明	所有閉包實例共享	多個閉包捕獲同一個包級/函數(shù)級變量
獨立變量	閉包創(chuàng)建函數(shù)內部	每個閉包實例獨立	像counter()工廠函數(shù)那樣每次創(chuàng)建新變量

閉包底層原理

Go的閉包實現(xiàn)基于以下幾點：

1、閉包函數(shù)會持有對外部變量的引用。

2、編譯器會將閉包和它引用的外部變量打包成一個結構體。

3、當閉包被調用時，它會通過這個結構體訪問外部變量。

底層實現(xiàn)示例（概念模型）：

// 編譯器生成的類似結構（實際實現(xiàn)更復雜）
type closureStruct struct {i int  // 被捕獲的變量// 可能還有其他捕獲的變量
}func counter() func() int {c := &closureStruct{i: 0}  // 分配在堆上return func() int {c.i++return c.i}
}

注意事項

1. 循環(huán)中的閉包陷阱

func main() {var funcs []func()for i := 0; i < 3; i++ {// 錯誤寫法：所有閉包共享同一個ifuncs = append(funcs, func() { fmt.Println(i) })}for _, f := range funcs {f() // 全部輸出3，不是預期的0,1,2}// 正確寫法1：通過參數(shù)傳遞for i := 0; i < 3; i++ {i := i // 創(chuàng)建局部變量副本funcs = append(funcs, func() { fmt.Println(i) })}// 正確寫法2：立即執(zhí)行for i := 0; i < 3; i++ {func(i int) {funcs = append(funcs, func() { fmt.Println(i) })}(i)}
}

2. 并發(fā)安全問題

當多個goroutine訪問同一個閉包變量時，需要加鎖：

func safeCounter() func() int {var i intvar mu sync.Mutexreturn func() int {mu.Lock()defer mu.Unlock()i++return i}
}

3. 性能

閉包會延長被捕獲變量的生命周期，可能導致內存占用增加，在性能敏感的場景需要謹慎使用。