Go: What is the difference between panic and error?

panic — immediate, unrecoverable (without recover) runtime failure. error — expected, handleable failure returned as a value.

Panic semantics:

• Stops current goroutine execution immediately.
• Runs deferred functions in current goroutine.
• Propagates up call stack looking for recover().
• Without recover(), crashes the program with a stack trace.
• Used for programmer errors, not runtime errors.

1// Panic for programmer errors
2func process(data []int, index int) int {
3    if index < 0 || index >= len(data) {
4        panic(fmt.Sprintf("index %d out of range", index))
5    }
6    return data[index]
7}
8
9// Recoverable panic
10func safeProcess() (result int, err error) {
11    defer func() {
12        if r := recover(); r != nil {
13            err = fmt.Errorf("panic recovered: %v", r)
14        }
15    }()
16    return process([]int{1, 2, 3}, 5) // panics
17}

Error semantics:

• Returned as a function value.
• Caller decides how to handle.
• Program continues execution.
• Used for expected runtime failures.

1// Error for expected failures
2func readConfig(path string) (*Config, error) {
3    data, err := os.ReadFile(path)
4    if err != nil {
5        return nil, fmt.Errorf("reading config: %w", err)
6    }
7    var cfg Config
8    if err := json.Unmarshal(data, &cfg); err != nil {
9        return nil, fmt.Errorf("parsing config: %w", err)
10    }
11    return &cfg, nil
12}

When to use panic:

• init() function failures.
• Out-of-memory conditions.
• Corruption of internal invariants.

When to use error:

• File I/O, network, database operations.
• User input validation.
• All library function returns.

Common mistakes:

• Using panic for normal error paths.
• Ignoring errors (compiler won't stop you).
• Panicking in library code (forces callers to use recover).
• Not checking errors.Is/errors.As for wrapped errors.
• Using log.Fatal (calls os.Exit, skips deferred functions).