如何使用%w动词在Golang中包装一个底层错误

fmt.Errorf

%w

errors.Is

errors.As

%w

package main

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

// simulate a low-level operation that might fail
func readFileContent(filename string) ([]byte, error) {
    _, err := os.Stat(filename) // Just checking if file exists for this example
    if os.IsNotExist(err) {
        return nil, fmt.Errorf("file '%s' does not exist: %w", filename, err)
    }
    if err != nil {
        return nil, fmt.Errorf("failed to stat file '%s': %w", filename, err)
    }
    // In a real scenario, you'd read the file here
    return []byte("some content"), nil
}

// A higher-level function that uses readFileContent
func loadConfiguration(path string) (string, error) {
    content, err := readFileContent(path)
    if err != nil {
        // Here, we wrap the error from readFileContent, adding more context
        // The %w verb is key here.
        return "", fmt.Errorf("failed to load configuration from '%s': %w", path, err)
    }
    return string(content), nil
}

func main() {
    // Scenario 1: File does not exist
    config, err := loadConfiguration("non_existent_config.yaml")
    if err != nil {
        fmt.Printf("Error loading config: %v\n", err)

        // Now, let's check if the underlying error was os.ErrNotExist
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Specifically, the configuration file was not found.")
        }

        // Or, if we had a custom error type, we could use errors.As
        var pathErr *os.PathError
        if errors.As(err, &pathErr) {
            fmt.Printf("It was a path error: Op=%s, Path=%s, Err=%v\n", pathErr.Op, pathErr.Path, pathErr.Err)
        }
    } else {
        fmt.Printf("Configuration loaded: %s\n", config)
    }

    fmt.Println("---")

    // Scenario 2: Simulate another type of error (e.g., permission denied)
    // For demonstration, let's create a dummy error
    type PermissionDeniedError struct {
        FileName string
    }
    func (e *PermissionDeniedError) Error() string {
        return fmt.Sprintf("permission denied for file '%s'", e.FileName)
    }

    // Let's pretend readFileContent returned this custom error
    myCustomReadFileContent := func(filename string) ([]byte, error) {
        return nil, &PermissionDeniedError{FileName: filename}
    }

    // And a higher-level function using it
    loadConfigurationWithCustomError := func(path string) (string, error) {
        content, err := myCustomReadFileContent(path)
        if err != nil {
            return "", fmt.Errorf("failed to load configuration from '%s' due to permission: %w", path, err)
        }
        return string(content), nil
    }

    config, err = loadConfigurationWithCustomError("protected_config.json")
    if err != nil {
        fmt.Printf("Error loading config: %v\n", err)

        var permErr *PermissionDeniedError
        if errors.As(err, &permErr) {
            fmt.Printf("Specifically, permission was denied for file: %s\n", permErr.FileName)
        }
    }
}

loadConfiguration

readFileContent

fmt.Errorf("failed to load configuration from '%s': %w", path, err)

%w

fmt.Errorf

err

err

os.ErrNotExist

os.PathError

errors.Is

errors.As

%w

sql.ErrConnDone

%w

errors.Is

errors.As

%w

%v

%v

fmt.Errorf

Error()

// Using %v
err := fmt.Errorf("original error")
wrappedErr := fmt.Errorf("failed to process: %v", err)
// errors.Is(wrappedErr, err) will return false because err is not wrapped, it's just stringified.

%w

errors.Unwrap()

errors.Is()

errors.As()

// Using %w
err := fmt.Errorf("original error")
wrappedErr := fmt.Errorf("failed to process: %w", err)
// errors.Is(wrappedErr, err) will return true because err is wrapped.

%w

%v

errors.New

fmt.Errorf

%v

errors.Is

errors.As

%w

errors.Is

errors.As

errors.Is(err, target)

err

target

err

target

==

Is(error) bool

true

io.EOF

os.ErrNotExist

// 假设我们有一个错误链：
// wrappedErr -> anotherWrappedErr -> os.ErrNotExist
if errors.Is(wrappedErr, os.ErrNotExist) {
    fmt.Println("检测到文件不存在错误，可以尝试创建文件。")
}

errors.As(err, &target)

err

target

target

error

*MyCustomError

type DatabaseError struct {
    Code    int
    Message string
}

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

// 假设某个函数返回了一个被包装的DatabaseError
func fetchData() error {
    return fmt.Errorf("failed to fetch user data: %w", &DatabaseError{Code: 1001, Message: "connection refused"})
}

func main() {
    err := fetchData()
    if err != nil {
        fmt.Printf("原始错误: %v\n", err)

        var dbErr *DatabaseError // target 必须是指针类型
        if errors.As(err, &dbErr) {
            fmt.Printf("检测到数据库错误！错误码: %d, 消息: %s\n", dbErr.Code, dbErr.Message)
            // 根据错误码进行更细致的处理
            if dbErr.Code == 1001 {
                fmt.Println("可能是数据库连接问题，尝试重连。")
            }
        } else {
            fmt.Println("不是数据库错误，可能是其他问题。")
        }
    }
}

errors.Is

errors.As