Go: What is the difference between panic and error?

panic — immediate runtime failure that stops normal execution. error — expected failure returned as a value for graceful handling.

Panic mechanics:

• Stops current goroutine immediately.
• Runs deferred functions in current goroutine.
• Propagates up call stack for recover().
• Without recover(), crashes program with stack trace.
• Use for programmer errors, not user-facing errors.

1// Panic for invariant violations
2func MustParse(s string) Config {
3    cfg, err := Parse(s)
4    if err != nil {
5        panic("invalid config: " + err.Error())
6    }
7    return cfg
8}
9
10// Recover in goroutine boundary
11func safeWorker() {
12    defer func() {
13        if r := recover(); r != nil {
14            log.Printf("worker panic: %v\n%s", r, debug.Stack())
15        }
16    }()
17    // ... worker logic
18}

Error mechanics:

• Returned as function value.
• Caller decides handling strategy.
• Program continues normally.
• Use for expected runtime failures.

1// Idiomatic error handling
2func FindUser(id int) (*User, error) {
3    row := db.QueryRow("SELECT * FROM users WHERE id=$1", id)
4    var user User
5    if err := row.Scan(&user.ID, &user.Name); err != nil {
6        if errors.Is(err, sql.ErrNoRows) {
7            return nil, fmt.Errorf("user %d: %w", id, ErrNotFound)
8        }
9        return nil, fmt.Errorf("querying user %d: %w", id, err)
10    }
11    return &user, nil
12}

When to use panic:

• init() failures.
• Unrecoverable conditions.
• Programmer mistakes (nil dereference, index out of bounds).

When to use error:

• All library functions.
• I/O operations.
• User input validation.

Common mistakes:

• Using panic for normal error paths.
• Ignoring errors.
• Panicking in library code.
• Not using errors.Is/errors.As.
• Using log.Fatal instead of returning error.