注：本人已有C，C++,Python基础，只写本人认为的重点。
这个知识点基本属于go的特性，比较重要，需要认真分析。
一、init函数
每个文件都可以定义init函数，它会在main函数执行前被调用，无论它的定义位置是在main后还是前。而全局变量的优先级又高于init，所以优先级是这样的：全局变量>init>main。示例如下：
package main
import "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 main
import (
"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 testutils
import "fmt"
var Age int
var Sex string
var Name string
func 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 main
import "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 main
import "fmt"
func getSum() func(int) int {
var sum int = 0 // 闭包中使用的变量
return func(num int) int { // 函数中返回一个匿名函数
sum = sum + num // 引用外部变量sum
return sum
}
//返回的匿名函数+匿名函数以外的变量sum形成了闭包
}
func main() {
f := getSum()
// 调用闭包
fmt.Println(f(1)) //1
fmt.Println(f(2)) //3
fmt.Println(f(3)) //6
fmt.Println(f(4)) //10
// 这里，变量 sum 仍然存活，因为闭包仍然在使用它
// 让闭包的引用消失
f = nil // 现在没有任何引用指向 sum
// 之后，如果没有其他地方引用 sum，它将被垃圾回收
fmt.Println("----------------------")
fmt.Println(getSum01(0, 1)) //1
fmt.Println(getSum01(1, 2)) //3
fmt.Println(getSum01(3, 3)) //6
fmt.Println(getSum01(6, 4)) //10
}
//不使用闭包的时候：我想保留的值，不可以反复使用
//闭包应用场景：闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了
func getSum01(sum int, num int) int {
sum = sum + num
return sum
}
闭包进阶：匿名函数的闭包
练习1：分析以下几段代码，它们的输出分别是？（如果是地址就答地址即可）
代码1
func main() {
counter := func() func() int {
count := 0
return func() int {
count++
return count
}
}()
fmt.Println(counter())
fmt.Println(counter())
fmt.Println(counter())
}
代码2
func main() {
counter := func() func() int {
count := 0
return func() int {
count++
return count
}
}
fmt.Println(counter())
fmt.Println(counter())
fmt.Println(counter())
}
代码3
func main() {
counter := func() func() int {
count := 0
return func() int {
count++
return count
}
}
fmt.Println(counter()())
fmt.Println(counter()())
fmt.Println(counter()())
}
这个分析起来还是有一定难度的，留到文末讲，读者可先思考一会儿。
四、defer关键字
defer是go的一个关键字，用于推迟执行函数或函数调用语句，直到外层函数返回后再执行这个函数或函数调用语句。具体来说就是将当前函数或函数调用语句压入一个栈中，等外层函数执行完后，再按栈的顺序（后进先出，数据结构的内容）取出栈顶元素。注意，压入栈中时，函数或调用语句中的变量的值也会一起保存，属于值传递，示例如下：
package main
import "fmt"
func main() {
res := func(num1 int, num2 int) int {
defer fmt.Println("num1=", num1)
defer fmt.Println("num2=", num2)
num1 += 90
num2 += 50
return num1 + num2
}(30, 60)
fmt.Println("sum=", res)
}
显然，num1和num2的值在函数体开头就被保存到栈中了，所以程序输出如下：
num2= 60
num1= 30
sum= 230
OK，我们再来看前面的练习，其关键在于匿名闭包：
counter := func() func() int {
count := 0
return func() int {
count++
return count
}
}()
首先，不用管返回值具体是什么，你得先搞清楚匿名函数的概念，之前说过：无括号，返回的就是匿名函数本身，有括号，就是匿名函数返回值。所以代码2和3就能做出来了：代码2调用了三次匿名函数，由于返回的是闭包，所以得到的是函数（闭包的本质就是匿名函数），将打印三次函数的地址（引用）。由于每次是重新调用匿名函数，所以是也就是刷新了三次闭包，得到了三个一样的闭包地址。代码3的counter也是函数，但调用语句多了括号，所以每次是重新调用匿名函数并调用闭包，所以是得到了三个一样的闭包的返回值，即三个1。理解了这两个，代码1就好理解了，有括号说明得到的是闭包，匿名函数就调用了这一次，所以之后操作的都是同一个闭包，并不会刷新。而闭包中的外部变量是一直存在的，所以结果是1 2 3。
到这里，如果你能完全理解，说明你对闭包和匿名函数的掌握到位了。这题呢，其实是本人和ChatGPT共同制作的一个题，因为我在问它闭包知识的时候，它给我的是代码1，然后我就在这基础上改了下并加以思考。这说明学习要多举一反三，多扩展一些情况，那么你对这个知识点的理解就比别人更深，这也是提高学习效率的方式之一，因为如果理解太浅，到后面就得补来补去，会浪费不少时间。