Go语言学习（六）| 函数
函数的定义
关键字 func 用来声明一个函数
func functionName(parameter type) returnType {
// 函数体
}函数中的参数列表和返回值并非是必须的
func functionName(parameter type) {
// 函数体
}如果有连续若干个参数，它们的类型一致，那么我们无须一一罗列，只需在最后一个参数后添加该类型。例：
func calc(num, price int) int {
return price * num
}多返回值
Go 语言支持一个函数可以有多个返回值括号，同时可以命名返回值。一旦命名了返回值，可以认为这些值在函数第一行就被声明为变量了。如果有连续若干个返回值，它们的类型一致，那么我们无须一一罗列，只需在最后一个返回值后添加该类型。
例：
package main
func main() {
s := Factorial(4)
println(s)
}
func Factorial(x int) int {
var result int
if x == 0 {
result = 1
} else {
result = x * Factorial(x-1)
}
return result
}也可以上述例子改为：例：
package main
func main() {
s := Factorial(4)
println(s)
}
func Factorial(x int) (result int) {
if x == 0 {
result = 1
} else {
result = x * Factorial(x-1)
}
return
}官方建议：最好命名返回值，因为不命名返回值，虽然代码更加简洁了，但是会造成生成的文档可读性差。保留函数
init函数（能够应用于所有的package）main函数（只能应用于package main）。
这两个函数在定义时不能有任何的参数和返回值。Go程序会自动调用 init() 和 main() ，所以你不需要在任何地方调用这两个函数。每个 package 中的 init 函数都是可选的，但 package main 就必须包含一个main函数。
变参
接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：
func funcName(arg ...int) {
}arg ... int 告诉 Go 这个函数接受不定数量的参数。
注意 这些参数的类型全部是 int。在函数体中，变量 arg 是一个 int 类型的 slice
例：
package main
import "fmt"
func main() {
test("a", "b")
test("Hello", "world", "你好")
}
func test(arg ...string) {
for _, val := range arg {
fmt.Printf("%s\n", val)
}
}函数作为值
上例也可以这样：
package main
import "fmt"
func main() {
demo := func(arg ...string) { //定义一个匿名函数，并且赋值给demo
for _, val := range arg {
fmt.Printf("%s\n", val)
}
}
demo("a", "b")
}函数作为值也可以用在其他地方，如 map 。例：
package main
import "fmt"
func main() {
map1 := map[int]func(i int) int{
1: func(x int) int { return x + 1 },
2: func(y int) int { return y + 2 },
3: func(z int) int { return z + 3 },
}
fmt.Printf("%d\n", map1[1](1))
fmt.Printf("%d\n", map1[2](1))
fmt.Printf("%d\n", map1[3](1))
}回调函数
例：
package main
import "fmt"
func main() {
callback(2, printit)
}
func printit(x int) {
fmt.Printf("%d\n", x)
}
func callback(y int, f func(int)) {
f(y)
}输出结果：2
例2：
package main
import "fmt"
func main() {
callback(2, printit)
}
func printit(x int) (demo int) {
demo = x + 1
return
}
func callback(y int, f func(int) int) {
result := f(y)
res := fmt.Sprintf("%d", result) + "demo" // Sprintf()将int转换成string
fmt.Printf("%s\n", res)
}输出结果：3demo
传值和传指针
例3：
package main
import "fmt"
//简单的一个函数，实现了参数+1的操作
func add1(a *int) int { // 请注意，
*a = *a + 1 // 修改了a的值
return *a // 返回新值
}
func main() {
x := 3
fmt.Println("x = ", x) // 应该输出 "x = 3"
x1 := add1(&x) // 调用 add1(&x) 传x的地址
fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
fmt.Println("x = ", x) // 应该输出 "x = 4"
}变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有 add1 函数知道 x 变量所在的地址，才能修改 x 变量的值。所以我们需要将x所在地址 &x 传入函数，并将函数的参数的类型由int改为 *int ，即改为指针类型，才能在函数中修改 x 变量的值。此时参数仍然是按 copy 传递的，只是 copy 的是一个指针。
函数传递指针的好处：
- 传指针使得多个函数能操作同一个对象。
- 传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次 copy 上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。
Go语言中 string ， slice ， map 这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变 slice 的长度，则仍需要取地址传递指针）
延迟代码 defer
package main
func ReadWrite() bool {
file.Open("file")
// 做一些工作
if failureX {
file.Close()
return false
}
if failureY {
file.Close()
return false
}
file.Close()
return true
}在这里有许多重复的代码。为了解决这些，Go 有了 defer 语句。在 defer 后指定的函数会在函数退出前调用。可改为如下代码：
package main
func ReadWrite() bool {
file.Open("file")
defer file.Close() //file.Close() 被添加到了 defer 列表
// 做一些工作
if failureX {
return false // Close() 现在自动调用
}
if failureY {
return false // 这里Close() 也将自动调用
}
return true
}defer 有点类似于 PHP 类中的 __destruct() 析构方法。 defer 也可以这样写：
defer func(x int) {
//
}(5)如果有很多调用 defer ，那么 defer 是采用后进先出模式
package main
func main() {
for j := 0; j < 5; j++ {
defer println(j)
}
}输出:43210
例：
package main
func main() {
s := test(2)
println(s)
}
func test(i int) (t int) {
defer func() {
t++
}()
t = i + 1
return
}输出结果：4
例2：
package main
func main() {
s := test(2)
println(s)
}
func test(i int) (t int) {
defer func(x int) {
t += x
}(5)
t = i + 1
return
}输出结果：8
在 Go 中函数也是一种变量，可以通过 type 来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型
例：
package main
import "fmt"
type testInt func(int) bool //声明了一个函数类型
func main() {
slice := []int{1, 2, 4, 5, 7}
fmt.Println("slice = ", slice)
odd := filter(slice, isOdd) //函数当做值来传递了
fmt.Println("Odd elements of slice are: ", odd)
even := filter(slice, isEven) //函数当做值来传递了
fmt.Println("Even elements of slice are: ", even)
}
func isOdd(integer int) bool {
if integer%2 == 0 {
return false
}
return true
}
func isEven(integer int) bool {
if integer%2 == 0 {
return true
}
return false
}
//声明的函数在这个地方当做了一个参数
func filter(slice []int, f testInt) []int {
var result []int
for _, value := range slice {
if f(value) {
result = append(result, value)
}
}
return result
}返回结果：slice = [1 2 3 4 5 7]Odd elements of slice are: [1 3 5 7]Even elements of slice are: [2 4]
Panic和Recover
panic
panic 是用来表示非常严重的不可恢复的错误的。在 Go 语言中这是一个内置函数，接收一个 interface{} 类型的值（也就是任何值了）作为参数。panic 的作用就像我们平常接触的异常。不过Go可没有 try…catch ，所以， panic 一般会导致程序挂掉（除非 recover ）。所以，Go语言中的异常，那真的是异常了。但是，关键的一点是，即使函数执行的时候panic了，函数不往下走了，运行时并不是立刻向上传递 panic ，而是到defer那，等defer的东西都跑完了， panic 再向上传递。所以这时候 defer 有点类似 try-catch-finally 中的 finally。
recover
Go语言提供了 recover 内置函数，前面提到，一旦 panic ，逻辑就会走到 defer 那，那我们就在 defer 那等着，调用 recover 函数将会捕获到当前的 panic （如果有的话），被捕获到的 panic 就不会向上传递了，于是，世界恢复了和平。你可以干你想干的事情了。
不过要注意的是， recover 之后，逻辑并不会恢复到 panic 那个点去，函数还是会在 defer 之后返回。