淺析Go語言中閉包的定義與使用

更新時間：2023年09月17日 08:20:36 作者：starrySky

閉包是編程語言中的一個重要概念,它允許函數(shù)不僅僅是獨立的代碼塊,還可以攜帶數(shù)據(jù)和狀態(tài),本文將深入探討閉包的定義、用途和注意事項,以及如何正確使用閉包,有需要的可以參考下

1. 引言

閉包是編程語言中的一個重要概念，它允許函數(shù)不僅僅是獨立的代碼塊，還可以攜帶數(shù)據(jù)和狀態(tài)。閉包的特點是可以捕獲并保持對外部變量的引用，使函數(shù)值具有狀態(tài)和行為，可以在多次調(diào)用之間保留狀態(tài)。

本文將深入探討閉包的定義、用途和注意事項，以及如何正確使用閉包。

2. 什么是閉包

閉包是一個函數(shù)值，它引用了在其外部定義的一個或多個變量。這些變量被稱為自由變量，它們在閉包內(nèi)部被綁定到函數(shù)值，因此閉包可以訪問和操作這些變量，即使在它們的外部函數(shù)已經(jīng)執(zhí)行完畢。

閉包的關(guān)鍵特點是它可以捕獲并保持對外部變量的引用，這使得函數(shù)值具有狀態(tài)和行為，可以在多次調(diào)用之間保留狀態(tài)。因此，閉包允許函數(shù)不僅僅是獨立的代碼塊，還可以攜帶數(shù)據(jù)和狀態(tài)。以下是一個簡單的示例，說明了閉包如何綁定數(shù)據(jù)：

func makeCounter() func() int {
    count := 0 // count 是一個自由變量，被閉包捕獲并綁定
    // 返回一個閉包函數(shù)，它引用并操作 count
    increment := func() int {
        count++
        return count
    }
    return increment
}
func main() {
    counter := makeCounter()
    fmt.Println(counter()) // 輸出 1
    fmt.Println(counter()) // 輸出 2
    fmt.Println(counter()) // 輸出 3
}

在這個示例中，makeCounter 函數(shù)返回一個閉包函數(shù) increment，該閉包函數(shù)引用了外部的自由變量 count。每次調(diào)用 counter 閉包函數(shù)時，它會增加 count 變量的值，并返回新的計數(shù)。這個閉包綁定了自由變量 count，使其具有狀態(tài)，并且可以在多次調(diào)用之間保留計數(shù)的狀態(tài)。這就是閉包如何綁定數(shù)據(jù)的一個示例。

3. 何時使用閉包

閉包最開始的用途是減少全局變量的使用，比如設我們有多個獨立的計數(shù)器，每個計數(shù)器都能夠獨立地計數(shù)，并且不需要使用全局變量。我們可以使用閉包來實現(xiàn)這個目標：

func createCounter() func() int {
   count := 0 // 閉包內(nèi)的局部變量
   // 返回一個閉包函數(shù)，用于增加計數(shù)
   increment := func() int {
       count++
       return count
   }
   return increment
}
func main() {
   counter := createCounter()
   fmt.Println(counter()) // 輸出 1
   fmt.Println(counter()) // 輸出 2
}

在這個示例中，createCounter 函數(shù)返回一個閉包函數(shù) increment，它捕獲了局部變量 count。每次調(diào)用 increment 時，它會增加 count 的值，并返回新的計數(shù)。這里使用閉包隱式傳遞共享變量，而不是依賴全局變量。

但是隱蔽的共享變量，帶來的后果就是不夠清晰，不夠直接。而且相對于在行為上附加數(shù)據(jù)的編程習慣:

func createCounter() func() int {
    count := 0 // 閉包內(nèi)的局部變量
    // 在該行為上附加數(shù)據(jù)，附加了count的數(shù)據(jù)
    increment := func() int {
        count++
        return count
    }
    return increment
}

