处理错误

  • Go 语言允许函数和方法同时返回多个值
  • 按照惯例，函数在返回错误时，最后边的返回值应用来表示错误。
  • 调用函数后，应立即检查是否发生错误。
    • 如果没有错误发生，那么返回的错误值为 nil。
  1.   package main
  3.   import (
  4.       "fmt"
  5.       "io/ioutil"
  6.       "os"
  7.   )
  9.   func main() {
  10.       files, err := ioutil.ReadDir(".")
  11.       if err != nil {
  12.           fmt.Println(err)
  13.           os.Exit(1)
  14.       }
  16.       for _, file := range files {
  17.           fmt.Println(file.Name())
  18.       }
  19.   }
  • 当错误发生时，函数返回的其它值通常就不再可信

优雅的错误处理

  • 减少错误处理代码的一种策略是：将程序中不会出错的部分和包含潜在错误隐患的部分隔离开来。
  • 对于不得不返回错误的代码，应尽力简化相应的错误处理代码。

Errors are values.
Don’t just check errors, handle them gracefully.
Don’t panic.
Make the zero value useful.
The bigger the interface, the weaker the abstraction.
interface{} says nothing.
Gofmt’s style is no one’s favorite, yet gofmt is everyone’s favorite.
Documentation is for users.
A little copying is better than a little dependency.
Clear is better than clever.
Concurrency is not parallelism.
Don’t communicate by sharing memory, share memory by communicating.
Channels orchestrate; mutexes serialize.

文件写入

  • 写入文件的时候可能出错：
    • 路径不正确
    • 权限不够
    • 磁盘空间不足
      …
  • 文件写入完毕后，必须被关闭，确保文件被刷到磁盘上，避免资源的泄露。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func proverbs(name string) error {
  9.     f, err := os.Create(name)
  10.     if err != nil {
  11.         return err
  12.     }
  14.     _, err = fmt.Fprintln(f, "Errors are values.")
  15.     if err != nil {
  16.         f.Close()
  17.         return err
  18.     }
  20.     _, err = fmt.Fprintln(f, "Don’t just check errors, handle them gracefully.")
  21.     f.Close()
  22.     return err
  23. }
  25. func main() {
  26.     err := proverbs("proverbs.txt")
  27.     if err != nil {
  28.         fmt.Println(err)
  29.         os.Exit(1)
  30.     }
  31. }

内置类型 error

  • 内置类型 error 用来表示错误。

defer 关键字

  • 使用 defer 关键字，Go 可以确保所有 deferred 的动作可以在函数返回前执行。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func proverbs(name string) error {
  9.     f, err := os.Create(name)
  10.     if err != nil {
  11.         return err
  12.     }
  13.     defer f.Close()
  15.     _, err = fmt.Fprintln(f, "Errors are values.")
  16.     if err != nil {
  17.         return err
  18.     }
  20.     _, err = fmt.Fprintln(f, "Don’t just check errors, handle them gracefully.")
  21.     return err
  22. }
  24. func main() {
  25.     err := proverbs("proverbs.txt")
  26.     if err != nil {
  27.         fmt.Println(err)
  28.         os.Exit(1)
  29.     }
  30. }
  • 可以 defer 任意的函数和方法。
  • defer 并不是专门做错误处理的。
  • defer 可以消除必须时刻惦记执行资源释放的负担

有创意的错误处理

  1. package main
  3. import (
  4.     "fmt"
  5.     "io"
  6.     "os"
  7. )
  9. type safeWriter struct {
  10.     w   io.Writer
  11.     err error
  12. }
  14. func (sw *safeWriter) writeln(s string) {
  15.     if sw.err != nil {
  16.         return
  17.     }
  18.     _, sw.err = fmt.Fprintln(sw.w, s)
  19. }
  20. func proverbs(name string) error {
  21.     f, err := os.Create(name)
  22.     if err != nil {
  23.         return err
  24.     }
  25.     defer f.Close()
  27.     sw := safeWriter{w: f}
  28.     sw.writeln("Errors are values.")
  29.     sw.writeln("Don’t just check errors, handle them gracefully.")
  30.     sw.writeln("Don't panic.")
  31.     sw.writeln("Make the zero value useful.")
  32.     sw.writeln("The bigger the interface, the weaker the abstraction.")
  33.     sw.writeln("interface{} says nothing.")
  34.     sw.writeln("Gofmt's style is no one's favorite, yet gofmt is everyone's favorite.")
  35.     sw.writeln("Documentation is for users.")
  36.     sw.writeln("A little copying is better than a little dependency.")
  37.     sw.writeln("Clear is better than clever.")
  38.     sw.writeln("Concurrency is not parallelism.")
  39.     sw.writeln("Don’t communicate by sharing memory, share memory by communicating.")
  40.     sw.writeln("Channels orchestrate; mutexes serialize.")
  42.     return sw.err
  43. }
  45. func main() {
  46.     err := proverbs("proverbs.txt")
  47.     if err != nil {
  48.         fmt.Println(err)
  49.         os.Exit(1)
  50.     }
  51. }

