Go 1.19.4 函数-Day 08

1. 函数概念和调用原理

1.1 基本介绍

函数是基本的代码块，用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

简单点理解，函数就是一个或者多个功能的集合体。

1.2 函数的作用

结构化编程对代码的最基本的封装，一般按照功能组织一段代码
封装的目的为了复用，减少冗余代码
代码更加简洁美观、可读易懂

1.3 函数的分类

内建函数，如make、new、panic等
库函数，如math.Ceil()等
自定义函数，使用func关键字定义

1.4 函数定义与调用

func 函数名(参数列表) [(返回值列表)]{
    函数体（代码块）
   [return 返回值]
}
这里[]表示其中的内容可有可无

func main(){
     被调用函数()
}

函数名就是标识符，命名要求一样
定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参
返回值列表可有可无，需要return语句配合，表示一个功能函数执行完返回的结果
函数名(参数列表) [(返回值列表)] 这部分称为函数签名
Go语言中形参也被称为入参，返回值也被称为出参

1.4.1 普通函数定义

package main

// 函数声明/定义(定义时)
func add(){
	Println("函数体，具体执行功能的代码块。")
}

func main() {
	add()// 函数调用（调用时）
}

1.4.2 带参数的函数定义

1.4.2.1 使用形参（入参）与实参

package main

import "fmt"

// x int, y int属于形式参数（形参或入参）。还可以写成x, y int
// add(x int, y int)属于签名
func add(x int, y int) {
	fmt.Println(x + y)
}

func main() {
	// 函数调用时，把add函数所需形参传过去，这种参数被称为“实参”，还能成为“传参”
	add(4, 5) // 注意参数的对应关系
}
==========调试结果==========
9

1.4.3 定义包含返回值的函数

调用时，如果有返回值，需要在调用时定义对应返回值个数的变量去接收。

package main

import "fmt"

// add(x int, y int) int，括号后的int表示返回值的类型和数量。
func add(x int, y int) int {
	fmt.Println("add函数的执行结果：", x+y)

	// 定义返回值为1
	return 1 // return之后的语句不会执行，函数将结束执行
}

func main() {
	// add函数的返回值赋值给v变量
	v := add(4, 5) // go语言中，只能在有返回值的情况下，才能用变量接住，不然定义了会报错。
	fmt.Println("add函数的返回值：", v)
	//fmt.Println(add(4, 5)) // 如果返回值只用一次那这样也可以，等同于上面两条。多次调用还是建议定义变量，使用起来方便
}
==========调试结果==========
add函数的执行结果： 9
add函数的返回值： 1

上述代码执行过程：

系统从上到下加载代码，加载到v := add(4, 5)时，先执行add(4, 5)。
在内存中找到add函数，并把4和5作为实参传递给add函数中的x和y。
add函数开始执行fmt.Println(“add函数的执行结果：”, x+y)，也就是把x+y的结果输出到控制台。
add函数中的println函数执行完毕后，开始执行return 1，最终会返回一个1给到main函数中的v。
执行main中的print函数，输出add函数的返回值。

1.5 函数调用原理

特别注意，函数定义只是告诉你有一个函数可以用，但这不是函数调用执行其代码。至于函数什么时候被调用，不知道。一定要分清楚定义和调用的区别。
函数调用相当于运行一次函数定义好的代码，函数本来就是为了复用，试想你可以用加法函数，我也可以用加法函数，你加你的，我加我的，应该互不干扰的使用函数。为了实现这个目标，函数调用的一般实现，都是把函数压栈（LIFO），每一个函数调用都会在栈中分配专用的栈帧，本地变量、实参、返回值等数据都保存在这里。
一句不准确的口诀：函数的每一次调用都是独立的，不相干的。—— wayne
上面的代码，首先调用main函数，main压栈，接着调用add(4, 5)时，add函数压栈，压在main的栈帧之上，add调用return，add栈帧消亡，回到main栈帧，将add返回值保存在main栈帧的本地变量out上。

