错误创建与包装

1. 概述

在 Go 语言中，错误处理是通过返回 error 接口类型的值来实现的。创建和包装错误是错误处理中的重要环节，它直接影响到错误信息的清晰度、上下文的完整性以及错误处理的效率。

本章节将详细介绍 Go 语言中错误的创建方法和错误包装技术，帮助开发者掌握如何创建有意义的错误并正确地包装错误以保留完整的错误链。

2. 基本概念

2.1 语法

Go 语言中创建和包装错误的基本语法：

// 创建基本错误
err := errors.New("something went wrong")

// 创建格式化错误
err := fmt.Errorf("error occurred: %s", details)

// 包装错误（Go 1.13+）
err := fmt.Errorf("failed to process: %w", originalErr)

2.2 语义

基本错误：由 errors.New() 创建的简单错误，只包含错误信息字符串
格式化错误：由 fmt.Errorf() 创建的带有格式化信息的错误
包装错误：使用 fmt.Errorf() 的 %w 动词包装的错误，保留原始错误信息

2.3 规范

错误信息应该清晰、具体，包含足够的上下文信息
包装错误时应该使用 %w 动词，以便保留原始错误
错误信息应该使用小写字母开头，不需要以句号结尾

3. 原理深度解析

3.1 错误创建的实现

errors.New() 的实现：

func New(text string) error {
    return &errorString{text}
}

type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

fmt.Errorf() 的实现：
- 当使用 %w 动词时，会创建一个实现了 error 接口和 Unwrap() 方法的包装错误
- 当不使用 %w 动词时，会创建一个普通的错误字符串

3.2 错误包装的原理

错误包装的核心是实现 Unwrap() 方法，使得错误链可以被遍历：

type wrapError struct {
    msg string
    err error
}

func (e *wrapError) Error() string {
    return e.msg
}

func (e *wrapError) Unwrap() error {
    return e.err
}

这样，通过 errors.Is() 和 errors.As() 函数，就可以遍历错误链，找到原始错误或特定类型的错误。

4. 常见错误与踩坑点

4.1 错误信息不清晰

错误表现：错误信息过于简单，无法提供足够的上下文信息

产生原因：使用 errors.New() 创建错误时，只提供了简单的错误信息

解决方案：使用 fmt.Errorf() 创建带有上下文信息的错误

4.2 错误包装不当

错误表现：包装错误后，无法正确获取原始错误

产生原因：没有使用 %w 动词包装错误，或者自定义错误类型没有实现 Unwrap() 方法

解决方案：使用 fmt.Errorf() 的 %w 动词包装错误，或者为自定义错误类型实现 Unwrap() 方法

4.3 错误包装层次过多

错误表现：错误信息过长，难以阅读

产生原因：每一层都包装错误，导致错误链过长

解决方案：只在需要添加有价值的上下文信息时才包装错误

5. 常见应用场景

5.1 基本错误创建

场景描述：创建简单的错误信息

使用方法：使用 errors.New() 创建基本错误

示例代码：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Result: %d\n", result)
}

5.2 格式化错误

场景描述：需要在错误信息中包含变量值

使用方法：使用 fmt.Errorf() 创建格式化错误

示例代码：

func getUser(id int) (User, error) {
    user, err := db.GetUser(id)
    if err != nil {
        return User{}, fmt.Errorf("failed to get user %d: %v", id, err)
    }
    return user, nil
}

func main() {
    user, err := getUser(123)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("User: %v\n", user)
}

5.3 错误包装

场景描述：需要保留原始错误信息，同时添加上下文信息

使用方法：使用 fmt.Errorf() 的 %w 动词包装错误

示例代码：

func readConfig(filename string) (Config, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return Config{}, fmt.Errorf("failed to read config file: %w", err)
    }
    // 解析配置
    return config, nil
}

func main() {
    config, err := readConfig("config.json")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Config file not found")
        }
        return
    }
    fmt.Printf("Config: %v\n", config)
}

5.4 自定义错误包装

场景描述：需要创建带有额外信息的自定义错误，并包装原始错误

使用方法：定义实现了 error 接口和 Unwrap() 方法的自定义错误类型

示例代码：

type AppError struct {
    Code    int
    Message string
    Cause   error
}

func (e *AppError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s (code: %d): %v", e.Message, e.Code, e.Cause)
    }
    return fmt.Sprintf("%s (code: %d)", e.Message, e.Code)
}

