GO语言的匿名函数就是闭包

基本概念

闭包是可以包含自由（未绑定到特定对象）变量的代码块，这些变量不在这个代码块内或者任何全局上下文中定义，而是在定义代码块的环境中定义。要执行的代码块（由于自由变量包含
在代码块中，所以这些自由变量以及它们引用的对象没有被释放）为自由变量提供绑定的计算环境（作用域）。

闭包的价值

闭包的价值在于可以作为函数对象或者匿名函数，对于类型系统而言，这意味着不仅要表示数据还要表示代码。支持闭包的多数语言都将函数作为第一级对象，就是说这些函数可以存储到
变量中作为参数传递给其他函数，最重要的是能够被函数动态创建和返回。

Go语言中的闭包

Go语言中的闭包同样也会引用到函数外的变量。闭包的实现确保只要闭包还被使用，那么被闭包引用的变量会一直存在。例：

// closure.go
package main
import (
    "fmt"
)
func main() {
    var j int = 5
    a := func() func() {
        var i int = 10
        return func() {
            fmt.Printf("i, j: %d, %d\n", i, j)
        }
    }()　　//末尾的括号表明匿名函数被调用，并将返回的函数指针赋给变量a
    a()
    j *= 2
    a()
}
输出：
i, j: 10, 5
i, j: 10, 10

Go语言支持匿名函数，即函数可以像普通变量一样被传递或使用。

闭包是“函数”和“引用环境”组成的整体。

func anonymous(n int) func() {
    return func() {
        n++ //对外部变量加1
        fmt.Println(n)
    }
}
func anonymous2(n int) func() {
    sum := n
    a := func() { //把匿名函数作为值赋给变量a(Go不允许函数嵌套，但你可以利用匿名函数实现函数嵌套)
        fmt.Println(sum + 1) //调用本函数外的变量，这里没有()匿名函数不会马上执行
    }
    return a
}
　　fmt.Println("---------anonymous func--------")
    anony := anonymous(10)
    anony()
    anony1 := anonymous(20)
    anony1()
    /**
    *再次调用anony()函数，结果是12，由此得出以下两点
    * 1、内函数对外函数的变量的修改，是对变量的引用
    * 2、变量被引用后，它所在的函数结束，该变量不会马上销毁
    **/
    anony()
    anony1()
    fmt.Println("---------anonymous2----------")
    an := anonymous2(10)
    an()
    an2 := anonymous2(20)
    an2()
    an()
    an2()
    
	输出：
	---------anonymous func--------
	11
	21
	12
	22
	---------anonymous2----------
	11
	21
	11
	21

闭包函数出现的条件：
1.被嵌套的函数引用到非本函数的外部变量，而且这外部变量不是“全局变量”;
2.嵌套的函数被独立了出来(被父函数返回或赋值变成了独立的个体)，而被引用的变量所在的父函数已结束。
对象是附有行为的数据，而闭包是附有数据的行为。

匿名函数执行

匿名函数最后括号中加参数，匿名函数立即执行，没有括号或括号中为空，则需要传参。例：

fmt.Println("-----------匿名函数的执行----------")
    m, n := func(i, j int) (m, n int) { // x y 为函数返回值
        return j, i
    }(1, 9) // 直接创建匿名函数并执行
    fmt.Println(m, n)
    f := func(i, j int) (result int) { // f 为函数地址
        result = i + j
        return result
    }
    fmt.Println(f(1, 2))
    
输出：
-----------匿名函数的执行----------
9 1
3

错误： expression in go/defer must be function call

go关键字后跟匿名函数报错： expression in go/defer must be function call，在匿名函数后加括号则可。例：

func smtp() error {
    return nil
}
　　go func() {
       err := smtp()
       if err != nil {
           fmt.Printf(err.Error())
       }
   }()

若去掉上面代码中的空括号会报错。
加()封装成表达式。

参考资料：