2. 函数类型与返回值

2.1 函数类型

可以看出同一种签名的函数是同一种类型

package main

import "fmt"

func fn1() {}

func fn2(i int) int { return 100 }

func fn3(j int) (r int) { return 200 }

func main() {
	fmt.Printf("%T\n", fn1)
	fmt.Printf("%T\n", fn2)
	fmt.Printf("%T\n", fn3)
}
==========调试结果==========
func() // 没有参数的函数，就是这样的
func(int) int
func(int) int

2.2 函数返回值

函数返回值为局部变量。

2.2.1 无返回值函数

注意：在Go中，无返回值的函数不允许使用变量去接，会报错。

package main

import "fmt"

func fn1() {
	fmt.Println("这是一个无返回值函数！")
}

func main() {
    // a := fn1() // 由于没有返回值，所以千万不要用变量去接，会报错
	fn1()// 无返回值，不需要传参的函数直接调用即可。
}
==========调试结果==========
这是一个无返回值函数！

2.2.2 带返回值的函数

2.2.2.1 返回一个值

package main

import "fmt"

func fn2() int { // 此处的int表示该函数有1个返回值
	return 100 // 返回一个值
}

func main() {
	v := fn2() // 变量接收返回值
	fmt.Println("fn2函数的返回值为：", v)
}
==========调试结果==========
fn2函数的返回值为： 100

package main

import "fmt"

func fn3() int {
	var r = 100
	return r
}

func main() {
	v := fn3()
	fmt.Println("fn3函数的返回值为：", v)
}
==========调试结果==========
fn3函数的返回值为： 100

package main

import "fmt"

func fn4() (r int) { // 直接在函数后面定义变量和类型也可以，r也相当于就是个占位符
	r = 300
	return r
	// return // 还可以这样，return后面不接变量，由系统自动推断到r int
}

func main() {
	v := fn4()
	fmt.Println("fn4函数的返回值为：", v)
}
==========调试结果==========
fn4函数的返回值为： 300

package main

import "fmt"

func fn4() (r int) {
	t := 300
	return t //该方式相当于r = t
}

func main() {
	v := fn4()
	fmt.Println("fn4函数的返回值为：", v)
}
==========调试结果==========
fn4函数的返回值为： 300

2.2.2.2 返回多个值

package main

import "fmt"

// go允许多返回值
func fn5() (int, int) { // (int, int)，两个int表示有两个返回值
	a, b := 4, 50
	return a, b
}

func main() {
	v1, v2 := fn5() // 注意：返回值变量要和返回值数量相对应
	fmt.Println("fn5函数的返回值为：", v1, v2)
}
==========调试结果==========
fn5函数的返回值为： 4 50

package main

import "fmt"

func fn6() (i int, j bool) {
	// return 100, false // 这样可以
	i, j = 200, true
	return // 这样也可以，相当于return i, j
}

func main() {
	v1, v2 := fn6()
	fmt.Println("fn6函数的返回值为：", v1, v2)
}
==========调试结果==========
fn6函数的返回值为： 200 true

这里看一个特殊示例

package main

import "fmt"

func fn7() (i int, j bool) {// 这里的i j也是充当了出参占位符的角色，同时也是局部变量，仅在该函数中使用
	return
}

func main() {
	v1, v2 := fn7()
	fmt.Println("fn7函数的返回值为：", v1, v2)
}
==========调试结果==========
fn7函数的返回值为： 0 false

从结果可以看出，不明确指定返回值的情况下，int默认为0，bool默认为false。
其实就是只声明，但是不赋值，使用了对应数据类型的默认值。

再看一个非常特殊的示例
在这里插入图片描述

为什么上图return报错了？
根本原因是return不知道把结果返回给谁！因为if f,err := xxx，这里相当于重新在if中声明了一个f局部变量和err局部变量，但是fn8函数的出参也定义了err变量，由于存在两个err变量，导致return不知道把结果返回给哪个err，所以报错了。
解决办法如下如图：

