错误处理的话题足够有趣，为了保持零件的数量，我决定将其分成几个部分：
.error处理

.error包装

错误处理
我如何在Go中尝试捕捉异常？在go中，error 是数值。这意味着，error 不是"抛出"，而是一个返回值，就像其他的值一样。例如，要打开一个文件：

f, err := os.Open("config.yml")

Open函数返回两个值：文件描述符和 error。在成功时，错误为nil，否则它有一些值。

if err != nil {
    // ... do something
    return err
}

通常的错误处理模式是检查错误是否为空。你可能会说，这样的明确性伴随着冗长的语言。是的，Golang代码中经常散布着if err != nil。哦，拜托，我是不是每次都要检查err !=nil？
在Go的bufio.Scanner中可以找到一个巧妙的例子，避免不断检查错误是否为nil。

const input = "The quick brown fox jumps over lazy dog."
scanner := bufio.NewScanner(strings.NewReader(input))
scanner.Split(bufio.ScanWords)
count := 0
// We're not checking the error, just iterate
for scanner.Scan() {
    count++
}
// See if there was any error in the end
if err := scanner.Err(); err != nil {
    fmt.Fprintln(os.Stderr, "reading input:", err)
}

scanner.Scan()在有匹配的情况下返回true，在没有匹配或有错误的情况下返回false。任何在扫描过程中可能发生的错误都会被记录下来。在扫描循环结束后，将推迟检查：不需要每次迭代都检查。

实际上"error"是什么？
它可以是任何东西。一般来说，它是任何实现了简单的、单一方法的错误接口的类型：

type error interface {
    Error() string
}

开箱即用，Go提供了内置的Error.New构造函数。

errors.New("missing ID parameter")

或更灵活的fmt.Errorf()：

return fmt.Errorf("Unsupported message type: %q", msgType)

返回error
这很容易，因为Go允许多个返回值。把错误类型作为最后一个。如果一切顺利，只需返回nil。

//堆代码 duidaima.com
func Divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("divide by zero prohibited")
    }
    return a/b, nil
}

自定义 error 类型
在绝大多数情况下，你对内部是字符串的错误没有意见。最终，它们只是被记录在某个地方。如果你需要根据返回的错误做出决定，不要试图解析其字符串值。为了给错误提供更多的背景，你可以创建你自己的类型。想象一下，你想从HTTP服务器处理函数中返回带有状态码的错误：

type HttpError struct {
    StatusCode int
    Err        error
}
func (h HttpError) Error() string {
    return fmt.Sprintf("HTTP error: %v (%d)", h.Err, h.StatusCode)
}

error 是值，所以要像其他结构一样创建和返回：

func handlerFunc(r http.Request) error {
    // ...
    // something went wrong:
    return HttpError{
        StatusCode: 404,
        Err:        errors.New("product not found"),
    }
    // ...
}

然后使用类型断言将一般的 error 转换为我们特定的HttpError：

he, ok := err.(HttpError)
if ok {
    log.Printf("HTTP error with status = %d", he.StatusCode)
}

或者使用推荐的、更安全的方式：

var he HttpError
if errors.As(err, &he) {
        log.Printf("HTTP error with status = %d", he.StatusCode)
}

日志
提示：在堆栈深处处理错误，在顶部记录。这种方法有助于防止重复的日志。使用包装技术来增加上下文和调试时有用的信息。流行的软件包https://pkg.go.dev/github.com/pkg/errors 也允许在日志中保留堆栈跟踪。

error 包装
让我们考虑一个例子：main()调用readConfig()，后者又调用readFromFile()。这是一个简化的例子，说明代码中出现的模式：嵌套调用和错误发生在低层。让我们使用谷歌错误包中的errors.Wrap()。

