type error interface {
    Error() string
}

import "errors"

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

func ReadFile(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("failed to read %s: %v", path, err)
    }
    return data, nil
}

result, err := SomeFunction()
if err != nil {
    // 處理錯(cuò)誤
    return err
}
// 使用result

type PathError struct {
    Op   string
    Path string
    Err  error
}

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

func OpenConfig(path string) error {
    if !fileExists(path) {
        return &PathError{
            Op:   "open",
            Path: path,
            Err:  errors.New("file not found"),
        }
    }
    // ...
}

if err == io.EOF {
    // 處理EOF
}

var ErrNotFound = errors.New("not found")

if errors.Is(err, ErrNotFound) {
    // 處理特定錯(cuò)誤
}

var pathErr *PathError
if errors.As(err, &pathErr) {
    fmt.Println("Failed at path:", pathErr.Path)
}

func ProcessFile(path string) error {
    data, err := ReadFile(path)
    if err != nil {
        return fmt.Errorf("process failed: %w", err)
    }
    // ...
}

if err != nil {
    unwrapped := errors.Unwrap(err)
    fmt.Println("Original error:", unwrapped)
}

data, _ := ReadFile("config.json") // 錯(cuò)誤!

// 不好的做法
if err != nil {
    return fmt.Errorf("failed: %w", 
        fmt.Errorf("processing: %w", 
            fmt.Errorf("io: %w", err)))
}

// 常規(guī)錯(cuò)誤不應(yīng)使用panic
if x < 0 {
    panic("x cannot be negative") // 應(yīng)該返回error
}

type MultiError struct {
    Errors []error
}

func (m *MultiError) Add(err error) {
    m.Errors = append(m.Errors, err)
}

func (m *MultiError) Error() string {
    var msgs []string
    for _, err := range m.Errors {
        msgs = append(msgs, err.Error())
    }
    return strings.Join(msgs, "; ")
}

func BatchProcess(items []Item) error {
    var merr MultiError
    for _, item := range items {
        if err := process(item); err != nil {
            merr.Add(err)
        }
    }
    if len(merr.Errors) > 0 {
        return &merr
    }
    return nil
}

func HandleRequest(w http.ResponseWriter, r *http.Request) {
    err := processRequest(r)
    if err != nil {
        // 記錄完整錯(cuò)誤信息
        log.Printf("request failed: %+v", err) 
      
        // 返回簡(jiǎn)化的錯(cuò)誤信息給客戶端
        http.Error(w, "internal server error", http.StatusInternalServerError)
        return
    }
    // ...
}

// 預(yù)定義錯(cuò)誤避免重復(fù)分配
var (
    ErrInvalidInput = errors.New("invalid input")
    ErrTimeout      = errors.New("operation timeout")
)

func Validate(input string) error {
    if input == "" {
        return ErrInvalidInput
    }
    // ...
}

func loadConfig() error {
    if err := readConfig(); err != nil {
        return fmt.Errorf("config load failed: %w", err)
    }
    return nil
}

func main() {
    err := loadConfig()
    if errors.Is(err, os.ErrNotExist) {
        fmt.Println("配置文件不存在")
    }
}