2.2.3 返回值总结

实际工作中，还是更建议显示的指定return 返回值，便于阅读。
可以返回0个或多个值。
可以在函数定义中写好返回值参数列表。
○ 可以没有标识符，只写类型。但是有时候不便于代码阅读，不知道返回参数的含义
○ 可以和形参一样，写标识符和类型来命名返回值变量，相邻类型相同可以合并写
○ 如果返回值参数列表中只有一个返回参数类型，小括号可以省略
○ 以上2种方式不能混用，也就是返回值参数要么都命名，要么都不要命名
return
○ return之后的语句不会执行，函数将结束执行
○ 如果函数无返回值，函数体内根据实际情况使用return
○ return后如果写值，必须写和返回值参数类型和个数一致的数据
○ return后什么都不写那么就使用返回值参数列表中的返回参数的值，如果返回值参数没有赋过值，就用零值

3. 函数的形参与可变参数

3.1 形参

可以无形参，也可以多个形参
不支持形式参数的默认值
形参是局部变量

3.1.1 定义无标识符形参

无标识符形参不建议使用，因为没办法在函数中拿到这个值（实参）。

定义形参的目的是为了在函数中使用，这种在函数中无法使用的形参，定义了也是没有意义的。

package main

import "fmt"

func fn1(int) { // 不建议这样用，因为没有办法获取传进来的实参100
	fmt.Println("无标识符形参！")
}

func main() {
    // 传递实参
	fn1(100)
}
==========调试结果==========
无标识符形参！

3.1.2 定义有标识符形参

推荐使用该方式。

package main

import "fmt"

func fn2(x, y int) {
    // 明确定义形参标识符后，就可以在函数体内部调用了
	fmt.Printf("有标识符形参：x=%v，y=%v", x, y)
}

func main() {
	fn2(100, 200)
}
==========调试结果==========
有标识符形参：x=100，y=200

3.1.2.1 形参默认值示例

注意：Go语言不支持形参默认值，所以不要这样定义。

package main

import "fmt"


// func config(a,b int, c string = "OK"){ // 这样是不可以的
func config(a, b int, c string) {
	fmt.Println(a, b, c)
}

func main() {
    // config(1,2)
	config(1, 2, "ok")
}
==========调试结果==========
1 2 ok

3.2 可变参数（name … type）

在 Go 语言中，可变参数是指函数可以接受任意数量的参数。
这通过在函数的参数列表中使用省略号 … 和参数类型来实现，最终可变参数收集实参到一个切片中，注意最终数据类型是切片。
使用可变参数可以让你的函数更加灵活，能够处理不同数量的输入。
注意：如果有可变参数，那它必须位于参数列表中最后。

3.2.1 定义可变参数函数

package main

import "fmt"

// ...表示任意数量的参数（0到n个），int为参数类型，nums为可变参数名称。
func fn6(nums ...int) {
	fmt.Printf("可变参数nums的值：%d\n可变参数nums的类型：%[1]T\n可变参数nums的长度：%[2]d\n可变参数nums的容量：%[3]d\n", nums, len(nums), cap(nums))
}

func main() {
	fn6()
	fn6(1, 3, 100)
}
==========调试结果==========
可变参数nums的值：[]
可变参数nums的类型：[]int
可变参数nums的长度：0
可变参数nums的容量：0
可变参数nums的值：[1 3 100]
可变参数nums的类型：[]int
可变参数nums的长度：3
可变参数nums的容量：3

3.2.2 切片分解（切片传递）

切片分解其实就是把传入的切片的header复制给了新的切片。
切片分解不会导致底层数组扩容，因为复制的header。

3.2.2.1 示例一

package main

import "fmt"

func fn6(nums ...int) {
	fmt.Println(nums)
	fmt.Printf("%p %p\n", &nums, &nums[0])
}

