四、函数

1.普通参数列表

func main() {
	car("奔驰")
	car("宝马")
}

func car(name string) {
	fmt.Println(name, "，汽车开跑了。。。")
}

2.不定参数列表

• 使用不定参数时，一定（只能）放在形参中的最后一个参数。
• 在对函数进行调用时，固定参数必须传值，不定参数可以根据需要来决定是否要传值。

func main() {
	sum(1, 2, 3)  //6
	sum1(1, 2, 3) //6
	test(1, 2, 3, 4, 5)
}

func sum(arrs ...int) {
	var sum int = 0
	for
	i := 0;
		i < len(arrs);
	i++ {
		sum += arrs[i]
	}
	fmt.Println(sum)
}

func sum1(arrs ...int) {
	var sum int = 0
	//i那里可以使用匿名变量_，这里数组下标并没用
	for i, arr := range arrs {
		fmt.Println(i) //数组下标
		sum += arr
	}
	fmt.Println(sum)
}

func test(arrs ...int) {
	//sum1()  //0 不定参数，没有固定参数，那么在调用时，可以根据需要来决定是否进行传值。
	//sum1(arrs...)     //15 全部将数据传递给sum2
	//sum1(arrs[3:]...) //9 将下标为2(包含)以后的数据全部传递
	sum1(arrs[:3]...) //6 将下标为2(不包含)以前的数据全部传递
}

3.函数返回值

func main() {
	res := sum(1, 2, 3)
	fmt.Println(res)  //6
	fmt.Println(sum1(1, 2, 3))  //6
	fmt.Println(sum2(1, 2, 3))  //6
}

func sum(arrs ...int) int {
	var sum int = 0
	for _, arr := range arrs {
		sum += arr
	}
	return sum
}

func sum1(arrs ...int) (sum int) { //给返回值命名
	for _, arr := range arrs {
		sum += arr
	}
	return sum
}

func sum2(arrs ...int) (sum int) { //给返回值命名
	for _, arr := range arrs {
		sum += arr
	}
	return //只写return就可以
}

4.函数返回多个值

func main() {
	num, sum := sum(1, 2, 3)
	fmt.Println(num, sum) //3 6
}

func sum(arrs ...int) (num int, sum int) {
	for _, arr := range arrs {
		sum += arr
	}
	return len(arrs), sum
}

5.函数类型

• 函数类型就是将函数作为一种类型可以用来定义变量

func Sum(a int, b int) (sum int) {
	sum = a + b
	return sum
}

func Ride(a int, b int) (sum int) {
	sum = a * b
	return sum
}

type SumType func(a int, b int) int //定义函数类型

func main() {
	var res int
	var sum SumType //定义函数类型的变量

	sum = Sum //sum指向Sum函数，求总和
	res = sum(10, 20)
	fmt.Println(res) //30

	sum = Ride //sum指向Ride函数，求乘积
	res = sum(10, 20)
	fmt.Println(res) //200
}

6.匿名函数

func main() {
	var num int = 9
	f := func() {
		num ++
		fmt.Println("匿名函数：", num) //匿名函数： 10
	}
	fmt.Println(num) //9
	f()
	fmt.Println("main函数：", num) //main函数： 10
}

• 输出结果：

9
匿名函数： 10
main函数： 10

• 匿名函数还有其它调用方式如下：

func main() {
	var num int = 9
	f := func() {
		num ++
		fmt.Println("匿名函数：", num) //匿名函数： 10
	}
	type FuncType func()
	var f1 FuncType
	f1 = f
	f1()
	fmt.Println("main函数：", num) //main函数： 10
}

• 定义匿名函数时，直接调用：需要在匿名函数的末尾加上小括号，表示调用。

func main() {
	var num int = 9
	func() {
		num ++
		fmt.Println("匿名函数：", num) //匿名函数： 10
	}()
	fmt.Println("main函数：", num) //main函数： 10
}

• 如果无参数、无返回值的匿名函数还可以像下面这样写，并且直接调用。

func main() {
	{
		fmt.Println("hello world")
	}
}

7.闭包

• 所谓的闭包是指有权访问另一个函数作用域中的变量的函数，就是在一个函数内部创建另一个函数。
• 在Go语言里，所有的匿名函数(Go语言规范中称之为函数字面量)都是闭包。

func main() {
	//虽然Test( )函数调用了三次，但是输出都是1.原因是：每次调用Test( )函数，都是重新声明变量x，当函数执行完成后，x会自动被释放所占资源。
	fmt.Println(Test())
	fmt.Println(Test())
	fmt.Println(Test())

	f := Test1()
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
}

func Test() int {
	var x int
	x++
	return x
}

//在定义Test( )函数时指定了返回的类型是一个匿名函数，并且该匿名函数返回的类型是整型。
func Test1() func() int {
	var x int
	return func() int {
		x++
		return x
	}
}

• 输出结果：

1
1
1
1
2
3

8.延迟调用defer

• 关键字 defer 用于延迟一个函数的执行。注意，defer语句只能出现在函数的内部。
• 如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。

func main() {
	//copyFile()
	copyFile1()
}

func copyFile() int {
	fmt.Println("打开源文件！")
	fmt.Println("创建目标文件！")
	fmt.Println("复制文件！") //如果这里报错了，就不会执行后面的关闭文件代码
	fmt.Println("关闭源文件")
	fmt.Println("关闭目标文件")
	return 0
}

//defer
func copyFile1() int {
	fmt.Println("打开源文件！")
	defer fmt.Println("关闭源文件") //后执行，defer相当于java的finally
	fmt.Println("创建目标文件！")
	defer fmt.Println("关闭目标文件") //先执行
	fmt.Println("复制文件！")
	return 0
}

• 输出结果：

打开源文件！
创建目标文件！
复制文件！
关闭目标文件
关闭源文件