Go 函数进阶

最新推荐文章于 2023-08-08 14:42:13 发布

ZiHao626

最新推荐文章于 2023-08-08 14:42:13 发布

阅读量87

点赞数 1

分类专栏： Go Learning 文章标签： golang

本文链接：https://blog.csdn.net/zihao123w/article/details/115944458

版权

Go Learning 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

9 函数进阶

变量作用域

全局变量

定义于函数外部，在程序整个运行周期内有效

局部变量

函数内定义的变量无法在该函数外使用
若局部变量和全局变量重名，优先访问局部变量
if 条件判断、for循环、switch语句块中定义的变量，只能在该语句块中使用

函数类型与变量

定义函数类型

使用关键字type 定义一个函数类型，格式：
- type calculation func(int,int) int
- 定义了一个calculation 类型，一种函数类型，接收两个int类型参数并且返回一个int类型
- 满足 参数列表一致并且返回值列表一致的都是某一函数类型
  - var c calculation

函数类型变量

可以声明函数类型的变量并且为该变量赋值

    func main() {
	var c calculation               // 声明一个calculation类型的变量c
	c = add                         // 把add赋值给c
	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // 像调用add一样调用c

	f := add                        // 将函数add赋值给变量f1
	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // 像调用add一样调用f
}

高阶函数

高阶函数：
- 函数作为参数
- 函数作为返回值

函数作为参数

示例：

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

函数作为返回值

示例：

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

匿名函数和闭包

匿名函数

多用于实现回调函数和闭包
函数可以作为返回值，但是Go 中，函数内部不能一般那样定义函数，只能定义匿名函数
- 格式
```
func (参数)(返回值){
	函数体
}
```

匿名函数没有函数名：需要 保存在某个变量 或者 作为立即执行函数

func main() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

闭包（不太懂）

闭包可以理解成**“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。或者说是函数和其引用环境的组合体**。
一个函数 和 与其相关的引用环境 组合而成的实体
- 闭包 = 函数+引用环境

示例：

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

变量f: 一个函数，并且它引用了其外部作用域中的x
- 此时 f 就是一个闭包
- 在f 的生命周期内，变量x 也一直有效

闭包进阶示例1

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder2(10)
	fmt.Println(f(10)) //20
	fmt.Println(f(20)) //40
	fmt.Println(f(30)) //70

	f1 := adder2(20)
	fmt.Println(f1(40)) //60
	fmt.Println(f1(50)) //110
}

闭包进阶示例2

func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func main() {
	jpgFunc := makeSuffixFunc(".jpg")
	txtFunc := makeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test")) //test.jpg
	fmt.Println(txtFunc("test")) //test.txt
}

闭包进阶示例3

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main() {
	f1, f2 := calc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

牢记 闭包 = 函数 + 引用环境

defer 语句

defer 语句的延迟调用的特性
- 使得能非常方便的处理资源释放问题
  - 资源清理，文件关闭，解锁及记录时间
  - C++ 语言中的析构函数（Destructor)可以起到类似作用：C++ 机制担保在对象被销毁前一定会执行析构函数中的代码
  - 析构函数：析构对象
  - defer：析构函数
Go 中的def 将语句进行 延迟处理
在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行

即：先被defer 的语句最后被执行，最后被defer 的语句最先被执行

示例

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}

输出：
```
start
end
3
2
1
```

defer 执行时机

在 Go 的函数中，return 语句在底层并不是原子操作
- 给返回值赋值
- RET 指令
而 defer 语句的执行时机，就在给返回值赋值后，RET 指令执行前
defer、 return、返回值 三者的执行顺序是 :
- return 最先给返回值赋值；
- 接着 defer 开始执行一些收尾工作；
- 最后 RET 指令携带返回值退出函数。

defer 经典案例(不太懂)

阅读代码，打印结果

func f1() int {
	x := 5
	defer func() {
		x++
	}()
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func main() {
	fmt.Println(f1())		//5
	fmt.Println(f2())		//6
	fmt.Println(f3())		//0
	fmt.Println(f4())		//1
}