当前位置： 首页 > article >正文

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

article 2024/11/19 4:34:49

注：本人已有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，然后我就在这基础上改了下并加以思考。这说明学习要多举一反三，多扩展一些情况，那么你对这个知识点的理解就比别人更深，这也是提高学习效率的方式之一，因为如果理解太浅，到后面就得补来补去，会浪费不少时间。


http://www.kler.cn/a/326038.html

相关文章：

  • 号卡分销系统，号卡系统，物联网卡系统源码安装教程
  • STM32设计井下瓦斯检测联网WIFI加Zigbee多路节点协调器传输
  • 任意文件下载漏洞
  • 代码段数据段的划分
  • AI 编程编辑器和工具
  • Python3.11.9+selenium，选择证书用多线程+键盘enter解决
  • 第L2周：机器学习｜线性回归模型 LinearRegression：2. 多元线性回归模型
  • Vulhub zico 2靶机详解
  • GS-SLAM论文阅读笔记--MM3DGS SLAM
  • A Learning-Based Approach to Static Program Slicing —— 论文笔记
  • 【Git原理与使用】分支管理
  • C++可见性
  • 关于武汉芯景科技有限公司的IIC电平转换芯片XJ9509开发指南（兼容PCa9509)
  • Matlab实现麻雀优化算法优化回声状态网络模型 （SSA-ESN）（附源码）
  • linux环境oracle11.2.0.4打补丁（p31537677_112040_Linux-x86-64.zip）
  • [M贪心] lc2207. 字符串中最多数目的子序列(模拟+贪心+一次遍历+代码细节+思维)
  • 无人机避障—— 激光雷达定高北醒TF03-UART（二）
  • 【基础算法总结】分治--快排+归并
  • YOLOv8改进，YOLOv8改进损失函数采用Powerful-IoU（2024年最新IOU），助力涨点
  • 【YOLOv10改进[SPPF]】使用 SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
  • Linux内核 -- 读写文件系统文件之kernel_read与kernel_write
  • APISIX 联动雷池 WAF 实现 Web 安全防护
  • VLAN Bond 堆叠
  • 苍穹外卖学习笔记(十三)
  • TikTok Shop成印尼第二大电商平台，TikTok怎么快速涨粉？
  • OpenCV开发笔记（八十一）：通过棋盘格使用鱼眼方式标定相机内参矩阵矫正摄像头图像