Go 1.19.4 函数-Day 08

1. 函数概念和调用原理

1.1 基本介绍

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

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

1.2 函数的作用

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

1.3 函数的分类

1. 内建函数，如make、new、panic等
2. 库函数，如math.Ceil()等
3. 自定义函数，使用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 

上述代码执行过程：

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

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

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系统中的某个目录下找某一个文件，会一层一层目录去找，直到找到为止，这就是递归。

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

1. 直接在自己函数中调用自己。
2. 间接在自己函数中调用的其他函数中调用了自己。可以理解为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 

执行过程解释

1. 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，就这么无限分裂下去且没有返回阶段。
2. 定义边界条件，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了。