GoLang之错误处理

 

 

错误处理

 

error

Go语言引入了一个错误处理的标准模式，即error接口，该接口定义以下：

type error interface {
    Error() string
}

 

对于大多数函数，若是要返回错误，能够将error做为多返回值的最后一个：

func foo(param int)(ret int, err error)
{
  ...  
}

 

调用时的代码：

n, err := foo(0)
if err != nil { // 错误处理 } else { // 使用返回值n }

 

咱们还能够自定义错误类型，一个例子：

package main
 
import "fmt" import "errors" //自定义的出错结构 type myError struct { arg int errMsg string } //实现Error接口 func (e *myError) Error() string { return fmt.Sprintf("%d - %s", e.arg, e.errMsg) } //两种出错 func error_test(arg int) (int, error) { if arg < 0 { return -1, errors.New("Bad Arguments - negtive!") }else if arg >256 { return -1, &myError{arg, "Bad Arguments - too large!"} } return arg*arg, nil } //相关的测试 func main() { for _, i := range []int{-1, 4, 1000} { if r, e := error_test(i); e != nil { fmt.Println("failed:", e) } else { fmt.Println("success:", r) } } }

 

 

 

defer 

你能够在Go函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行（即最后一个defer语句将最早执行），最后该函数返回。

特别是当你在进行一些打开资源的操做时，遇到错误须要提早返回，在返回前你须要关闭相应的资源，否则很容易形成资源泄露等问题。以下代码所示，咱们通常写打开一个资源是这样操做的：

func CopyFile(dst, src string) (w int64, err error) {
    srcFile, err := os.Open(src) if err != nil { return } defer srcFile.Close() dstFile, err := os.Create(dst) if err != nil { return } defer dstFile.Close() return io.Copy(dstFile, srcFile) }

 

若是defer后面一条语句干不完清理工做，也可使用一个匿名函数：

defer func(){
    ...
}()

 

注意，defer语句是在return以后执行的，例如：

func test() (result int) {
    defer func() {
        result = 12 }() return 10 } func main() { fmt.Println(test()) // 12 }

 

 

panic() recover()

panic()函数用于抛出异常，recover()函数用于捕获异常，这两个函数的原型以下：

func panic(interface{})
func recover() interface{}

 

当在一个函数中调用panic()时，正常的函数执行流程将当即终止，但函数中以前使用defer关键字延迟执行的语句将正常展开执行，以后该函数将返回到调用函数，并致使逐层向上执行panic()流程，直至所属的goroutine中全部正在执行的函数被终止。错误信息将被报告，包括在调用panic()函数时传入的参数，这个过程称为错误流程处理。

panic()接受一个interface{}参数，可支持任意类型，例如：

panic(404)
panic("network broken") panic(Error("file not exists"))

 

在defer语句中，可使用recover()终止错误处理流程，这样能够避免异常向上传递，但要注意recover()以后，程序不会再回到panic()那里，函数仍在defer以后返回。

func foo() {
    panic(errors.New("i'm a bug")) return } func test() (result int) { defer func() { if r := recover(); r != nil { err := r.(error) fmt.Println("Cache Exception:", err) } }() foo() return 10 } func main() { fmt.Println(test()) // 0 }

 

 

 

 

 

注意，在一个函数中panic被调用后，其defer语句仍会执行，

func foo()(n int) {
    defer func() {
        if r := recover(); r != nil {
            n++    // take effective
        }
    }()
    n++             // take effective
    panic(errors.New("i'm a bug"))
    n++             // take no effective
    return n
}