GO_05_2:Golang 中 panic、recover、defer 的用法

 函数 defer

  1. 它的执行方式类似其他语言中的折构函数,在函数体执行结束后按照调用顺序的 相反顺序 逐个执行

  2. 即使函数发生 严重错误 也会被执行,类似于 java 中 try{...} catch(){} finally{} 结构的 finally

  3. 支持匿名函数的调用

  4. 常用于资源清理、文件关闭、解锁以及记录时间等善后操作

  5. 通过与匿名函数配合可在 return 之后修改函数计算结果

  6. 如果函数体内某个变量作为 defer 时匿名函数的参数,则在定义 defer 时即已经获得了拷贝,否则则是引用某个变量的地址

  7. 需要注意,Go 没有异常机制,但有 panic/recover 模式来处理错误

  8. panic 可以在任何地方引发,但 recover 只有在 defer 调用的函数中有效

首先我们来验证一下 defer函数的执行顺序

package main

import "fmt"

func main() {
    fmt.Println("a")
    defer fmt.Println("b")
    defer fmt.Println("c")
    defer fmt.Println("d")
}
a
d
c
b

我们从结果就可以看出来 defer函数 执行顺序为倒着来的,即和栈相似,先进后出的顺序。

 panic/recover 函数

  Golang 有2个内置的函数 panic() 和 recover(),用以报告和捕获运行时发生的程序错误,与 error 不同,panic-recover 一般用在函数内部。一定要注意不要滥用 panic-recover,可能会导致性能问题,我一般只在未知输入和不可靠请求时使用。

  golang 的错误处理流程:当一个函数在执行过程中出现了异常或遇到 panic(),正常语句就会立即终止,然后执行 defer 语句,再报告异常信息,最后退出 goroutine。如果在 defer 中使用了 recover() 函数,则会捕获错误信息,使该错误信息终止报告。

package main

import (
    "log"
    "strconv"
)

//捕获因未知输入导致的程序异常
func catch(nums ...int) int {
    defer func() {
        if r := recover(); r != nil {
            log.Println("[E]", r)
        }
    }()

    return nums[1] * nums[2] * nums[3] //index out of range
}

//主动抛出 panic,不推荐使用,可能会导致性能问题
func toFloat64(num string) (float64, error) {
    defer func() {
        if r := recover(); r != nil {
            log.Println("[W]", r)
        }
    }()

    if num == "" {
        panic("param is null") //主动抛出 panic
    }

    return strconv.ParseFloat(num, 10)
}

func main() {
    catch(2, 8)
    toFloat64("")
}
2017/03/24 13:07:49 [E] runtime error: index out of range
2017/03/24 13:07:49 [W] param is null

  Go语言追求简洁优雅,所以,Go语言不支持传统的 try…catch…finally 这种异常,因为Go语言的设计者们认为,将异常与控制结构混在一起会很容易使得代码变得混乱。因为开发者很容易滥用异常,甚至一个小小的错误都抛出一个异常。在Go语言中,使用多值返回来返回错误。不要用异常代替错误,更不要用来控制流程。在极个别的情况下,也就是说,遇到真正的异常的情况下(比如除数为0了)。才使用Go中引入的Exception处理:defer, panic, recover。这几个异常的使用场景可以这么简单描述:Go中可以抛出一个panic的异常,然后在defer中通过recover捕获这个异常,然后正常处理。

package main

import "fmt"

func main(){
    defer func(){ // 必须要先声明defer,否则不能捕获到panic异常
        fmt.Println("c")
        if err:=recover();err!=nil{
            fmt.Println(err) // 这里的err其实就是panic传入的内容,55
        }
        fmt.Println("d")
    }()

    f()
}

func f(){
    fmt.Println("a")
    panic(55)
    fmt.Println("b")
    fmt.Println("f")
}

结果打印如下:

a
c
55
d
exit code 0, process exited normally.

  用Go实现类似 try catch 的异常处理的例子如下:

package main  

//实现 try catch 例子
func Try(fun func(), handler func(interface{})) {
    defer func() {
        if err := recover(); err != nil {
            handler(err)
        }
    }()

    fun()
}

