在Golang中应该返回错误值还是直接在函数内部打印日志

if err != nil { return err }

readFile(path string) ([]byte, error)

os.ErrNotExist

os.ErrPermission

package main

import (
    "fmt"
    "io/ioutil"
    "os"
)

func readFileContent(path string) ([]byte, error) {
    content, err := ioutil.ReadFile(path)
    if err != nil {
        // 这里不直接打印日志，而是返回错误
        // 调用者将决定如何处理这个错误
        return nil, fmt.Errorf("failed to read file %s: %w", path, err)
    }
    return content, nil
}

func main() {
    filePath := "non_existent_file.txt"
    data, err := readFileContent(filePath)
    if err != nil {
        // 在这里，我们可以根据错误类型进行更具体的处理
        if os.IsNotExist(err) {
            fmt.Printf("Error: File '%s' does not exist. Please create it.\n", filePath)
        } else {
            // 对于其他类型的错误，我们可以在这里记录日志
            // 并给用户一个通用的错误提示
            fmt.Printf("An unexpected error occurred while reading file: %v\n", err)
            // log.Printf("ERROR: Failed to process file %s: %v", filePath, err) // 实际应用中会用日志库
        }
        return
    }
    fmt.Printf("File content: %s\n", string(data))
}

FATAL

panic

os.Exit(1)

fmt.Println

log.Printf

fmt.Errorf

%w

errors.Is

errors.As

errors.Unwrap

package main

import (
    "errors"
    "fmt"
    "log"
)

// CustomError 示例：自定义错误类型
type CustomError struct {
    Op  string // 操作名称
    Err error  // 原始错误
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("operation %s failed: %v", e.Op, e.Err)
}

func (e *CustomError) Unwrap() error {
    return e.Err
}

func doSomethingRisky(input string) error {
    if input == "" {
        // 返回一个具体的错误
        return errors.New("input cannot be empty")
    }
    // 模拟其他错误
    if input == "fail" {
        return errors.New("simulated internal failure")
    }
    return nil
}

func processData(data string) error {
    err := doSomethingRisky(data)
    if err != nil {
        // 包装底层错误，添加当前函数的上下文
        return &CustomError{Op: "processData", Err: err}
    }
    return nil
}

func main() {
    // 场景1: 正常情况
    if err := processData("valid_data"); err != nil {
        log.Printf("Error in main: %v", err)
    } else {
        fmt.Println("Processing 'valid_data' successful.")
    }

    // 场景2: 底层错误被包装
    err := processData("")
    if err != nil {
        // 在这里进行日志记录
        log.Printf("ERROR: Failed to process data: %v", err) // 记录包装后的错误
        // 检查是否是特定的底层错误
        var customErr *CustomError
        if errors.As(err, &customErr) {
            fmt.Printf("Detected CustomError during operation '%s'. Original error: %v\n", customErr.Op, customErr.Err)
            if errors.Is(customErr.Err, errors.New("input cannot be empty")) {
                fmt.Println("Specific handling for empty input error.")
            }
        }
    }

    // 场景3: 另一个底层错误被包装
    err = processData("fail")
    if err != nil {
        log.Printf("ERROR: Another failure: %v", err)
        var customErr *CustomError
        if errors.As(err, &customErr) {
            fmt.Printf("Detected CustomError during operation '%s'. Original error: %v\n", customErr.Op, customErr.Err)
        }
    }
}

zap

logrus