Golang基础——函数，作用域，匿名函数，递归

函数：

package main

import "fmt"

func aaa(a int, b int) { // 函数的括号必须在第一行
	fmt.Println(a + b)
}

func bbb(a int, b int) int { // 有返回值的函数必须按照返回类型返回值
	fmt.Println(a + b) // 可以不调用函数
	return a + b
}

func q(args ...int) {
	fmt.Println("q")
	fmt.Println(args)
}

func p(args ...int) {
	fmt.Println(args) // args 为不定长参数，类型为 int ，多个值为： [1 2 3 4 5]
	q(args...)        // 将数组打散传参
	// 不定长参数放在参数最后，固定参数必须传值，不定长参数可以不传值
	// fmt.Println(args...) // 报错：cannot use args (type []int) as type []interface {} in argument to fmt.Println
	fmt.Println(args[:]) // 切片
}

func ccc(a, b int) (sum int) { // 返回值：定义为sum，返回时，可以只写return，return不能省略。
	sum = a + b // 返回值变量不能与参数重复，且要用括号
	return
}

func main() {
	aaa(1, 3)
	c := bbb(2, 5)
	fmt.Println(c)
	p(1, 2, 3, 4, 5) // [1 2 3 4 5]
	fmt.Println(ccc(2, 3))
	f := ccc // 函数是一等公民，函数名可以当作参数传递
	fmt.Println(ccc)
	fmt.Println("f", f(5, 5)) // 函数名是一个地址：0x937620
	fmt.Printf("%T", ccc)     // 函数类型：func(int, int) int
    var ff func(int, int) int  // 定义 ff 为一个 func(int,int) int 类型的变量，可以接受同类型的函数ccc
	ff = ccc
	ff(2, 3)
}

作用域：

// 局部作用域：
函数体内，for循环内，if初始化代码块内：
	var v = 11
	if v := 1; v == 1 {
		fmt.Println("aaa")
	}
	fmt.Println("v", v)  // 11

// 全局作用域：
定义在函数外的变量，即全局变量。
但是，在函数体内重新定义该变量时，会就近使用局部变量。

var a = 2

func test() {
	fmt.Println(a) // 2
}
func main() {
	test() // 2
	fmt.Println(&a)  // 全局变量：0xd03250
	a := 1
	fmt.Println(a) // 1
	fmt.Println(&a)  // 局部变量：0xc0000120b0
	test() // 2
}

匿名函数：

    // 闭包，没有的变量从上级找
	num := 10
	f := func() {
		num++
		fmt.Println("匿名函数")
	}
	f()
	fmt.Println(num)  // 11

	num := 1
	func() {
		num++
	}()
	fmt.Println(num)  // 2
    // num设置为形式参数，为局部变量，所以，num值传递给函数，复制了一份给局部变量，外部num不受影响，仍为1
	num := 1
	func(num int) {
		num++
	}(num)
	fmt.Println(num) // 1

	num := 10
	func() {  // 匿名函数定义必须调用， func literal evaluated but not used
		num++
		fmt.Println("匿名函数")
	}()  // 加括号直接调用匿名函数
	fmt.Println(num) // 11

	num := 10
	var fff func()
    fff = func() { // 定义的func()类型的fff变量接收匿名函数
		num++
		fmt.Println("匿名函数")
	}
	fff()
	fmt.Println(num) // 11

	func(a, b int) {
		fmt.Println(a + b)  // 3
	}(1, 2)  // 调用传值

	i, j := func(x, y int) (max, min int) {  // 返回值
		if x > y {
			max = x
			min = y
		} else {
			max = y
			min = x
		}
		return
	}(1, 3)
	fmt.Println(i, j)

	x := 11
	i, j := func(x, y int) (max, min int) {
		if x > y {
			fmt.Println(x) // 1
			max = x
			min = y
			x++
			fmt.Println(x) // 2
		} else {
			fmt.Println(x) // 1

			max = y
			min = x
			x++
			fmt.Println(x) // 2
		}
		return
	}(1, 3)
	fmt.Println(i, j) // 3 1
	fmt.Println(x)    // 11
    // 匿名函数可以定义到函数体外，但是有名函数不可以定义到函数体内
    var f = func() {
        fmt.Println("aaa")
    }

递归：

var sum = 0

func dg(num int) int {
	if num == 1 {
		return 1
	}
	num += dg(num - 1)
	return num
}