这是所有自定义包实现者应该遵守的最佳实践：

    1）在包内部，总是应该从 panic 中 recover：不允许显式的超出包范围的 panic ()

    2）向包的调用者返回错误值（而不是 panic）。

    在包内部，特别是在非导出函数中有很深层次的嵌套调用时，对主调函数来说用 panic 来表示应该被翻译成错误的错误场景是很有用的（并且提高了代码可读性）。

    这在下面的代码中被很好地阐述了。我们有一个简单的 parse 包（示例 13.4）用来把输入的字符串解析为整数切片；这个包有自己特殊的 ParseError。

    当没有东西需要转换或者转换成整数失败时，这个包会 panic（在函数 fields2numbers 中）。但是可导出的 Parse 函数会从 panic 中 recover 并用所有这些信息返回一个错误给调用者。为了演示这个过程，在 panic_recover.go 中 调用了 parse 包（示例 13.4）；不可解析的字符串会导致错误并被打印出来。

    示例 13.4 parse.go：

    1. // parse.go
    2. package parse
    4. import (
    5.     "fmt"
    6.     "strings"
    7.     "strconv"
    8. )
    10. // A ParseError indicates an error in converting a word into an integer.
    11. type ParseError struct {
    12.     Index int      // The index into the space-separated list of words.
    13.     Word  string   // The word that generated the parse error.
    14.     Err error // The raw error that precipitated this error, if any.
    15. }
    17. // String returns a human-readable error message.
    18. func (e *ParseError) String() string {
    19.     return fmt.Sprintf("pkg parse: error parsing %q as int", e.Word)
    20. }
    22. // Parse parses the space-separated words in in put as integers.
    23. func Parse(input string) (numbers []int, err error) {
    24.     defer func() {
    25.         if r := recover(); r != nil {
    26.             var ok bool
    27.             err, ok = r.(error)
    28.             if !ok {
    29.                 err = fmt.Errorf("pkg: %v", r)
    30.             }
    31.         }
    32.     }()
    34.     fields := strings.Fields(input)
    35.     numbers = fields2numbers(fields)
    36.     return
    37. }
    39. func fields2numbers(fields []string) (numbers []int) {
    40.     if len(fields) == 0 {
    41.         panic("no words to parse")
    42.     }
    43.     for idx, field := range fields {
    44.         num, err := strconv.Atoi(field)
    45.         if err != nil {
    46.             panic(&ParseError{idx, field, err})
    47.         }
    48.         numbers = append(numbers, num)
    49.     }
    50.     return
    51. }

    示例 13.5 panic_package.go：

    1. // panic_package.go
    2. package main
    4. import (
    5.     "fmt"
    6.     "./parse/parse"
    7. )
    9. func main() {
    10.     var examples = []string{
    11.             "1 2 3 4 5",
    12.             "100 50 25 12.5 6.25",
    13.             "2 + 2 = 4",
    14.             "1st class",
    15.             "",
    16.     }
    18.     for _, ex := range examples {
    19.         fmt.Printf("Parsing %q:\n  ", ex)
    20.         nums, err := parse.Parse(ex)
    21.         if err != nil {
    22.             fmt.Println(err) // here String() method from ParseError is used
    23.             continue
    24.         }
    25.         fmt.Println(nums)
    26.     }
    27. }

    输出：

    1. Parsing "1 2 3 4 5":
    2.   [1 2 3 4 5]
    3. Parsing "100 50 25 12.5 6.25":
    4.   pkg parse: error parsing "12.5" as int
    5. Parsing "2 + 2 = 4":
    6.   pkg parse: error parsing "+" as int
    7. Parsing "1st class":
    8.   pkg parse: error parsing "1st" as int
    9. Parsing "":
    10.   pkg: no words to parse