Go函数3：匿名函数与闭包

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接收到的返回值（匿名函数），而不需要经过初始化

}