func main() {
	var p = []int{1, 3}
	fn6(p...)// 这里就相当于是header复制
	fmt.Printf("%p %p\n", &p, &p[0])
}
==========调试结果==========
[1 3]
0xc000008090 0xc0000180a0
0xc000008078 0xc0000180a0

3.2.2.2 示例二

func fn7(x, y int, nums ...int) {
 fmt.Printf("%d %d; %T %[3]v, %d, %d\n", x, y, nums, len(nums),
cap(nums))
}
p := []int{4, 5}
fn7(p...)          // 错误，不能用在普通参数上
fn7(1, p...)       // 错误，不能用在普通参数上
fn7(1, 2, 3, p...) // 错误，不能用2种方式为可变参数传参，不能混用
// fn7(1, 2, p..., 9, 10) // 语法错误
// fn7(1, 2, []int{4, 5}..., []int{6, 7}...) // 语法错误，不能连续使用p...，只能一次
// 正确的如下
fn7(1, 2, []int{4, 5}...)
fn7(1, 2, p...)
fn7(1, 2, 3, 4, 5)

3.2.3 小练习：编写一个函数，它可以接受任意数量的整数参数，并返回它们的总和。

package main

import (
	"fmt"
)

// 编写一个函数 sum，它可以接受任意数量的整数参数，并返回它们的总和。
func Sum(nums ...int) int {
	a := 0
	for _, v := range nums {
		a += v
	}
	return a
}

func main() {
	fmt.Println(Sum(10, 2, 10))
}
==========调试结果==========
22

4. 作用域

作用域实际上就是在说“标识符”的可见范围，有点类似于全局变量和局部变量这种概念。
函数天然就是一个作用域，Go中的作用域主要如下：

语句块作用域
如if、for、switch等语句中使用短格式定义的变量，可以认为就是该语句块的变量，作用域仅在该语句块中。
显示的块作用域
{xxx}，这就是显示的块作用域。
universe块作用域
包块作用域
函数块作用域

4.1 语句块作用域

package main

import "fmt"

func main() {
	t := []int{1, 2, 3, 4}
	for _, v := range t {
		fmt.Println(v)
	}
	// 语句块外部引用变量v失败，因为v的作用域只在for循环内部
	//fmt.Println(v)
	fmt.Println("------------------")
	var v = 1 // 这里再定义一个v也不会有冲突，因为两个v的作用域不同
	fmt.Println(v)
}
==========调试结果==========
1
2
3
4
------------------
1

4.2 显示的块作用域

package main

import "fmt"

func main() {
	{
		const a = 100
		var b = 200
		c := 300
		fmt.Println(a,b,c)
	}
	
	// 这样是不可以的，abc标识符只能在{}中生效。
	//fmt.Println(a,b,c)
}
==========调试结果==========
100 200 300

4.3 universe块（宇宙块）

宇宙块，意思就是全局块，不过是语言内建的（就是go系统的内置函数）。
预定义的标识符就在这个全局环境中，因此什么bool、int、nil、true、false、iota、append等标识符全局可见，随处可用。

4.4 包块作用域

所谓包块作用域，就是说多份代码文件都属于同一个包，那么在main包中就可以调用其他包的变量或函数。
所有包内定义全局标识符，包内可见。包外需要大写首字母导出，使用时也要加上包名。如fmt.Print
如下图：

4.5 函数块作用域

函数声明的时候使用了花括号，所以整个函数体就是一个显式代码块。这个函数就是一个块作用域。

4.6 作用域综合测试

package main

import "fmt"

var a = 100

const b = 200

//c := 300 // 错误，定义全局变量，不能使用短格式

func main() {
	// 全局变量可以在函数体内部调用（向内穿透）
	a = 500
	fmt.Println("调用全局变量a：", a)

	// 由于作用域不同，所以a可以在函数体内部二次定义，此时的a为函数体内局部变量
	var a = 1000               // 重复定义不代表覆盖，全局a和局部a是两个完全独立的个体
	fmt.Println("调用局部变量a：", a) //同时存在相同全局和局部变量时，优先采用就近原则

	fmt.Println("调用全局常量b：", b)
	const b = "abc"
	fmt.Println("调用局部常量b：", b)

}
==========调试结果==========
调用全局变量a： 500
调用局部变量a： 1000
调用全局常量b： 200
调用局部常量b： abc

