GoLang入门D6

今天学习函数

1. 函数参数用值传递的形式
2. 允许多值返回，若只有单值，可以不声明
3. 不允许函数嵌套

延迟代码
若有多个defer，defer的执行方式是LIFO，也就是栈。defer在函数结束之前调用。

package main

import (
	"fmt"
)

func main() {
	s := [5]float32{1.2, 3, 6.6, 8, 5}
	for i := 0; i < 5; i++ {
		defer fmt.Printf("%f   ", s[i])
	}
}

输出

5.000000   8.000000   6.600000   3.000000   1.200000   

defer在其环境周围return之前不会被立即调用，但是其中的参数和返回值都会被求值。

package main

import (
	"fmt"
	"time"
)


//返回值是匿名函数
func f() func() {
	t := time.Now()
	fmt.Println("in f()")
	return func() {
		fmt.Println(time.Since(t))
	}
}

func g() {
	defer f()()
	time.Sleep(5 * time.Second)
}

func main() {
	g()
}

输出

in f()
5.0004516s

可以看到，先输出in f()，过五秒再输出5.0004516s
变参
假如不指定变参的类型，默认是空接口 []interface{}

package main

import (
	"fmt"
)
//这里的参数是int类型的slice
func f(arg ...int) {
	for _, k := range arg {
		fmt.Println(k)
	}
}

func g(arg ...int) {
	f(arg[2:]...)
}

func main() {
	a := [...]int{1, 1, 2, 2, 3, 4, 5}
	g(a[0:]...)
}

输出

2
2
3
4
5

函数作为值
函数可以作为函数参数（回调）、函数返回值、map值类型

package main

import (
	"fmt"
)

func main() {
	var xs = map[int]func() int{
		1: func() int { return 100 },
		2: func() int { return 200 },
		3: func() int { return 300 },
	}
	for _, k := range xs {
		fmt.Println(k)
	}
}

输出是三个函数地址
Panic&Recover
panic()，recover()都是内建函数
恐慌可以通过调用panic产生，也可以由运行时错误产生，函数f()陷入恐慌后，跳回调用f()的地方，再继续跳回直至程序崩溃，所有gorutine返回。
recover()仅在恐慌中有效，使恐慌的gorutine恢复，正常执行的函数调用recover会返回nil。
下面是一个检查恐慌是否产生的函数。

func throwPanic(f func()) (b bool){
	defer func(){
		if x:=recover();x!=nil{
			b=true
		}
	}()
	f()
	return
}