【Go函数详解】三、匿名函数和闭包

---

一、匿名函数的定义与使用

匿名函数时一种没有指定函数名的函数声明方式（与之相对的，有名字的函数被称为具名函数），在很多编程语言中都有实现和支持。

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

Go匿名函数也可以赋值给一个变量或者直接执行：

// 1、将匿名函数赋值给变量
add := func(a, b int) int {
    return a + b
}

// 调用匿名函数 add
fmt.Println(add(1, 2))  

// 2、定义时直接调用匿名函数
func(a, b int) {
    fmt.Println(a + b)
} (1, 2) 

为什么可以将匿名函数赋值给一个普通变量呢？以下解析

二、匿名函数与闭包

回答上面的问题需要了解闭包

1. 闭包概念

闭包（Closure）是指一个函数包含了它外部作用域中的变量，即使在外部作用域结束后，这些变量依然可以被内部函数访问和修改。闭包使得函数可以“记住”外部作用域的状态，这种状态在函数调用之间是保持的。
闭包的核心概念是函数内部可以引用外部作用域的变量，即使在函数内部外部作用域已经结束。
简单来说，【闭】的意思是【封闭外部状态】，即使外部状态已经失效，闭包内部依然保留了一份从外部引用的变量。

2. 闭包特点

1. 函数可以在定义的作用域之外被调用，仍然可以访问外部作用域的变量。
2. 外部作用域中的变量不会被销毁，直到闭包不再引用它们。
3. 多个闭包可以共享同一个外部作用域的变量。

3. 闭包的实现原理

Go语言中的闭包是通过函数值（Function Value） 实现的。在Go语言中，函数不仅是代码，还是数据，可以像其他类型的值一样被传递、赋值和操作。当一个函数内部引用了外部作用域的变量时，Go编译器会生成一个闭包实例，将外部变量的引用与函数代码绑定在一起。

基本闭包

func makeCounter() func() int {
    count := 0
    return func() int {	//若这里是非匿名函数，那编译报错
        count++
        return count
    }
}

counter := makeCounter()
fmt.Println(counter()) // 输出 1
fmt.Println(counter()) // 输出 2

makeCounter 函数返回一个匿名函数，这个匿名函数持有了外部变量 count 的引用。每次调用 counter() 时，都会访问和修改外部作用域的 count 变量。

闭包是一种函数对象，可以持有外部变量的状态。支持闭包的语言将函数视为第一类对象，使得函数具有与其他数据类型（整型、字符串、数组、切片、字典、结构体等）相同的地位，可以赋值给变量，也可以作为参数传递给其他函数，还能在运行时被函数动态地创建和返回。

4. 闭包的注意事项

4.1 内存泄漏

由于闭包持有外部作用域的变量引用，如果闭包一直被引用，外部作用域的变量不会被销毁，可能会导致内存泄漏。在使用闭包时，需要注意外部作用域变量的生命周期

4.2 竞态条件

在并发编程中，由于多个goroutine可以共享闭包中的变量，可能会引发竞态条件和数据不一致问题。在并发场景下使用闭包时，需要保证变量的访问是安全的。

三、匿名函数的常见使用场景

1. 保证局部变量的安全性

匿名函数内部声明的局部变量无法从外部修改，从而确保了安全性（类似类的私有属性）：

var j int = 1

f := func() {
    var i int = 1
    fmt.Printf("i, j: %d, %d\n", i, j)
}

f()  //i, j: 1, 1
j += 2
f()  //i, j: 1, 3

在上面的示例中，匿名函数引用了外部变量，所以同时也是个闭包，变量 f 指向的闭包引用了局部变量 i 和 j，i 在闭包内部定义，其值被隔离，不能从外部修改，而变量 j 在闭包外部定义，所以可以从外部修改，闭包持有的是它的引用。

2. 将匿名函数作为函数参数

匿名函数除了可以赋值给普通变量外，还可以作为参数传递到函数中进行调用，就像普通数据类型一样：

add := func(a, b int) int {
    return a + b
}

// 将函数类型作为参数
func(call func(int, int) int) {
    fmt.Println(call(1, 2))
}(add)

当我们将函数声明数据类型时，需要严格指定每个参数和返回值的类型，这才是一个完整的函数类型，因此 add 函数对应的函数类型是 func(int, int) int。

也可以将第二个匿名函数提取到 main 函数外，成为一个具名函数 handleAdd，然后定义不同的加法算法实现函数，并将其作为参数传入 handleAdd：

func main() {
    ...

    // 普通的加法操作
    add1 := func(a, b int) int {
        return a + b
    }

    // 定义多种加法算法
    base := 10
    add2 := func(a, b int) int {
        return a * base + b
    }

    handleAdd(1, 2, add1)  // 3
    handleAdd(1, 2, add2)  // 12
}

// 将匿名函数作为参数
func handleAdd(a, b int, call func(int, int) int) {
    fmt.Println(call(a, b))
}

就可以通过一个函数执行多种不同加法实现算法，提升了代码的复用性。

3. 将匿名函数作为函数返回值

// 将函数作为返回值类型
func deferAdd(a, b int) func() int {
    return func() int {
        return a + b
    }
}

func main() {
    ...

    // 此时返回的是匿名函数
    addFunc := deferAdd(1, 2)
    // 这里才会真正执行加法操作
    fmt.Println(addFunc())
}

在上面这个示例代码中，调用 deferAdd 函数返回的是一个匿名函数，但是这个匿名函数引用了外部函数传入的参数，因此形成闭包，只要这个闭包存在，这些持有的参数变量就一直存在，即使脱离了 deferAdd 函数的作用域，依然可以访问它们。
另外调用 deferAdd 方法时并没有执行闭包，只有运行 addFunc() 时才会真正执行闭包中的业务逻辑（这里是加法运算），因此，我们可以通过将函数返回值声明为函数类型来实现业务逻辑的延迟执行，让执行时机完全掌握在开发者手中。