Go 1.19.4 函数-Day 08

avatar
作者
猴君
阅读量:2

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了。

在这里插入图片描述

广告一刻

为您即时展示最新活动产品广告消息,让您随时掌握产品活动新动态!