func main() {
    Try(func() {
       panic("foo")
    }, func(e interface{}) {
       print(e)
    })
}
时间: 2024-08-06 17:46:58

GO_05_2:Golang 中 panic、recover、defer 的用法的相关文章

Golang中多用途的defer

defer顾名思义就是延迟执行,那么defer在Golang中该如何使用以及何时使用呢? A "defer" statement invokes a function whose executionis deferred to the moment the surrounding function returns, Golang的官方时这么定义的. 1.那么在什么情况下会调用defer延迟过的函数呢? 从文档中可以知道主要有两种情况: 当函数执行了return 语句后 当函数处于pan

Go语言中的panic recover defer

panic 抛出异常 recover 捕获异常 捕获后会返回外层函数继续执行 defer 函数退出之前执行 func panicOut() { print(5) panic("error") print(6) } func recoverHere() { print(3) defer func(){ err := recover() print(err) }() panicOut() print(4) } func outFunc(){ print(1) recoverHere() p

【GoLang】panic defer recover 深入理解

先等我想清楚golang错误处理 为什么要这么设计的时候 再来更新... Golang这么时尚的语言是没有类似try..catch 这种异常处理机制,而是使用 panic 和 recover处理异常. 其实相当于python的raise. golang的异常处理组合 panic,defer,recover,跟java中的try catch finially是类似的. 但是从语言的用户体验来说,不怎么好. 但考虑到golang的场景基本是系统高性能层面的,这种精准错误处理应该减少那种后遗症bug.

defer, panic, recover使用总结

1. defer : 延迟调用.多个defer,依次入栈,在函数即将退出时,依次出栈调用 1 package main 2 import "fmt" 3 func main() { 4 defer func() { 5 fmt.Println("defer one") 6 }() 7 defer func() { 8 fmt.Println("defer two") 9 }() 10 defer func() { 11 fmt.Println(&

golang中defer的正确使用方式(源自深入解析go)

3.4 defer关键字 defer和go一样都是Go语言提供的关键字.defer用于资源的释放,会在函数返回之前进行调用.一般采用如下模式: f,err := os.Open(filename) if err != nil { panic(err) } defer f.Close() 如果有多个defer表达式,调用顺序类似于栈,越后面的defer表达式越先被调用. 不过如果对defer的了解不够深入,使用起来可能会踩到一些坑,尤其是跟带命名的返回参数一起使用时.在讲解defer的实现之前先看

Golang中使用log(一):Golang 标准库提供的Log

Golang的标准库提供了log的机制,但是该模块的功能较为简单(看似简单,其实他有他的设计思路).不过比手写fmt. Printxxx还是强很多的.至少在输出的位置做了线程安全的保护.其官方手册见Golang log (天朝的墙大家懂的).这里给出一个简单使用的例子: package main import ( "log" ) func main(){ log.Fatal("Come with fatal,exit with 1 \n") } 编译运行后,会看到程

Go_18: Golang 中三种读取文件发放性能对比

Golang 中读取文件大概有三种方法,分别为: 1. 通过原生态 io 包中的 read 方法进行读取 2. 通过 io/ioutil 包提供的 read 方法进行读取 3. 通过 bufio 包提供的 read 方法进行读取 下面通过代码来验证这三种方式的读取性能,并总结出我们平时应该使用的方案,以便我们可以写出最优代码: package main import ( "os" "io" "bufio" "io/ioutil"

Golang中使用log(二):Golang 标准库log的实现

前一篇文章我们看到了Golang标准库中log模块的使用,那么它是如何实现的呢?下面我从log.Logger开始逐步分析其实现. 其源码可以参考官方地址 1.Logger结构 首先来看下类型Logger的定义: type Logger struct { mu sync.Mutex // ensures atomic writes; protects the following fields prefix string // prefix to write at beginning of each

Golang 中三种读取文件发放性能对比

Golang 中读取文件大概有三种方法,分别为: 1. 通过原生态 io 包中的 read 方法进行读取 2. 通过 io/ioutil 包提供的 read 方法进行读取 3. 通过 bufio 包提供的 read 方法进行读取 下面通过代码来验证这三种方式的读取性能,并总结出我们平时应该使用的方案,以便我们可以写出最优代码: package main import ( "os" "io" "bufio" "io/ioutil"