Go匿名函数和闭包

1.匿名函数

匿名函数即没有名字的函数，一般用于只使用一次的函数，或者直接用变量调用的函数。

方法一：

在定义函数时直接调用，此函数只能调用一次。

func main() {
    a := func(n1 int, n2 int) int{
		return n1 + n2
	}(2,3)
	fmt.Println(a)
}

方法二：

将匿名函数赋给一个变量（函数变量），再通过变量调用匿名函数。

func main() {
    a := func(n1 int, n2 int) int{
		return n1+n2
	}
	ans := a(2,3)
	fmt.Println(ans)
}

同理，也可定义全局匿名函数。

var(
	a = func (n1 int, n2 int) int {
		return n1+n2
	}
)

func main() {
	ans := a(2,3)
	fmt.Println(ans)
}

2.闭包

闭包：一个匿名函数和其相关引用环境组成的一个整体。

直接看一个例子：

func AddUpper(a int) func (int) int{
	var n int = 10
	fmt.Println("a =",a)
	return func(x int) int{
		n += x;
		return n
	}
}

func main() {
	f := AddUpper(1)
	fmt.Println("f(1) =",f(1))
	fmt.Println("f(2) =",f(2))
	fmt.Println("f(3) =",f(3))
    ff := AddUpper(2)
	fmt.Println("ff(1) =", ff(4))
	fmt.Println("ff(2) =", ff(5))
	fmt.Println("ff(3) =", ff(6))
}
/*
a = 1
f(1) = 11
f(2) = 13
f(3) = 16
a = 2
ff(1) = 14
ff(2) = 19
ff(3) = 25
*/

由例子可见，下面的代码就是一个闭包

func AddUpper(a int) func (int) int{
	var n int = 10
	fmt.Println("a =",a)
	return func(x int) int{
		n += x;
		return n
	}
}

下面的代码就是闭包中的匿名函数

func(x int) int{
	n += x;
	return n
}

其他的则是相关引用环境

再分析结果可知：

闭包就相当于java中的一个类，每次调用该闭包时（ f := AddUpper(1) ），就新建了一个包的环境。引用环境中的所有变量都储存在包内，以此就可以在保持闭包状态的情况下，调用匿名函数。

其实，闭包也就相当于下面的全局变量+函数，不过使用闭包可以同时维持多个全局变量。

var n int = 10
func AddUpper(x int) int{
		n += x
		return n
}

func main() {
	f := AddUpper(1)
	fmt.Println(f)
}

例：添加后缀

func makeSuffix(suffix string) func(string) string {
	return func(s string) string {
		if !strings.HasSuffix(s, suffix) {
			return s + suffix
		}
		return s
	}
}

func main() {
	f := makeSuffix(".jpg")
	fmt.Println(f("123"))
	fmt.Println(f("123.jpg"))
}