1. 异常处理

    Golang 没有结构化异常，使用 panic 抛出错误，recover 捕获错误。

    异常的使用场景简单描述：Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。

    panic：

    recover：

    2.     2、用来控制一个goroutine的panicking行为，捕获panic，从而影响应用的行为
    3.     3、一般的调用建议
    4.         a). 在defer函数中，通过recever来终止一个goroutine的panicking过程，从而恢复正常代码的执行
    5.         b). 可以获取通过panic传递的error

    注意:

    1.     1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。
    2.     2.recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。
    3.     3.多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。
    1. package main
    3. func main() {
    4.     test()
    5. }
    7. func test() {
    8.     defer func() {
    9.         if err := recover(); err != nil {
    10.             println(err.(string)) // 将 interface{} 转型为具体类型。
    11.         }
    12.     }()
    14.     panic("panic error!")
    15. }

    输出结果：

    1.     panic error!

    由于 panic、recover 参数类型为 interface{}，因此可抛出任何类型对象。

    1.     func panic(v interface{})
    2.     func recover() interface{}
    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func main() {
    8.     defer func() {
    9.         if err := recover(); err != nil {
    10.             fmt.Println(err)
    11.         }
    12.     }()
    14.     var ch chan int = make(chan int, 10)
    15.     close(ch)
    16.     ch <- 1
    17. }

    输出结果：

    延迟调用中引发的错误，可被后续延迟调用捕获，但仅最后一个错误可被捕获。

    1. package main
    3. import "fmt"
    5. func test() {
    6.     defer func() {
    7.         fmt.Println(recover())
    8.     }()
    10.     defer func() {
    11.     }()
    13.     panic("test panic")
    14. }
    16. func main() {
    17.     test()
    18. }

    输出:

    1.     defer panic

    捕获函数 recover 只有在延迟调用内直接调用才会终止错误，否则总是返回 nil。任何未捕获的错误都会沿调用堆栈向外传递。

    1. package main
    3. import "fmt"
    5. func test() {
    6.     defer func() {
    7.         fmt.Println(recover()) //有效
    8.     }()
    9.     defer recover()              //无效！
    10.     defer fmt.Println(recover()) //无效！
    11.     defer func() {
    12.         func() {
    13.             println("defer inner")
    14.             recover() //无效！
    15.         }()
    16.     }()
    18.     panic("test panic")
    19. }
    21. func main() {
    22.     test()
    23. }

    输出:

    1.     defer inner
    2.     <nil>
    3.     test panic

    使用延迟匿名函数或下面这样都是有效的。

    1. package main
    3. import (
    4.     "fmt"
    5. )
    7. func except() {
    8.     fmt.Println(recover())
    9. }
    11. func test() {
    12.     defer except()
    13.     panic("test panic")
    14. }
    16. func main() {
    17.     test()

    输出结果：

      输出结果：

      1.     x / y = 0

      除用 panic 引发中断性错误外，还可返回 error 类型错误对象来表示函数调用状态。

      1. type error interface {
      2.     Error() string
      3. }

      标准库 errors.New 和 fmt.Errorf 函数用于创建实现 error 接口的错误对象。通过判断错误对象实例来确定具体错误类型。

      1. package main
      3. import (
      4.     "errors"
      5.     "fmt"
      6. )
      8. var ErrDivByZero = errors.New("division by zero")
      10. func div(x, y int) (int, error) {
      11.     if y == 0 {
      12.         return 0, ErrDivByZero
      13.     }
      14.     return x / y, nil
      15. }
      17. func main() {
      18.     defer func() {
      19.         fmt.Println(recover())
      20.     }()
      21.     switch z, err := div(10, 0); err {
      22.     case nil:
      23.         println(z)
      24.     case ErrDivByZero:
      25.         panic(err)
      26.     }
      27. }

      输出结果：

      1.     division by zero

      Go实现类似 try catch 的异常处理

      1. package main
      3. import "fmt"
      5. func Try(fun func(), handler func(interface{})) {
      6.     defer func() {
      7.         if err := recover(); err != nil {
      8.             handler(err)
      9.         }
      10.     }()
      11.     fun()
      12. }
      14. func main() {
      15.     Try(func() {
      16.         panic("test panic")
      17.     }, func(err interface{}) {
      18.         fmt.Println(err)
      19.     })

      输出结果：

      1.     test panic

      如何区别使用 panic 和 error 两种方式?