我們更習慣的是在數(shù)據(jù)上附加行為，也就是傳統(tǒng)面向?qū)ο蟮姆绞?，這種方式相對于閉包更加簡單清晰，更容易理解:

type Counter struct{
    counter int
}
func (c *Counter) increment() int{
    c.count++
    return c.counter
}

因此，如果不是真的有必要，我們還是避免使用閉包這個特性，除非其真的能夠提高代碼的質(zhì)量，更容易維護和開發(fā)，那我們才去使用該特性，這個就需要我們設計時去權(quán)衡。

4. 閉包的使用有什么注意事項

4.1 多個閉包共享同一局部變量

當多個閉包共享同一局部變量時，它們會訪問并修改同一個變量，此時這些閉包對局部變量的修改都是互相影響的，此時需要特別注意，避免出現(xiàn)競態(tài)條件:

func getClosure() (func(),func()){
   localVar := 0 // 局部變量
   // 定義并返回兩個閉包，它們引用同一個局部變量
   closure1 := func() {
      localVar++
      fmt.Printf("Closure 1: %d\n", localVar)
   }
   closure2 := func() {
      localVar += 2
      fmt.Printf("Closure 2: %d\n", localVar)
   }
   return closure1, closure2
}
func main() {
   f, f2 := outer()
   f()
   f2()
}

此時closure1 和 closure2 是會被相互影響的，所以如果遇到這種情況，我們應該考慮使用合適的同步機制，來保證線程安全。

4.2 避免循環(huán)變量陷阱

循環(huán)變量陷阱通常發(fā)生在使用閉包時，閉包捕獲了循環(huán)變量的當前值，而不是在閉包執(zhí)行時的值。比如下面的示例:

package main
import "fmt"
func main() {
    // 創(chuàng)建一個字符串數(shù)組
    names := []string{"Alice", "Bob", "Charlie"}
    // 定義一個存儲閉包的切片
    var greeters []func() string
    // 錯誤的方式（會導致循環(huán)變量陷阱）
    for _, name := range names {
        // 創(chuàng)建閉包，捕獲循環(huán)變量 name
        greeter := func() string {
            return "Hello, " + name + "!"
        }
        greeters = append(greeters, greeter)
    }
    // 調(diào)用閉包
    for _, greeter := range greeters {
        fmt.Println(greeter())
    }
    fmt.Println()
}

在上面的示例中，我們有一個字符串切片 names 和一個存儲閉包的切片 greeters。我們首先嘗試使用錯誤的方式來創(chuàng)建閉包，直接在循環(huán)中捕獲循環(huán)變量 name。這樣做會導致所有的閉包都捕獲了相同的 name 變量，因此最后調(diào)用閉包時，它們都返回相同的結(jié)果，如下:

Hello, Charlie!
Hello, Charlie!
Hello, Charlie!

解決這個問題，可以在循環(huán)內(nèi)部創(chuàng)建一個局部變量，將循環(huán)變量的值賦給局部變量，然后在閉包中引用局部變量。這樣可以確保每個閉包捕獲的是不同的局部變量，而不是共享相同的變量。以下是一個示例說明：

package main
import "fmt"
func main() {
    // 創(chuàng)建一個字符串數(shù)組
    names := []string{"Alice", "Bob", "Charlie"}
    // 定義一個存儲閉包的切片
    var greeters []func() string
    // 正確的方式（使用局部變量）
    for _, name := range names {
        // 創(chuàng)建局部變量，賦值給閉包
        localName := name
        greeter := func() string {
            return "Hello, " + localName + "!"
        }
        greeters = append(greeters, greeter)
    }
    // 再次調(diào)用閉包
    for _, greeter := range greeters {
        fmt.Println(greeter())
    }
}

創(chuàng)建一個局部變量 localName 并將循環(huán)變量的值賦給它，然后在閉包中引用 localName。這確保了每個閉包捕獲的是不同的局部變量，最終可以得到正確的結(jié)果。