1.匿名函数顾名思义，是一个没有名字的函数。
2.匿名函数实现了闭包的功能。
3.所有的匿名函数都是闭包

一.匿名函数

1.1声明调用：

package main
import "fmt"
func main(){
    i := 1
    //声明f为一个匿名函数，实现i++的功能。
    f := func(){
        i++
        fmt.Println(i)
    }
    //调用f
    f()
}
//输出：2

1.2直接调用（末尾加括号）

package main
import "fmt"
func main(){
    i := 1
    //匿名函数定义，实现i++的功能。
    func(){
        i++
        fmt.Println(i)
    }()                //此处加上()会直接被调用
}
//输出：2

1.3指定别名调用

package main
import "fmt"
func main(){
    i := 1
    //匿名函数定义，实现i++的功能。
    f := func(){
        i++
        fmt.Println(i)
    }
    type f_func func()    //设定别名
    var f1 f_func        //声明f1为f_func类型
    f1 = f                //初始化
    f1()
}
//输出：2

1.4带参数的匿名函数

package main
import "fmt"
func main(){
    func(a,b int){
        var sum int 
        sum = a+b
        fmt.Println(sum)
    }(3,9)                //传入值，并调用此匿名函数
}
//输出：12

1.5带参数和返回值的匿名函数

package main
import "fmt"
func main(){
    //定义一个匿名函数，用x，y接收两个返回值
    x,y := func(a,b int) (max,min int){
        if a>b{
            max = a
            min = b
        }else{
            max = b
            min = a
        }
        return 
    }(34,453)
    fmt.Println(x, y)
}
//输出：453，34

二.闭包

2.1常规函数的缺陷

如果需要实现一个自增的函数，通常的设计是建立一个自增函数，并调用n次，实现n次自增，如下：

package main
import "fmt"
func add1() int{
    var x int = 1        //由于x不是全局变量
    x++                    //所以每次调用都会被初始化
    return x            //因此，此函数不能实现自增
}
func main(){
    fmt.Println(add())
    fmt.Println(add())
    fmt.Println(add())
}
//输出：2，2，2

如果要实现自增，其实也不是难事，只需把x设置为全局变量即可。但本着能尽量缩小变量作用于的原则，可以用匿名函数实现这个功能。
闭包的关系比较绕，但并不难理解。

2.2闭包实现自增

package main
import "fmt"
func add() func()int{//返回一个匿名函数类型：func()int
    var x int = 1
    return func()int{    //返回一个匿名函数
        x++
        return x
    }
}
func main(){
    add1 := add()        //此时add1接收到add的返回值[func()int]，并把x初始化为1
    fmt.Println(add1())    //调用add1，即直接调用[func()int],而不需要经过初始化，实现+1
    fmt.Println(add1())    //再次调用add1，即直接调用[func()int],再次+1，而不需要经过初始化
    add2 := add()         //add2接收到add的返回值[func()int]，并初始化为1
    fmt.Println(add2())    //直接调用add2接收到的返回值（匿名函数），而不需要经过初始化
}