Go学习.4

func 函数名(参数)(返回值){
函数体
}
函数名：由字母、数字、下划线组成，不能重名。
参数：参数由参数变量和参数变量的类型组成，多个参数之间使用",“分隔。
返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用”,"分隔。
函数体：实现指定功能的代码块。

函数调用
通过函数名调用

参数
Go语言中有可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加…来标识。
注意：可变参数通常要作为函数的最后一个参数。

如 func funcA(x…int){}

返回值
return 输出返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来。
func a(x, y int)(int ,int){}

返回值命名
函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。
例：

func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

变量作用域

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。 在函数中可以访问到全局变量。
局部变量分两种：函数内，语句块定义（其实就是作用域不同罢了）

局部变量和全局变量重名，优先访问局部变量

函数类型与变量
我们可以使用type关键字来定义一个函数类型

type a func(int, int) int
上面语句定义了一个a类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。

函数类型变量

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

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

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

高阶函数
函数可作为参数，返回值

匿名函数和闭包

匿名函数就是没有函数名的函数

func(参数)(返回值){
函数体
}
匿名函数需要保存到某个变量或者作为立即执行函数

闭包
闭包指的是一个函数和与其相关的引用环境组合而成的实体。
例：

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也一直有效。
闭包=函数+引用环境

derfer
Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

defer执行时机
在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。

例：

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

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

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())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

输出 ：

5
8
5
5

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

输出：

A 1 2 3
B 10 2 12
BB 10 12 22
AA 1 3 4