再来看个特殊例子

package main

import "fmt"

var a = 100

func showA() int { // 看这里
	return a
}

func main() {
	a = 500
	fmt.Println("调用全局变量a：", a)

	var a = 1000
	fmt.Println("调用局部变量a：", a)

	fmt.Println("return返回值：", showA()) // 看这里
}

看下上面showA函数最终的返回值是多少？
答案是500。
因为showA函数体内部是没有a这个变量的，所以它只能向函数体外寻找，只能找到a这个全局变量，而在main函数中，全局变量a的结果已经被修改为500了，所以最终返回值为500。

5. 递归函数

什么是递归？
可以理解为在linux系统中的某个目录下找某一个文件，会一层一层目录去找，直到找到为止，这就是递归。

什么是递归函数？
有两种递归方式：

直接在自己函数中调用自己。
间接在自己函数中调用的其他函数中调用了自己。可以理解为A调用B，B函数体中又调用了A。
这种间接的递归非常危险，要尽量避免出现间接递归。
并且不管是1或2这种递归调用，假设函数体内部没有返回，那么每次调用都会生成一个“栈争”，有点类似于叠盘子（可以称为递归前进段），直到内存中分配的栈空间耗尽（盘子叠满了），程序就崩溃了。
正常应该是能叠就能收，收这个操作被称为“递归返回段”。

注意：

递归函数要有边界条件（递归终止条件，防止无限递归）、递归前进段、递归返回段。
递归函数必须有边界条件（递归终止条件，防止无限递归）。
当边界条件不满足时，递归前进。
当边界条件满足时，递归返回。

5.1 斐波那契数列递归

5.1.1 版本一：普通循环实现

package main

import "fmt"

func fib1(n int) int {
	switch {
	// 如果小于0，说明传参为负数
	case n < 0:
		panic("n is negative!!!")
	// 如果为0，就直接返回0，因为斐波那契数列的第一个数字就是0
	case n == 0:
		return 0
	// 如果是1或2，就直接返回1，因为0,1,1,……
	case n == 1 || n == 2:
		return 1
	}

	// 开始计算第三个数字
	a, b := 0, 1 // 先定义两个初始值

	for i := 0; i < n-2; i++ { // n-2是因为上面已经输出了2个数字（0和1）
		a, b = b, a+b
	}
	return b
}

func main() {
	v := fib1(4) // 显示单个斐波那契数列
	fmt.Println(v)
}
==========调试结果==========
2

5.1.2 版本二：递归实现

斐波那契数列：1，1，2，3，……
实现公式：F(n)=F(n-1)+F(n-2)。n-1就是前一个数字，n-2就是前面第二个数字
还是理解为：从第三个数开始往后，都是前两数的和

package main

import "fmt"

func fib2(n int) int {
	// （2）判断函数传参值为1或2就直接返回1，相当于就是“边界条件”。
	if n == 0 {
		panic("传参不能为0")
	} else if n == 1 || n == 2 { // 此处的1和2表示的是第一个数和第二个数
		return 1
	}

	// （1）递归调用
	return fib2(n-1) + fib2(n-2)
}

func main() {
	v := fib2(6)
	fmt.Println(v)
}
==========调试结果==========
8

执行过程解释

