Golang错误处理链式调用与包装方法

fmt.Errorf

%w

errors.New("something went wrong")

fmt.Errorf

%w

package main

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

// 定义一个我们可能需要检查的底层错误
var ErrFileNotFound = errors.New("file not found")
var ErrPermissionDenied = errors.New("permission denied")

// readConfig 模拟读取配置文件，可能因为文件不存在或权限问题失败
func readConfig(path string) ([]byte, error) {
    if path == "" {
        return nil, fmt.Errorf("config path cannot be empty")
    }
    // 模拟文件不存在
    if path == "/etc/app/non_existent.conf" {
        return nil, fmt.Errorf("failed to open config file: %w", ErrFileNotFound)
    }
    // 模拟权限不足
    if path == "/etc/app/restricted.conf" {
        return nil, fmt.Errorf("access denied to config file: %w", ErrPermissionDenied)
    }
    // 正常情况
    return []byte("config data"), nil
}

// loadApplicationSettings 模拟加载应用设置，它会调用 readConfig
func loadApplicationSettings(configPath string) (string, error) {
    data, err := readConfig(configPath)
    if err != nil {
        // 在这里，我们将 readConfig 返回的错误包装起来，添加当前函数的上下文
        return "", fmt.Errorf("failed to load application settings from %s: %w", configPath, err)
    }
    return string(data), nil
}

func main() {
    // 尝试加载一个不存在的配置文件
    err := loadApplicationSettings("/etc/app/non_existent.conf")
    if err != nil {
        fmt.Println("Error encountered (full chain):", err)

        // 使用 errors.Is 检查错误链中是否包含特定的底层错误
        if errors.Is(err, ErrFileNotFound) {
            fmt.Println("Root cause: Configuration file was not found.")
        } else if errors.Is(err, ErrPermissionDenied) {
            fmt.Println("Root cause: Permission denied to access configuration file.")
        } else {
            fmt.Println("A different kind of error occurred.")
        }

        // 假设我们有一个自定义错误类型，可以通过 errors.As 提取
        var pathErr *os.PathError // os.PathError 实现了 error 接口
        if errors.As(err, &pathErr) {
            fmt.Printf("Extracted os.PathError: Op=%s, Path=%s, Err=%v\n", pathErr.Op, pathErr.Path, pathErr.Err)
        }
    }

    fmt.Println("\n---")

    // 尝试加载一个权限不足的配置文件
    err = loadApplicationSettings("/etc/app/restricted.conf")
    if err != nil {
        fmt.Println("Error encountered (full chain):", err)
        if errors.Is(err, ErrPermissionDenied) {
            fmt.Println("Root cause: Permission denied to access configuration file.")
        }
    }
}

%w

errors.Is

ErrFileNotFound

errors.As

fmt.Errorf

%w

errors

Is

As

Unwrap

fmt.Errorf

%w

// 假设这是我们定义的业务错误
var ErrInvalidInput = errors.New("invalid input parameter")

// validateUser 模拟用户输入验证
func validateUser(username string) error {
    if username == "" {
        return fmt.Errorf("username cannot be empty: %w", ErrInvalidInput) // 包装ErrInvalidInput
    }
    return nil
}

// createUser 模拟创建用户，它依赖于用户验证
func createUser(username, password string) error {
    err := validateUser(username)
    if err != nil {
        // 在这里，我们再次包装错误，添加createUser的上下文
        return fmt.Errorf("failed to create user %s: %w", username, err)
    }
    // 实际创建用户的逻辑...
    fmt.Printf("User %s created successfully.\n", username)
    return nil
}

func main() {
    err := createUser("", "password123") // 尝试创建一个空用户名的用户
    if err != nil {
        fmt.Println("Full error trace:", err) // 打印完整的错误链

        // 检查错误链中是否包含 ErrInvalidInput
        if errors.Is(err, ErrInvalidInput) {
            fmt.Println("Specific error: User input was invalid.")
        }

        // 假设我们有一个自定义错误类型，例如一个带有错误码的错误
        type AuthError struct {
            Code    int
            Message string
        }
        func (e *AuthError) Error() string {
            return fmt.Sprintf("auth error %d: %s", e.Code, e.Message)
        }

        // 模拟一个AuthError被包装
        authErr := &AuthError{Code: 1001, Message: "authentication failed"}
        wrappedAuthErr := fmt.Errorf("login failed: %w", authErr)

        var extractedAuthErr *AuthError
        if errors.As(wrappedAuthErr, &extractedAuthErr) {
            fmt.Printf("Extracted AuthError: Code=%d, Message=%s\n", extractedAuthErr.Code, extractedAuthErr.Message)
        }
    }
}

validateUser

createUser

main

fmt.Errorf("...: %w", innerErr)

Unwrap

innerErr

errors.Is