func (e *AppError) Unwrap() error {
    return e.Cause
}

func processFile(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return &AppError{Code: 400, Message: "failed to read file", Cause: err}
    }
    // 处理数据
    return nil
}

func main() {
    err := processFile("nonexistent.txt")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("File not found")
        }
    }
}

5.5 错误链处理

场景描述：处理多层嵌套的错误

使用方法：使用 errors.Is() 或 errors.As() 函数遍历错误链

示例代码：

func level1() error {
    if err := level2(); err != nil {
        return fmt.Errorf("level1 error: %w", err)
    }
    return nil
}

func level2() error {
    if err := level3(); err != nil {
        return fmt.Errorf("level2 error: %w", err)
    }
    return nil
}

func level3() error {
    return os.ErrNotExist
}

func main() {
    err := level1()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Original error is os.ErrNotExist")
        }
    }
}

6. 企业级进阶应用场景

6.1 错误分类与包装

场景描述：在企业级应用中，需要对错误进行分类，并保留完整的错误链

使用方法：创建带有错误类型的自定义错误，并包装原始错误

示例代码：

// 错误类型定义
const (
    ErrorTypeValidation = iota
    ErrorTypeDatabase
    ErrorTypeNetwork
    ErrorTypeInternal
)

// 自定义错误类型
type AppError struct {
    Type    int
    Code    int
    Message string
    Cause   error
}

func (e *AppError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s (code: %d): %v", e.Message, e.Code, e.Cause)
    }
    return fmt.Sprintf("%s (code: %d)", e.Message, e.Code)
}

func (e *AppError) Unwrap() error {
    return e.Cause
}

// 创建验证错误
func NewValidationError(code int, message string, cause error) *AppError {
    return &AppError{Type: ErrorTypeValidation, Code: code, Message: message, Cause: cause}
}

// 创建数据库错误
func NewDatabaseError(code int, message string, cause error) *AppError {
    return &AppError{Type: ErrorTypeDatabase, Code: code, Message: message, Cause: cause}
}

// 使用示例
func validateUser(user User) error {
    if user.Name == "" {
        return NewValidationError(400, "name is required", nil)
    }
    return nil
}

func getUser(id int) (User, error) {
    user, err := db.GetUser(id)
    if err != nil {
        return User{}, NewDatabaseError(500, "failed to get user", err)
    }
    return user, nil
}

6.2 错误监控与包装

场景描述：在企业级应用中，需要监控错误的发生情况，同时保留完整的错误信息

使用方法：创建错误监控包装器，包装原始错误并记录错误信息

示例代码：

// 错误监控包装器
type monitoredError struct {
    err        error
    timestamp  time.Time
    stackTrace string
}

func (e *monitoredError) Error() string {
    return e.err.Error()
}

func (e *monitoredError) Unwrap() error {
    return e.err
}

func MonitorError(err error) error {
    if err == nil {
        return nil
    }
    
    // 捕获堆栈信息
    stackTrace := captureStackTrace()
    
    // 创建监控错误
    monitoredErr := &monitoredError{
        err:        err,
        timestamp:  time.Now(),
        stackTrace: stackTrace,
    }
    
    // 记录错误信息
    log.Printf("Error occurred: %v\nStack trace: %s\n", err, stackTrace)
    
    // 可以发送到监控系统
    sendToMonitoringSystem(monitoredErr)
    
    return monitoredErr
}

// 使用示例
func processRequest(req Request) error {
    err := validateRequest(req)
    if err != nil {
        return MonitorError(fmt.Errorf("invalid request: %w", err))
    }
    
    err = saveRequest(req)
    if err != nil {
        return MonitorError(fmt.Errorf("failed to save request: %w", err))
    }
    
    return nil
}

6.3 错误恢复与包装

场景描述：在企业级应用中，需要从某些错误中恢复，并包装错误信息

使用方法：创建带有恢复信息的包装错误

示例代码：

// 可恢复错误
type RecoverableError struct {
    Message   string
    Cause     error
    Retryable bool
}

func (e *RecoverableError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s: %v", e.Message, e.Cause)
    }
    return e.Message
}

func (e *RecoverableError) Unwrap() error {
    return e.Cause
}

