函数

go 语言中的函数依然是作为一等对象实现的，和 C++ 相比它不支持重载，也不支持默认值；方法下也比较简单，下面定义一个返回 "hello" 的函数

package main

import "fmt"

func greeting(name string) string {
    return "hello " + name
}

func main() {
    message := greeting("tom")
    fmt.Println(message)
}

运行效果

go run .
hello tom

---

多返回值

go 语言中的函数可以一次返回多个值

package main

import "fmt"

func fun_a(name string) (int, string) {
    return 100, "一百"
}

func main() {
    ivalue, svalue := fun_a("tom")
    fmt.Println(ivalue, svalue)
}

运行效果

go run .
100 一百

---

defer

defer 用于在函数执行完成之后执行一段逻辑，注意这段逻辑的执行时间在 return 语句之后。

package main

import "fmt"

var global_value int = 100

func fun_a() int {
    // 1. 在函数结束之后再执行的钩子
    defer func() {
        fmt.Printf("执行 defer 钩子函数 \n")
        global_value = 200
    }()

    // 2. 直接 return
    fmt.Printf("fun_a 准备 return \n")
    return global_value
}

func main() {
    // 3. 取得返回值
    var i int = fun_a()
    fmt.Printf("i = %d , global_value = %d \n", i, global_value)
}

运行效果

go run .
fun_a 准备 return 
执行 defer 钩子函数 
i = 100 , global_value = 200

从实践上看，这个功能多被用来执行类似于 close 这样的函数，与异常处理。

---

异常处理

go 语言中没有 try-catch-finally 这样的结构，而是依赖于 recover 和 panic 这组函数。

recover 捕获异常

package main

import "fmt"

var global_value int = 100

func test_fun() int {
    defer func() {
        // 2. 处理异常
        var err = recover()
        fmt.Printf("开始错误处理，异常信息为：%s", err)
    }()
    var result = global_value - 100
    return result
}

func main() {
    // 1. 触发异常
    var _ int = test_fun()
}

运行效果

go run .
开始错误处理，异常信息为：%!s(<nil>)%   

可以看到这个异常信息不太可读，我们可以通过自己调用 panic 函数来处理这个事。

package main

import "fmt"

var global_value int = 100

func test_fun() int {
    defer func() {

        var err = recover()
        fmt.Printf("开始错误处理，异常信息为：'%s' \n", err)
    }()
    panic("遇到了一个解决不了的错误")

    // 由于前面 panic 了所以条 return 语句是不可能被执行了
    return global_value
}

func main() {
    var v int = -1
    // 虽然 test_fun 函数的调用出错了，但是 v 的值会被设置为函数返回值的零值
    v = test_fun()
    fmt.Printf("v = %d \n", v)

}

运行效果

go run .
开始错误处理，异常信息为：'遇到了一个解决不了的错误' 
v = 0 

---