New error

  • errors 包里有一个构造用 New函数，它接收 string 作为参数用来表示错误信息。该函数返回 error 类型。 
  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "os"
  7. )
  9. const rows, columns = 9, 9
  11. // Grid is a Sudoku grid
  12. type Grid [rows][columns]int8
  14. // Set a digit on a Sudoku grid
  15. func (g *Grid) Set(row, column int, digit int8) error {
  16.     if !inBounds(row, column) {
  17.         return errors.New("out of bounds")
  18.     }
  20.     g[row][column] = digit
  21.     return nil
  22. }
  23. func inBounds(row, column int) bool {
  24.     if row < 0 || row >= rows {
  25.         return false
  26.     }
  27.     if column < 0 || column >= columns {
  28.         return false
  29.     }
  30.     return true
  31. }
  32. func main() {
  33.     var g Grid
  34.     err := g.Set(10, 0, 5)
  35.     if err != nil {
  36.         fmt.Printf("An error occurred: %v.\n", err)
  37.         os.Exit(1)
  38.     }
  39. }

按需返回错误

  • 按照惯例，包含错误信息的变量名应以 Err 开头。 
  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "os"
  7. )
  9. const rows, columns = 9, 9
  11. // Grid is a Sudoku grid
  12. type Grid [rows][columns]int8
  14. // Errors that could occur.
  15. var (
  16.     ErrBounds = errors.New("out of bounds")
  17.     ErrDigit  = errors.New("invalid digit")
  18. )
  20. // Set a digit on a Sudoku grid
  21. func (g *Grid) Set(row, column int, digit int8) error {
  22.     if !inBounds(row, column) {
  23.         return ErrBounds
  24.     }
  25.     if !validDigit(digit) {
  26.         return ErrDigit
  27.     }
  29.     g[row][column] = digit
  30.     return nil
  31. }
  33. func inBounds(row, column int) bool {
  34.     if row < 0 || row >= rows {
  35.         return false
  36.     }
  37.     if column < 0 || column >= columns {
  38.         return false
  39.     }
  40.     return true
  41. }
  42. func validDigit(digit int8) bool {
  43.     return digit >= 1 && digit <= 9
  44. }
  46. func main() {
  47.     var g Grid
  48.     err := g.Set(0, 0, 15)
  49.     if err != nil {
  50.         switch err {
  51.         case ErrBounds, ErrDigit:
  52.             fmt.Println("Les erreurs de paramètres hors limites.")
  53.         default:
  54.             fmt.Println(err)
  55.         }
  56.         os.Exit(1)
  57.     }
  58. }
  • errors.New 这个构造函数是使用指针实现的，所以上例中的 switch 语句比较的是内存地址，而不是错误包含的文字信息。

