Go Error Handling Quick Reference Cheat Sheet

// Error handling pattern
result, err := doSomething()
if err != nil {
    return fmt.Errorf("context: %w", err)
}

// Custom error
type NotFoundError struct {
    ID int
}
func (e *NotFoundError) Error() string {
    return fmt.Sprintf("not found: %d", e.ID)
}

// errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }
var nfe *NotFoundError
if errors.As(err, &nfe) { ... }

// Error wrapping pattern
if err != nil {
    return fmt.Errorf("operation failed: %w", err)
}

// Table-driven tests
tests := []struct{
    name string
    input int
    want  int
}{
    {"positive", 5, 25},
    {"zero", 0, 0},
}
for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        got := Square(tt.input)
        if got != tt.want { t.Errorf(...) }
    })
}

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

// Custom error type
type ValidationError struct {
    Field   string
    Message string
}
func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

// Multi-error handling
var errs []error
for _, item := range items {
    if err := validate(item); err != nil {
        errs = append(errs, err)
    }
}
return errors.Join(errs...)

// Generics (Go 1.18+)
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// Type constraints
type Number interface {
    ~int | ~float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums { total += n }
    return total
}

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2,3) = %d; want 5", got)
    }
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

func FuzzParse(f *testing.F) {
    f.Add("42")
    f.Fuzz(func(t *testing.T, s string) {
        Parse(s) // should not panic
    })
}