func readFromFile() (string, error) {
    data, err := os.ReadFile("wrong file name")
    if err != nil {
        return "", errors.Wrap(err, "readFromFile")
    }
    return string(data), nil
}
func readConfig() (string, error) {
    data, err := readFromFile()
    if err != nil {
        return "", errors.Wrap(err, "readConfig")
    }
    // ...
    return data, nil
}
func main() {
    conf, err := readConfig()
    if err != nil {
        log.Printf("Cannot read: %v", err)
    }
}
output：

2022/03/16 00:37:54 Cannot read: readConfig: readFromFile: open wrong file name: no such file or directory

在每个包裹着错误的层次，你可以添加一条信息。一个原因，也可能只是一个函数名称或其他抽象层次的标识。

检索根本原因
如果你需要跟踪的最底层错误，使用

errors.Cause(err)

来检索堆栈中的第一个错误。该函数是安全的，所以当提供一个没有包装的错误时，它将返回错误。

内置包装
第二种错误包装的方式，允许有一点灵活性，就是使用：

err = fmt.Errorf("read file: %w", err)

注意%w格式指定符，它用错误的文本值来代替。请记住，这种形式不保留堆栈痕迹。

stack trace
使用errors.Wrap()函数包装的错误会保留调用堆栈。要打印它，请使用%+v格式指定符：

log.Printf("Cannot read: %+v", err)
output：

2022/07/22 18:51:54 Cannot read: open wrong file name: no such file or directory
readFromFile
awesomeProject/learnWrapping.readFromFile
        /Code/learn/go/awesomeProject/learnWrapping/wrapping.go:13
awesomeProject/learnWrapping.readConfig
        /Code/learn/go/awesomeProject/learnWrapping/wrapping.go:19
awesomeProject/learnWrapping.Main
        /Code/learn/go/awesomeProject/learnWrapping/wrapping.go:28
main.main
        /Users/tomek/Code/learn/go/awesomeProject/main.go:6

堆栈跟踪可以通过另一种有点隐晦的方式来检索。包含堆栈跟踪的错误实现了私有的stackTracer接口（它是私有的，因为名字以小写字母开头）。但是，这是Go，你可以在你的代码中重新声明这个接口：

type stackTracer interface {
        StackTrace() errors.StackTrace
}

并单独访问每个堆栈框架：

if sterr, ok := err.(stackTracer); ok {
    log.Printf("Stack trace:")
    for n, f := range sterr.StackTrace() {
        fmt.Printf("%d: %s %n:%d\n", n, f, f, f)
    }
}
output：

2022/07/23 15:11:17 Stack trace:
0: wrapping.go readConfig:21
1: wrapping.go Main:32
2: main.go main:6
3: proc.go main:250
4: asm_arm64.s goexit:1259

在堆栈深处处理错误，在顶部记录
包裹是保存上下文信息的有用技术，有助于避免重复记录语句。让我们重温一下上面的例子：在第四行，用黑体字突出显示，文件系统读取错误被记录下来。然后它又被main()函数记录下来，导致双重日志。

func readFromFile() (string, error) {
    data, err := os.ReadFile("wrong file name")
    if err != nil {
        log.Printf("readFromFile failed")
        return "", errors.Wrap(err, "readFromFile")
    }
    return string(data), nil
}
func readConfig() (string, error) {
    data, err := readFromFile()
    if err != nil {
        return "", errors.Wrap(err, "readConfig")
    }
    // ...
    return data, nil
}
func main() {
    conf, err := readConfig()
    if err != nil {
        log.Printf("Cannot read: %v", err)
    }
}

结果我们会在日志中看到重复的语句：

2022/09/13 14:22:41 Cannot read file: "dummyfile.txt"
2022/09/13 14:22:41 Cannot read: readConfig: readFromFile: open dummyfile.txt: no such file or directory

在上面的例子中，包装好的错误组合提供了足够的上下文来确定错误的原因。在第一行，我们得到了断章取义的声明，这说明了什么。当然，你可以将Context下游传递给每一个方法，但我不认为这样做的好处会超过污染造成的不清晰。