15 — Error Handling

// errors.Join combines multiple errors into one.
// errors.Is/As walk all joined errors.

func validateAll(u *User) error {
    var errs []error
    if u.Name == "" {
        errs = append(errs, &ValidationError{Field: "name", Message: "required"})
    }
    if u.Email == "" {
        errs = append(errs, &ValidationError{Field: "email", Message: "required"})
    }
    if u.Age < 0 {
        errs = append(errs, &ValidationError{Field: "age", Message: "must be non-negative"})
    }
    return errors.Join(errs...)  // nil if no errors, combined if any
}

// Joined error's Error() prints all sub-errors:
// "validation [name]: required\nvalidation [email]: required"

// errors.Is checks all joined errors:
// errors.Is(joinedErr, someErr) — true if any joined error matches

💡 Tips & Tricks

• Idiom: wrap errors with context at each layer — fmt.Errorf("doing X: %w", err) — so the final error reads like a stack trace. The context should describe what the caller was doing, not the low-level failure.
• Idiom: use errors.Is for sentinel errors — it walks the wrap chain. err == ErrNotFound misses wrapped errors. Always use errors.Is.
• Idiom: use errors.As to extract typed errors with fields — var perr *PathError; if errors.As(err, &perr) { ... perr.Path }. Pass &perr (pointer to the target), not perr.
• Idiom: use %w (not %v) in fmt.Errorf to wrap — %w preserves the original for Is/As; %v formats into the message and loses the chain. Use %v only when you deliberately want to hide the original.
• Idiom: reserve panic for genuine bugs — violated invariants, "this should never happen." Normal failures return error. The MustX convention panics for programmer mistakes (bad compile-time constants).
• Safety: always recover in goroutines that handle external input — a single bad request causing a panic shouldn't crash the server. Log the panic + stack trace for debugging.

⚠️ Edge Cases & Gotchas

• %w vs %v: %w wraps (preserves for Is/As); %v formats (loses chain). Use %w almost always.
• Sentinel comparison with == misses wraps: err == ErrNotFound is false if err wraps ErrNotFound. Use errors.Is.
• errors.As target must be &target: var e *MyError; errors.As(err, &e) — pass &e (**MyError), not e (*MyError).
• Returning nil pointer as error = non-nil interface: var p *MyError = nil; return p — the returned error is non-nil (has type *MyError). Return nil directly.
• panic in a goroutine crashes the program: unrecovered panics terminate the whole process. Always recover in goroutines that handle external input.
• recover only works in the deferred function of the panicking goroutine: you can't recover from another goroutine's panic. Each goroutine needs its own recover.
• log.Fatal calls os.Exit: skips deferred functions. Don't use it in library code or anywhere with cleanup defers. Use only in main for fatal startup errors.
• errors.Join(nil, nil) returns nil: joining nil errors returns nil. Joining non-nil errors returns a non-nil combined error.
• Multiple %w in fmt.Errorf (Go 1.20+): fmt.Errorf("%w and %w", err1, err2) wraps both — errors.Is checks both. Rare but supported.
• Ignoring an error is a bug: _ = f() hides failures. errcheck linter flags these. At minimum, log the error.

🧠 Quick Quiz

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

func getUser(id int) (*User, error) {
    if id == 0 {
        return nil, fmt.Errorf("getUser %d: %w", id, ErrNotFound)
    }
    return &User{}, nil
}

func main() {
    _, err := getUser(0)
    fmt.Println(errors.Is(err, ErrNotFound))
    fmt.Println(err == ErrNotFound)
}