自定义错误类型

  • error 类型是一个内置的接口：任何类型只要实现了返回 string 的 Error() 方法就满足了该接口。
  • 可以创建新的错误类型。 
  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "os"
  7.     "strings"
  8. )
  10. const rows, columns = 9, 9
  12. // Grid is a Sudoku grid
  13. type Grid [rows][columns]int8
  15. // Errors that could occur.
  16. var (
  17.     ErrBounds = errors.New("out of bounds")
  18.     ErrDigit  = errors.New("invalid digit")
  19. )
  21. // SudokuError is a slice of errors.
  22. type SudokuError []error
  24. // Error returns one or more errors separated by commas.
  25. func (se SudokuError) Error() string {
  26.     var s []string
  27.     for _, err := range se {
  28.         s = append(s, err.Error())
  29.     }
  30.     return strings.Join(s, ", ")
  31. }
  33. // Set a digit on a Sudoku grid
  34. func (g *Grid) Set(row, column int, digit int8) error {
  35.     var errs SudokuError
  36.     if !inBounds(row, column) {
  37.         errs = append(errs, ErrBounds)
  38.     }
  39.     if !validDigit(digit) {
  40.         errs = append(errs, ErrDigit)
  41.     }
  42.     if len(errs) > 0 {
  43.         return errs
  44.     }
  46.     g[row][column] = digit
  47.     return nil
  48. }
  50. func inBounds(row, column int) bool {
  51.     if row < 0 || row >= rows {
  52.         return false
  53.     }
  54.     if column < 0 || column >= columns {
  55.         return false
  56.     }
  57.     return true
  58. }
  60. func validDigit(digit int8) bool {
  61.     return digit >= 1 && digit <= 9
  62. }
  64. func main() {
  65.     var g Grid
  66.     err := g.Set(10, 0, 15)
  67.     if err != nil {
  68.         if errs, ok := err.(SudokuError); ok {
  69.             fmt.Printf("%d error(s) occurred:\n", len(errs))
  70.             for _, e := range errs {
  71.                 fmt.Printf("- %v\n", e)
  72.             }
  73.         }
  74.         os.Exit(1)
  75.     }
  76. }
  • 按照惯例，自定义错误类型的名字应以 Error 结尾。
    • 有时候名字就是 Error，例如 url.Error

类型断言

  • 上例中，我们可以使用类型断言来访问每一种错误。
  • 使用类型断言，你可以把接口类型转化成底层的具体类型。
    • 例如：err.(SudokuError)
  • 如果类型满足多个接口，那么类型断言可使它从一个接口类型转化为另一个接口类型。

不要恐慌（don’t panic）

  • Go 没有异常，它有个类似机制 panic。
  • 当 panic 发生，那么程序就会崩溃。

其它语言的异常 vs Go 的错误值

  • 其它语言的异常在行为和实现上与 Go 语言的错误值有很大的不同：
    • 如果函数抛出异常，并且附近没人捕获它，那么它就会“冒泡”到函数的调用者那里，如果还没有人进行捕获，那么就继续“冒泡”到更上层的调用者… 直到达到栈（Stack）的顶部（例如 main 函数）。
    • 异常这种错误处理方式可被看作是可选的：
      • 不处理异常，就不需要加入其它代码。
      • 想要处理异常，就需要加入相当数量的专用代码。
    • Go 语言中的错误值更简单灵活:
      • 忽略错误是有意识的决定，从代码上看也是显而易见的。

如何 panic

  • Go 里有一个和其他语言异常类似的机制：panic。
  • 实际上，panic 很少出现。
  • 创建 panic：
    • panic(“I forgot my towel”)
      • panic 的参数可以是任意类型

错误值、panic、os.Exit ?

  • 通常，更推荐使用错误值，其次才是 panic。
  • panic 比 os.Exit 更好：panic 后会执行所有 defer 的动作，而 os.Exit 则不会。
  • 有时候 Go 程序会 panic 而不是返回错误值（比如执行除零计算）

保持冷静并继续

  • 为了防止 panic 导致程序崩溃，Go 提供了 recover 函数。
  • defer 的动作会在函数返回前执行，即使发生了 panic。
  • 但如果 defer 的函数调用了 recover，panic 就会停止，程序将继续运行。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     defer func() {
  7.         if e := recover(); e != nil {
  8.             fmt.Println(e)
  9.         }
  10.     }()
  12.     panic("I forgot my towel")
  13. }

作业题

  • 编写一个程序：
    • 在 Go 标准库里，有个函数可以解析网址（golang.org/pkg/net/url/#Parse）：
    • 使用一个非法网址传递到 url.Parse 函数，把发生的错误显示出来。
    • 使用 %#v 和 Printf 打印错误，看看都显示什么。
    • 然后执行 *url.Error 类型断言，来访问和打印底层结构体的字段和内容。
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/url"
  6.     "os"
  7. )
  9. func main() {
  10.     u, err := url.Parse("https://a b.com/")
  12.     if err != nil {
  13.         fmt.Println(err)
  14.         fmt.Printf("%#v\n", err)
  16.         if e, ok := err.(*url.Error); ok {
  17.             fmt.Println("Op:", e.Op)
  18.             fmt.Println("URL:", e.URL)
  19.             fmt.Println("Err:", e.Err)
  20.         }
  21.         os.Exit(1)
  22.     }
  24.     fmt.Println(u)
  25. }