return fib2(n-1) + fib2(n-2)
假设我传参为3，也就是fib2(3)，那么fib2(n-1) + fib2(n-2)就变成了fib2(3-1) + fib2(3-2)=return fib2(2) + fib2(1)，这就形成了递推公式。
但是在递归调用中，必须有前进段和返回段，也就是必须要加边界条件防止无限递归。
这里如果不加边界条件，那么3就会分裂成2和1，2分裂成1和0,1分裂成0和-1，就这么无限分裂下去且没有返回阶段。
定义边界条件，if判断。
还是假定传参为fib2(3)，那么return fib2(2) + fib2(1)=fib2(3)，这么看着是不是不对。
实际的执行过程是先把fib2(3-1)=2带入到形参处落栈，如下图：
加法先执行左边。
> 然后再把fib2(3-2)=1带入到形参处落栈，入下图：
但是在这个过程中，单单n-2就能无限次分裂了，所以必须设置边界条件来阻止无限递归。

else if n == 1 || n == 2 {return 1}，有了这个判断，就阻止了递归调用的无限调用，同时，还返回了值给了fib2(3)，这个1相当于被它进行了暂计，等到计算fib2(n-2)时，也会把结果暂计下来，最后运行return 1 + 1，并把最终返回值返回给main函数，到此整个函数调用结束。

5.1.3 版本三：循环改调用实现

就是把版本一里面你的循环，改成函数递归调用。
循环的次数等于递归调用的次数。

package main

import "fmt"

func fib3(n, a, b int) int {
	if n < 3 {
		return b
	}
	
	return fib3(n-1, b, a+b)
}

func main() {
	v := fib3(10, 1, 1)
	fmt.Println(v)
}
==========调试结果==========
55

5.1.4 三种方式效率对比

上面三种方式，效率最高的是fib1、其次是fib3，效率最差的是fib2。
为什么fib2效率最差？主要就是因为这个公式fib2(n-1) + fib2(n-2)，看下图：
稍微传参一个大一点的数字，函数体内部会存在大量的重复计算，严重浪费时间和资源。
不过也有解决办法，就是把fib分裂出来的结果先到map中查询一次，没有匹配到的就把结果存到map中，一旦匹配到的结果，就说明之前肯定已经计算过了，就不用重复计算了。
唯一的缺点可能就是需要多消耗一点内存，但是运行速度变快了。

5.2 间接递归

func foo() {
 bar()
}
func bar() {
 foo()
}
foo()

就像上面的代码，foo中调用bar，bar中调用foo。
不推荐这么玩，特别是复杂代码，出了问题非常不利于排查。

5.3 递归总结

能不用就不用

递归是一种很自然的表达，符合逻辑思维
递归相对运行效率低，每一次调用函数都要开辟栈帧
递归有深度限制，如果递归层次太深，函数连续压栈，栈内存就溢出了
如果是有限次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只
要不是死循环，可以多次迭代直至算出结果
绝大多数递归，都可以使用循环实现
即使递归代码很简洁，但是能不用则不用递归

6. 匿名函数

6.1 什么是匿名函数

匿名函数是Go语言中的一种特殊函数，它没有函数名，通常用于快速定义一个功能，然后立即使用它。它们可以作为参数传递给其他函数，或者存储在变量中，以便稍后使用。

6.2 为什么要用匿名函数

在Go语言中，匿名函数是一种没有名称的函数，它们在某些情况下非常有用，比如当需要一个简单的功能，但又不想为此创建一个完整的函数定义时。
调用的话，由于没有名字，所以只能选择立即调用或者赋值给一个标识符。
主要使用场景是用作高阶函数中，是传入的逻辑，函数允许传入参数，就是把逻辑外置。
所谓高阶函数就是返回值或形参是一个函数，两者满足其一皆为高阶函数。
如下例子就会演示这种场景。

6.3 定义匿名函数

6.3.1 方式一：纯匿名函数

package main

import "fmt"

func main() {
	// 定义匿名函数并调用，但是只能使用一次，因为它没有标识符。
	v := func(x, y int) int {
		return x + y
	}(4, 5)
	fmt.Println(v)
}
==========调试结果==========
9

6.3.2 方式二：匿名函数加高阶函数

package main

import "fmt"

