GO学习笔记（3）

链接: 学习资源

函数声明和调用

Go语言函数声明格式如下：

func 函数名（参数列表） （返回值） {
	函数体
}
1
2
3

package main

import (
	"fmt"
	"math"
)
//三个数字找最大值和最小值
func Max_Min(a, b, c float64) (float64, float64) {
	return math.Max(math.Max(a, b), c), math.Min(math.Min(a, b), c)
}
func main() {
	x, y := Max_Min(3.14, 5, 2)
	fmt.Println(x, y)
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

可变参数

概念：一个函数的参数类型确定，但是个数不确定，就可以使用可变参数

func myfunc(arg ...int) {}
1

注意事项：

• 如果一个函数有可变参数的同时还有其他参数，那么可变参数要放到参数列表的最后
• 一个函数的参数列表中最多有一个可变参数

package main

import "fmt"

func getSum(nums ...int) {
	res := 0
	for i := 0; i < len(nums); i++ {
		res += nums[i]

	}
	fmt.Println("res = ", res)
}
func main() {
	getSum(3, 4, 6, 1)
	getSum(5, 6, 22)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出：

res =  14
res =  33

1
2
3

---

defer

在go语言中，使用defer关键字延迟一个函数或者方法的执行

如果有好多调用defer，那么defer采用先进后出的(栈)模式

package main

import "fmt"

func work(tep int) {
	fmt.Println(tep)
}
func main() {
	work(1)
	defer work(2)
	work(3)
	defer work(4)
	work(5)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出

1
3
5
4
2

1
2
3
4
5
6

---

函数式编程

既然函数是一种数据类型，可以作为一个参数传到函数里，即一个函数可以作为另一个函数的参数

定义两个函数work(),add()
将add函数作为work函数的参数
work函数：叫做高阶函数，接收了一个函数作为参数的函数
add函数：叫做回调函数，作为另一个函数的参数

package main

import "fmt"

func work(a, b int, F func(int, int) int) int {

	return F(a, b)
}
func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}

func main() {
	fmt.Println(work(1, 2, add))
	fmt.Println(work(7, 3, sub))

	//匿名函数作为参数
	res := work(6, 3, func(a, b int) int {
		if b == 0 {
			fmt.Println("除数不能为零")
			return 0
		}
		return a / b
	})
	fmt.Println(res)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

输出：

3
4
2

1
2
3
4