Golang中的闭包详解_golang闭包

在Golang中，闭包是一个函数和与其相关的引用环境的组合。换句话说，闭包可以访问在其函数外部定义的变量。

闭包的一个常见用途是创建内部函数，即在函数内部定义的函数，而这个内部函数可以访问外部函数的变量。

以下是一个简单的例子：

package main
 
import "fmt"
 
func main() {
    getSqure := getSqureMaker()
    fmt.Println(getSqure(3)) // 输出：9
}
 
func getSqureMaker() func(int) int {
    var number int
    return func(squareNum int) int {
        number = squareNum
        return number * number
    }
}

在这个例子中，getSqureMaker 是一个外部函数，它返回一个闭包。这个闭包就是内部函数，它可以访问外部函数的变量 number。

当你调用 getSqureMaker 时，它返回一个闭包，这个闭包被赋值给 getSqure 变量。当你调用 getSqure(3) 时，闭包被执行，它返回 9，因为 3 * 3 = 9。

注意，虽然 number 是在外部函数中定义的，但它仍然可以在闭包中被访问和修改。这是因为闭包保留了对其外部环境的引用。

闭包还有其他一些用途，例如在并发编程中保护变量的安全。

例如，以下代码创建了一个计数器函数，每次调用返回当前调用的次数：

package main
 
import (
    "fmt"
    "sync"
)
 
func counter() func() int {
    var mu sync.Mutex
    var count int
    return func() int {
        mu.Lock()
        defer mu.Unlock()
        count++
        return count
    }
}
 
func main() {
    nextNumber := counter()
    fmt.Println(nextNumber()) // 输出：1
    fmt.Println(nextNumber()) // 输出：2
    fmt.Println(nextNumber()) // 输出：3
}

在这个例子中，counter 函数返回一个闭包，这个闭包用一个互斥锁保护 count 变量，确保并发访问时 count 的值正确。每次调用闭包，计数器都会递增，并返回当前的值。