// 尝试执行操作，处理可恢复的错误
func TryOperation(attempts int, f func() error) error {
    for i := 0; i < attempts; i++ {
        err := f()
        if err == nil {
            return nil
        }
        
        var recoverableErr *RecoverableError
        if errors.As(err, &recoverableErr) && recoverableErr.Retryable {
            log.Printf("Attempt %d failed, retrying: %v\n", i+1, err)
            time.Sleep(time.Second * time.Duration(i+1))
            continue
        }
        
        return err
    }
    return fmt.Errorf("failed after %d attempts", attempts)
}

// 使用示例
func fetchData(url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return &RecoverableError{Message: "failed to fetch data", Cause: err, Retryable: true}
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }
    
    // 处理响应
    return nil
}

func main() {
    err := TryOperation(3, func() error {
        return fetchData("https://example.com")
    })
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}

7. 行业最佳实践

7.1 使用 fmt.Errorf 包装错误

实践内容：使用 fmt.Errorf() 的 %w 动词包装错误

推荐理由：这样可以保留原始错误信息，同时添加上下文信息，便于调试和错误处理

7.2 错误信息应该包含上下文

实践内容：在错误信息中包含足够的上下文信息

推荐理由：上下文信息有助于快速定位问题，减少调试时间

7.3 只在必要时包装错误

实践内容：只在需要添加有价值的上下文信息时才包装错误

推荐理由：过多的错误包装会导致错误链过长，影响错误信息的可读性

7.4 为自定义错误实现 Unwrap 方法

实践内容：为包装了其他错误的自定义错误类型实现 Unwrap() 方法

推荐理由：这样可以确保 errors.Is() 和 errors.As() 函数能够正确处理错误链

7.5 统一错误创建方式

实践内容：创建统一的错误创建函数，确保错误格式一致

推荐理由：统一的错误格式有助于错误处理的一致性，便于错误监控和统计

8. 常见问题答疑（FAQ）

8.1 问：errors.New() 和 fmt.Errorf() 有什么区别？

回答：errors.New() 创建一个简单的错误，只包含错误信息字符串；fmt.Errorf() 可以创建带有格式化信息的错误，并且在 Go 1.13+ 中可以使用 %w 动词包装错误

示例代码：

// 使用 errors.New()
err1 := errors.New("simple error")

// 使用 fmt.Errorf()
err2 := fmt.Errorf("formatted error: %s", "something went wrong")

// 使用 fmt.Errorf() 包装错误
err3 := fmt.Errorf("wrapped error: %w", err1)

8.2 问：如何在包装错误后仍然能够检查原始错误？

回答：使用 errors.Is() 或 errors.As() 函数，它们会遍历错误链，找到原始错误或特定类型的错误

示例代码：

err := fmt.Errorf("wrapped error: %w", os.ErrNotExist)

// 检查是否是特定错误
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("Original error is os.ErrNotExist")
}

// 检查是否是特定类型的错误
var pathErr *os.PathError
if errors.As(err, &pathErr) {
    fmt.Printf("Path error: %v\n", pathErr)
}

8.3 问：自定义错误类型是否需要实现 Unwrap 方法？

回答：如果自定义错误类型包装了其他错误，应该实现 Unwrap() 方法，以便 errors.Is() 和 errors.As() 函数能够正确处理错误链

示例代码：

type MyError struct {
    Message string
    Cause   error
}

func (e *MyError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s: %v", e.Message, e.Cause)
    }
    return e.Message
}

func (e *MyError) Unwrap() error {
    return e.Cause
}

8.4 问：错误包装会影响性能吗？

回答：错误包装的开销很小，主要是创建一个新的错误对象。在大多数情况下，这种开销可以忽略不计

示例代码：

// 错误包装的性能测试
func benchmarkErrorWrapping(b *testing.B) {
    originalErr := errors.New("original error")
    for i := 0; i < b.N; i++ {
        err := fmt.Errorf("wrapped error: %w", originalErr)
        _ = err
    }
}

8.5 问：如何创建带有错误码的错误？

回答：定义自定义错误类型，包含错误码字段

示例代码：

type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func NewAppError(code int, message string) *AppError {
    return &AppError{Code: code, Message: message}
}

// 使用示例
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, NewAppError(400, "division by zero")
    }
    return a / b, nil
}

8.6 问：如何在错误信息中包含堆栈信息？

回答：使用 runtime 包捕获堆栈信息，并将其包含在错误信息中

示例代码：

func captureStackTrace() string {
    var buf bytes.Buffer
    stackTrace := debug.Stack()
    buf.Write(stackTrace)
    return buf.String()
}