// fn func(x,y int) int,这一步就属于逻辑外移了
// 所谓逻辑外移，就是calc函数本身并不管运算逻辑如何实现，而是由fn函数把运算逻辑作为参数传递进来
func calc(a, b int, fn func(x, y int) int) int {// fn是高阶函数
	// 这个r对应的是fn func(x,y int) int中最后的这个int
	r := fn(a, b)
	// 这个r对应的是这个int {
	return r
}

func minus(x, y int) int {
	return x - y
}

func main() {
	// fn函数的运算逻辑，在这里作为实参传入{return x + y}
	fmt.Println(calc(4, 5, func(x, y int) int { return x + y }))
	fmt.Println(calc(4, 5, func(x, y int) int { return x * y }))
	fmt.Println(calc(4, 5, minus))// 注意minus不要写成minus()
}
==========调试结果==========
9
20
-1

7. 函数嵌套

package main

import "fmt"

func outer() {
	c := 99
	var inner = func() {
		fmt.Println("1 inner c=", c)
	}
	inner()
	fmt.Println("2 outer c=", c)
}

func main() {
	outer()
}
==========调试结果==========
1 inner c= 99
2 outer c= 99

可以看到outer中定义了另外一个函数inner，并且调用了inner。outer是包级变量，main可见，可以调用。而inner是outer中的局部变量，outer中可见。

8. 闭包

自由变量： 未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量。
闭包： 就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量（局部变量），就形成了闭包。闭包是运行期动态的概念（只有在运行期间才会有闭包）。

略

9. defer

9.1 介绍

defer意思是推迟、延迟。语法很简单，就在正常的语句前加上defer就可以了。

在某函数中使用defer语句，会使得defer后跟的语句进行延迟处理，当该函数return前，或发生panic时，defer后语句开始执行。

同一个函数可以有多个defer语句，依次加入调用栈中（LIFO），函数返回或panic时，从栈顶依次执行
defer后语句。执行的先后顺序和注册的顺序正好相反，也就是后注册的先执行。

defer后的语句必须是一个函数或方法的调用。

9.2 示例

9.2.1 示例一

package main

import "fmt"

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("stop")
}
==========调试结果==========
start
stop
3
2
1

9.2.2 示例二

package main

import "fmt"

func main() {
	fmt.Println("start")
	count := 1
	defer fmt.Println(count)
	count++
	defer fmt.Println(count)
	count++
	defer fmt.Println(count)
	count++
	fmt.Println("stop")
}
==========调试结果==========
start
stop
3
2
1

为啥上述代码执行结果是321，为什么？因为defer注册时就，就把其后语句的延迟执行的函数的参数准备好了，也就是注册时计算。

9.2.3 示例三：特殊示例

package main

import "fmt"

func main() {
	fmt.Println("start")
	count := 1
	defer func() {
		fmt.Println(count)
	}()
	count++
	defer fmt.Println(count)
	count++
	defer fmt.Println(count)
	count++
	fmt.Println("stop")
}
==========调试结果==========
start
stop
3
2
4

为什么结果是3 2 4？
（1）首先main函数中的内容从上到下加载到内存中，这里先忽略defer func() { fmt.Println(count) }()，继续往下看
（2）count++，count从原来的1变成2
（3）紧接着defer fmt.Println(count)，此时的count就会被加载成2。
（4）count++，count从原来的2变成3。
（5）defer fmt.Println(count)，此时的count就会被加载成3。
（6）count++，count从原来的3变成4。

再回来看defer func() { fmt.Println(count) }()。
函数定义部分：func() { fmt.Println(count) }
函数调用部分：()

再看fmt.Println(count)。
有啥区别？Println函数，在执行时，是有明确的传参的，就是count，而我们的匿名函数呢，它没有，它的结构是：func() { 函数体内部 }，这就导致在加载的时候，这个匿名函数是不会有任何变化的，等到真正执行这个函数的时候，函数体内部的println函数才开始执行，此时的count变量经过几次迭代，就已经变成4了。