Go语言函数，递归，类型匿名函数，闭包，延迟调用，命令行参数，作用域

函数

定义格式：

无需前置声明，支持多返回值，支持命名返回值，支持匿名函数的闭包，支持变长参数…。

func test (x,y int)（a,b int）{
    return x + y,x * y
}

递归函数：

递归函数就是自己调用自己，相当于是在做循环，递归函数中应该有一个条件判断，条件满足则不再递归。

递归函数可以用来做循环

var i =0
func test() {
	if i < 10 {
		fmt.Println("i等于",i)
		i++
		test() //	在这里调用自己，实现递归
	}
}

函数类型：

我们可以定义一个目标函数的类型，然后给该类型的变量赋值来实现函数类型的使用，也可以直接自动推到类型赋值。

func demo(a, b int) int {
	return a + b
}
type FuncType func(a, b int) int
func main() {
	var result FuncType
	result = demo	//	不能在这里传参,这里只能写函数名
	fmt.Println(result(10, 20))
}

func demo(a,b int)int{
    return a + b
}

func main(){
    result := demo
    fmt.Println(result(10,20))
}

匿名函数:

在一个函数中定义一个函数，并且不给它命名，则这个函数为匿名函数

注意：67

func main() {
	f := func() {
		fmt.Println("这是一个匿名函数。")
	}
	f()
}

匿名函数channel传递：

func testChannel() {
	c := make(chan func(a, b int) int, 2)
	c <- func(a, b int) int {
		return a + b
	}
	println((<-c)(10, 20))
}

闭包：

一个匿名函数，通过地址引用直接使用父函数的变量，对该变量的引用就是闭包引用。

当匿名函数当作父函数返回值返回后，父函数结束，该变量还会继续存在，就形成了逃逸。

因为返回的是一个函数，所以直接调用函数后要再加()调用匿名函数

func main() {
	f := test5(123)
	f()
	test5(456)()
}

func test5(x int) func() {
	return func() {
		println(x)
	}
}

延迟调用：

函数中使用defer注册延时调用，在函数解释后，按照先进后出的顺序执行延时操作。

延迟调用一般运用于函数结束后关闭文件，链接等操作

获取命令行参数：

可以使用使用os.args获取命令行中输入的参数，参数0程序所在地址，之后是真实输入的参数

func main() {
	for key, value := range os.Args {
		fmt.Println(key, value)
	}
}

$ go run 6.命令行参数.go  123 456 789

0 /tmp/go-build290169430/b001/exe/6.命令行参数
1 123
2 456
3 789

作用域：

定义在函数内部的变量为局部变量，只能在本函数内使用。

定义在函数外部的变量为全局变量，可以供包内所有函数使用。