type StackError struct {
    Message    string
    StackTrace string
    Cause      error
}

func (e *StackError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s\nStack trace:\n%s\nCause: %v", e.Message, e.StackTrace, e.Cause)
    }
    return fmt.Sprintf("%s\nStack trace:\n%s", e.Message, e.StackTrace)
}

func (e *StackError) Unwrap() error {
    return e.Cause
}

func NewStackError(message string, cause error) *StackError {
    return &StackError{
        Message:    message,
        StackTrace: captureStackTrace(),
        Cause:      cause,
    }
}

9. 实战练习

9.1 基础练习

练习内容：实现一个错误包装函数，保留完整的错误链

解题思路：

定义一个包装错误的函数
确保包装后的错误可以通过 errors.Is() 和 errors.As() 函数正确处理
测试错误链的处理

常见误区：没有实现 Unwrap() 方法，导致错误链断裂

分步提示：

定义函数 WrapError，接受原始错误和包装信息
创建一个实现了 error 接口和 Unwrap() 方法的包装错误类型
实现 Error() 方法，返回包装后的错误信息
编写测试代码，验证错误链的处理

参考代码：

package main

import (
    "errors"
    "fmt"
    "os"
)

type wrappedError struct {
    message string
    err     error
}

func (e *wrappedError) Error() string {
    return fmt.Sprintf("%s: %v", e.message, e.err)
}

func (e *wrappedError) Unwrap() error {
    return e.err
}

func WrapError(err error, message string) error {
    if err == nil {
        return nil
    }
    return &wrappedError{message: message, err: err}
}

func level1() error {
    if err := level2(); err != nil {
        return WrapError(err, "level1 error")
    }
    return nil
}

func level2() error {
    if err := level3(); err != nil {
        return WrapError(err, "level2 error")
    }
    return nil
}

func level3() error {
    return os.ErrNotExist
}

func main() {
    err := level1()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Original error is os.ErrNotExist")
        }
    }
}

9.2 进阶练习

练习内容：实现一个带有错误码和堆栈信息的自定义错误类型

解题思路：

定义一个自定义错误类型，包含错误码、错误信息、堆栈信息和原始错误
实现 Error() 方法，返回格式化的错误信息
实现 Unwrap() 方法，返回原始错误
编写测试代码，验证错误处理

常见误区：没有正确捕获堆栈信息，或者没有实现 Unwrap() 方法

分步提示：

定义结构体 DetailedError，包含 Code、Message、StackTrace 和 Cause 字段
实现 Error() 方法，返回格式化的错误信息
实现 Unwrap() 方法，返回原始错误
创建函数 NewDetailedError，用于创建新的 DetailedError
编写测试代码，验证错误处理

参考代码：

package main

import (
    "bytes"
    "debug"
    "errors"
    "fmt"
    "os"
)

type DetailedError struct {
    Code       int
    Message    string
    StackTrace string
    Cause      error
}

func (e *DetailedError) Error() string {
    var buf bytes.Buffer
    buf.WriteString(fmt.Sprintf("Error %d: %s\n", e.Code, e.Message))
    buf.WriteString(fmt.Sprintf("Stack trace:\n%s\n", e.StackTrace))
    if e.Cause != nil {
        buf.WriteString(fmt.Sprintf("Cause: %v\n", e.Cause))
    }
    return buf.String()
}

func (e *DetailedError) Unwrap() error {
    return e.Cause
}

func captureStackTrace() string {
    var buf bytes.Buffer
    stackTrace := debug.Stack()
    buf.Write(stackTrace)
    return buf.String()
}

func NewDetailedError(code int, message string, cause error) *DetailedError {
    return &DetailedError{
        Code:       code,
        Message:    message,
        StackTrace: captureStackTrace(),
        Cause:      cause,
    }
}

func processFile(filename string) error {
    data, err := os.ReadFile(filename)
    if err != nil {
        return NewDetailedError(400, "failed to read file", err)
    }
    // 处理数据
    return nil
}

func main() {
    err := processFile("nonexistent.txt")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Original error is os.ErrNotExist")
        }
    }
}

9.3 挑战练习

练习内容：实现一个错误处理中间件，包装 HTTP 请求中的错误并返回适当的响应

解题思路：

定义一个 HTTP 中间件函数，接受下一个处理函数
在中间件中执行下一个处理函数，捕获错误
根据错误类型包装错误并返回适当的 HTTP 响应
记录错误信息

