Go: What is the difference between panic and error?

panic — an unrecoverable runtime error that stops normal execution. error — an expected failure that can be handled gracefully.

panic behavior:

• Immediately stops the current goroutine's normal execution.
• Runs all deferred functions in the goroutine.
• Propagates up the call stack looking for a recover().
• If no recover() is found, the program crashes.
• Prints a stack trace to stderr.

1func riskyOperation() {
2    // This will crash the program
3    panic("something went terribly wrong")
4}
5
6// Built-in functions that panic:
7var s []int
8_ = s[0]       // index out of range panic
9var m map[string]int
10_ = m["key"]   // nil map access panic
11var p *int
12_ = *p          // nil pointer dereference panic

error behavior:

• Returned as a normal function return value.
• The caller decides what to do.
• No stack trace (unless explicitly added).
• Program continues running.

1func divide(a, b int) (int, error) {
2    if b == 0 {
3        return 0, errors.New("division by zero")
4    }
5    return a / b, nil
6}
7
8// Caller handles the error
9result, err := divide(10, 0)
10if err != nil {
11    log.Printf("Error: %v", err)
12    return // graceful handling
13}

When to use panic:

• In init() functions (configuration must be valid).
• When a programmer makes a mistake (nil pointer, index out of bounds).
• For truly unrecoverable errors where continuing is dangerous.

When to use error:

• All expected failures (file not found, network timeout, invalid input).
• Library functions (never panic in library code).
• API endpoints (return error responses, not crashes).

Common mistakes:

• Using panic for normal error handling (instead of returning error).
• Ignoring errors (result, _ := divide(10, 0)).
• Panicking in library code (forces callers to use recover).
• Using log.Fatal which calls os.Exit(1) — deferred functions won't run.