08Go语言的函数

函数的声明

• 注意

1. GO语言的函数可以返回多个值；
2. 返回值类型，在最后
3. 入参，类型在参数后面
4. 参数类型一致，可以简写在一起

func funcName(parametername type1,parametername type2)(output1 type1,output2 type2){
 return value1,value2
}
func funSum(a,b int) {
	fmt.Println(a+b)
}

可变参数

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

参数传递

分为值类型，引用类型
注意，数组在GO语言中是值类型。

函数的返回值

func getSum2() int {
	sum := 0
	for i := 0; i < 5; i++ {
		sum += i
	}
	return sum
}
func getSum3() (sum int) {
	for i := 0; i < 5; i++ {
		sum += i
	}
	return
}

• 多返回值

func addMult(a,b int)(int,int) {
	return a+b,a*b
}
func addMult2(a,b int)(ab1,ab2 int) {
	ab1=a+b
	ab2=a*b
	return 
}

空白标识符_,可以丢弃不需要的多返回值

defer

延迟函数，可以将函数延迟执行。

1. 多个延迟函数，执行顺序参考先进后出的原则
2. 延迟执行，但不会延迟赋值，赋值在defer调用的时候就进行赋值了
3. defer会在return之前执行

func main() {
	//多个defer ，先进后出
	defer fun1()
	defer fun2()
	//延迟执行，但赋值不是延迟的
	a := 2
	defer fun3(a)
	a++
	//fun4中defer 会在fun4方法return 前执行
	fmt.Println(fun4())
}
func fun4() int {
	defer fmt.Println("在return 0 之前执行")
	return 0
}

func fun3(a int) {
	fmt.Println("fun3:a=" + strconv.Itoa(a))
}
func fun1() {
	fmt.Println("fun1")
}
func fun2() {
	fmt.Println("fun2")
}

//在return 0 之前执行
//0
//fun3:a=2
//fun2
//fun1

定义函数类型变量

感觉好像JS

	var f func()
	f = fun1
	f()
	f2 := fun2
	f2()

匿名函数

也感觉好像js

	f3 := func(a, b int) {
		fmt.Println(a)
		fmt.Println(b)
	}
	f3(1, 2)

回调函数

还是感觉好像JS

func main() {
	fmt.Println(oper(1, 2, add))
	fmt.Println(oper(1, 2, sub))
}
func oper(a, b int, fun func(int, int) int) int {
	return fun(a, b)
}
func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}

闭包

内层函数引用了外层的函数的变量，这种情况称为闭包，闭包函数局部变量的声明周期发生改变，不随外层函数的结束而结束。

func main() {
	res1 := inc()
	fmt.Println(res1())
	fmt.Println(res1())
	fmt.Println(res1())
	res2 := inc()
	fmt.Println(res2())
}
func inc() func() int {
	i := 0
	fun := func() int {
		i++
		return i
	}
	return fun
}