常见误区：没有正确处理不同类型的错误，或者没有包装错误信息

分步提示：

定义中间件函数 ErrorHandlerMiddleware，签名为 func(http.Handler) http.Handler
实现中间件逻辑，包括错误捕获和处理
创建一个 responseRecorder 来记录响应状态码
根据错误类型包装错误并返回适当的 HTTP 响应
编写测试代码，验证中间件功能

参考代码：

package main

import (
    "bytes"
    "debug"
    "fmt"
    "log"
    "net/http"
    "net/http/httptest"
)

type AppError struct {
    StatusCode int
    Message    string
    StackTrace string
    Cause      error
}

func (e *AppError) Error() string {
    var buf bytes.Buffer
    buf.WriteString(fmt.Sprintf("Error %d: %s\n", e.StatusCode, e.Message))
    buf.WriteString(fmt.Sprintf("Stack trace:\n%s\n", e.StackTrace))
    if e.Cause != nil {
        buf.WriteString(fmt.Sprintf("Cause: %v\n", e.Cause))
    }
    return buf.String()
}

func (e *AppError) Unwrap() error {
    return e.Cause
}

func captureStackTrace() string {
    var buf bytes.Buffer
    stackTrace := debug.Stack()
    buf.Write(stackTrace)
    return buf.String()
}

func NewAppError(statusCode int, message string, cause error) *AppError {
    return &AppError{
        StatusCode: statusCode,
        Message:    message,
        StackTrace: captureStackTrace(),
        Cause:      cause,
    }
}

// 错误处理中间件
func ErrorHandlerMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // 记录 panic
                panicErr := NewAppError(http.StatusInternalServerError, "Internal Server Error", fmt.Errorf("panic: %v", err))
                log.Printf("Panic recovered: %v\n", err)
                http.Error(w, panicErr.Message, panicErr.StatusCode)
            }
        }()
        
        // 执行下一个处理函数
        next.ServeHTTP(w, r)
    })
}

// 测试处理函数
func testHandler(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path == "/error" {
        err := NewAppError(http.StatusBadRequest, "Bad Request", nil)
        http.Error(w, err.Message, err.StatusCode)
        return
    }
    fmt.Fprintln(w, "Hello, World!")
}

func main() {
    // 创建测试服务器
    handler := ErrorHandlerMiddleware(http.HandlerFunc(testHandler))
    
    // 测试正常请求
    req, _ := http.NewRequest("GET", "/", nil)
    rr := httptest.NewRecorder()
    handler.ServeHTTP(rr, req)
    fmt.Printf("Normal request: %d %s\n", rr.Code, rr.Body.String())
    
    // 测试错误请求
    req, _ = http.NewRequest("GET", "/error", nil)
    rr = httptest.NewRecorder()
    handler.ServeHTTP(rr, req)
    fmt.Printf("Error request: %d %s\n", rr.Code, rr.Body.String())
    
    // 启动服务器
    http.ListenAndServe(":8080", handler)
}

10. 知识点总结

10.1 核心要点

Go 语言中创建错误的方法包括 errors.New() 和 fmt.Errorf()
使用 fmt.Errorf() 的 %w 动词可以包装错误，保留原始错误信息
包装错误时应该实现 Unwrap() 方法，以便 errors.Is() 和 errors.As() 函数能够正确处理错误链
错误信息应该清晰、具体，包含足够的上下文信息
只在需要添加有价值的上下文信息时才包装错误

10.2 易错点回顾

错误信息不清晰，缺少上下文
没有使用 %w 动词包装错误，导致无法正确获取原始错误
错误包装层次过多，导致错误信息过长
自定义错误类型没有实现 Unwrap() 方法，导致错误链断裂
忽略错误返回值，导致程序在不可预期的情况下失败

11. 拓展参考资料

11.1 官方文档链接

11.2 进阶学习路径建议

学习 context 包，了解如何在错误处理中使用上下文
学习 errgroup 包，掌握并发错误处理
学习第三方错误处理库，如 pkg/errors
学习如何在大型项目中设计错误处理策略

12. 代码规范

12.1 错误处理代码风格

错误检查应该在函数调用后立即进行
错误信息应该清晰、具体，包含足够的上下文
当函数返回错误时，其他返回值应该是零值
使用 defer 语句确保资源正确关闭
对于需要在多个地方使用的错误，定义错误变量

12.2 示例代码

