golang学习笔记13-函数（二）：init函数，匿名函数，闭包，defer

注：本人已有C，C++,Python基础，只写本人认为的重点。
这个知识点基本属于go的特性，比较重要，需要认真分析。

一、init函数

每个文件都可以定义init函数，它会在main函数执行前被调用，无论它的定义位置是在main后还是前。而全局变量的优先级又高于init，所以优先级是这样的：全局变量>init>main。示例如下：

package mainimport "fmt"var a = test()func test() int {fmt.Println("test已执行")return 1
}func init() {fmt.Println("init已执行")
}func main() {fmt.Println("main已执行")
}

上述程序的输出是：

test已执行
init已执行
main已执行

当多个文件存在init时，比如main所依赖的包中也有init，结果会怎样呢？假设main和依赖的包testutils内容如下：
main

package mainimport ("fmt""mod05/demo07/testutils"
)var a = test()func test() int {fmt.Println("test已执行")return 1
}func init() {fmt.Println("main中的init已执行")
}func main() {fmt.Println("main已执行")fmt.Println("age=", testutils.Age, "sex=",testutils.Sex, "name=", testutils.Name)
}

testutils

package testutilsimport "fmt"var Age int
var Sex string
var Name stringfunc init() {fmt.Println("testutils中的init已执行")Age, Sex, Name = 19, "女", "张三"
}

则程序运行结果为

testutils中的init已执行
test已执行
main中的init已执行
main已执行
age= 19 sex= 女 name= 张三

显然，导入的包先执行，然后main中的test执行前先初始化全局变量，再执行test，最后执行init和main。所以顺序是：utils的全局变量->utils的init->main文件的全局变量>main文件的init->main文件的main函数。
总结下init的优先级：文件之间，被导包>当前包，文件内，全局变量>init>main。

二、匿名函数

相对于C++和python的匿名函数，go的匿名函数就简单很多了，就是在函数定义前用一个变量接收，示例如下：

package mainimport "fmt"func main() {//定义匿名函数：定义的同时调用result := func(num1 int, num2 int) int {return num1 + num2}(10, 20)fmt.Println(result)//将匿名函数赋给一个变量，这个变量实际就是函数类型的变量//sub等价于匿名函数sub := func(num1 int, num2 int) int {return num1 - num2}//直接调用sub就是调用这个匿名函数了result01 := sub(30, 70)fmt.Println(result01)result02 := sub(30, 70)fmt.Println(result02)
}

需要注意的是，匿名函数定义后如果不用括号，那么这个变量就是匿名函数本身，如果用括号就是调用一次匿名函数，得到的是这个匿名函数的返回值，这个要好好理解，后面会有相关练习。

三、闭包（closure）

当函数返回一个匿名函数，且该匿名函数使用了它之外的变量，这个外部变量+该匿名函数就组成了一个闭包（closure），闭包形成后，该外部变量会一直留在内存中，示例如下：

package mainimport "fmt"func getSum() func(int) int {var sum int = 0            // 闭包中使用的变量return func(num int) int { // 函数中返回一个匿名函数sum = sum + num // 引用外部变量sumreturn sum}//返回的匿名函数+匿名函数以外的变量sum形成了闭包
}func main() {f := getSum()// 调用闭包fmt.Println(f(1)) //1fmt.Println(f(2)) //3fmt.Println(f(3)) //6fmt.Println(f(4)) //10// 这里，变量 sum 仍然存活，因为闭包仍然在使用它// 让闭包的引用消失f = nil // 现在没有任何引用指向 sum// 之后，如果没有其他地方引用 sum，它将被垃圾回收fmt.Println("----------------------")fmt.Println(getSum01(0, 1)) //1fmt.Println(getSum01(1, 2)) //3fmt.Println(getSum01(3, 3)) //6fmt.Println(getSum01(6, 4)) //10
}//不使用闭包的时候：我想保留的值，不可以反复使用
//闭包应用场景：闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了
func getSum01(sum int, num int) int {sum = sum + numreturn sum
}

闭包进阶：匿名函数的闭包
练习1：分析以下几段代码，它们的输出分别是？（如果是地址就答地址即可）
代码1

func main() {counter := func() func() int {count := 0return func() int {count++return count}}()fmt.Println(counter())fmt.Println(counter())fmt.Println(counter())
}

代码2

func main() {counter := func() func() int {count := 0return func() int {count++return count}}fmt.Println(counter())fmt.Println(counter())fmt.Println(counter())
}

代码3

func main() {counter := func() func() int {count := 0return func() int {count++return count}}fmt.Println(counter()())fmt.Println(counter()())fmt.Println(counter()())
}

这个分析起来还是有一定难度的，留到文末讲，读者可先思考一会儿。

四、defer关键字

defer是go的一个关键字，用于推迟执行函数或函数调用语句，直到外层函数返回后再执行这个函数或函数调用语句。具体来说就是将当前函数或函数调用语句压入一个栈中，等外层函数执行完后，再按栈的顺序（后进先出，数据结构的内容）取出栈顶元素。注意，压入栈中时，函数或调用语句中的变量的值也会一起保存，属于值传递，示例如下：

package mainimport "fmt"func main() {res := func(num1 int, num2 int) int {defer fmt.Println("num1=", num1)defer fmt.Println("num2=", num2)num1 += 90num2 += 50return num1 + num2}(30, 60)fmt.Println("sum=", res)
}

显然，num1和num2的值在函数体开头就被保存到栈中了，所以程序输出如下：

num2= 60
num1= 30
sum= 230

OK，我们再来看前面的练习，其关键在于匿名闭包：

counter := func() func() int {count := 0return func() int {count++return count}
}()

首先，不用管返回值具体是什么，你得先搞清楚匿名函数的概念，之前说过：无括号，返回的就是匿名函数本身，有括号，就是匿名函数返回值。所以代码2和3就能做出来了：代码2调用了三次匿名函数，由于返回的是闭包，所以得到的是函数（闭包的本质就是匿名函数），将打印三次函数的地址（引用）。由于每次是重新调用匿名函数，所以是也就是刷新了三次闭包，得到了三个一样的闭包地址。代码3的counter也是函数，但调用语句多了括号，所以每次是重新调用匿名函数并调用闭包，所以是得到了三个一样的闭包的返回值，即三个1。理解了这两个，代码1就好理解了，有括号说明得到的是闭包，匿名函数就调用了这一次，所以之后操作的都是同一个闭包，并不会刷新。而闭包中的外部变量是一直存在的，所以结果是1 2 3。
到这里，如果你能完全理解，说明你对闭包和匿名函数的掌握到位了。这题呢，其实是本人和ChatGPT共同制作的一个题，因为我在问它闭包知识的时候，它给我的是代码1，然后我就在这基础上改了下并加以思考。这说明学习要多举一反三，多扩展一些情况，那么你对这个知识点的理解就比别人更深，这也是提高学习效率的方式之一，因为如果理解太浅，到后面就得补来补去，会浪费不少时间。