// 定义错误变量
var (
    ErrNotFound      = errors.New("resource not found")
    ErrInvalidInput  = errors.New("invalid input")
    ErrInternalError = errors.New("internal error")
)

// 正确的错误创建和包装示例
func getUser(id int) (User, error) {
    user, err := db.GetUser(id)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return User{}, fmt.Errorf("%w: user %d", ErrNotFound, id)
        }
        return User{}, fmt.Errorf("%w: %v", ErrInternalError, err)
    }
    return user, nil
}

// 自定义错误类型
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
}

// 使用自定义错误类型
func validateUser(user User) error {
    if user.Name == "" {
        return &ValidationError{Field: "name", Message: "name is required"}
    }
    return nil
}

本章节介绍了 Go 语言中错误的创建和包装方法。通过学习这些内容，开发者可以更好地掌握错误处理的技巧，编写更加健壮和可维护的代码。

错误创建与包装 ​

1. 概述 ​

2. 基本概念 ​

2.1 语法 ​

2.2 语义 ​

2.3 规范 ​

3. 原理深度解析 ​

3.1 错误创建的实现 ​

3.2 错误包装的原理 ​

4. 常见错误与踩坑点 ​

4.1 错误信息不清晰 ​

4.2 错误包装不当 ​

4.3 错误包装层次过多 ​

5. 常见应用场景 ​

5.1 基本错误创建 ​

5.2 格式化错误 ​

5.3 错误包装 ​

5.4 自定义错误包装 ​

5.5 错误链处理 ​

6. 企业级进阶应用场景 ​

6.1 错误分类与包装 ​

6.2 错误监控与包装 ​

6.3 错误恢复与包装 ​

7. 行业最佳实践 ​

7.1 使用 fmt.Errorf 包装错误 ​

7.2 错误信息应该包含上下文 ​

7.3 只在必要时包装错误 ​

7.4 为自定义错误实现 Unwrap 方法 ​

7.5 统一错误创建方式 ​

8. 常见问题答疑（FAQ） ​

8.1 问：errors.New() 和 fmt.Errorf() 有什么区别？ ​

8.2 问：如何在包装错误后仍然能够检查原始错误？ ​

8.3 问：自定义错误类型是否需要实现 Unwrap 方法？ ​

8.4 问：错误包装会影响性能吗？ ​

8.5 问：如何创建带有错误码的错误？ ​

8.6 问：如何在错误信息中包含堆栈信息？ ​

9. 实战练习 ​

9.1 基础练习 ​

9.2 进阶练习 ​

9.3 挑战练习 ​

10. 知识点总结 ​

10.1 核心要点 ​

10.2 易错点回顾 ​

11. 拓展参考资料 ​

11.1 官方文档链接 ​

11.2 进阶学习路径建议 ​

12. 代码规范 ​

12.1 错误处理代码风格 ​

12.2 示例代码 ​

错误创建与包装

1. 概述

2. 基本概念

2.1 语法

2.2 语义

2.3 规范

3. 原理深度解析

3.1 错误创建的实现

3.2 错误包装的原理

4. 常见错误与踩坑点

4.1 错误信息不清晰

4.2 错误包装不当

4.3 错误包装层次过多

5. 常见应用场景

5.1 基本错误创建

5.2 格式化错误

5.3 错误包装

5.4 自定义错误包装

5.5 错误链处理

6. 企业级进阶应用场景

6.1 错误分类与包装

6.2 错误监控与包装

6.3 错误恢复与包装

7. 行业最佳实践

7.1 使用 fmt.Errorf 包装错误

7.2 错误信息应该包含上下文

7.3 只在必要时包装错误

7.4 为自定义错误实现 Unwrap 方法

7.5 统一错误创建方式

8. 常见问题答疑（FAQ）

8.1 问：errors.New() 和 fmt.Errorf() 有什么区别？

8.2 问：如何在包装错误后仍然能够检查原始错误？

8.3 问：自定义错误类型是否需要实现 Unwrap 方法？

8.4 问：错误包装会影响性能吗？

8.5 问：如何创建带有错误码的错误？

8.6 问：如何在错误信息中包含堆栈信息？

9. 实战练习

9.1 基础练习

9.2 进阶练习

9.3 挑战练习

10. 知识点总结

10.1 核心要点

10.2 易错点回顾

11. 拓展参考资料

11.1 官方文档链接

11.2 进阶学习路径建议

12. 代码规范

12.1 错误处理代码风格

12.2 示例代码