What is the difference between panic and error?

Question

Accepted Answer

**panic** — immediate runtime failure. **error** — expected failure returned as value.

**Panic:**
- Stops goroutine immediately.
- Runs deferred functions.
- Propagates for `recover()`.
- Use for programmer errors.

```go
// Panic for invariant violations
func MustParse(s string) Config {
    cfg, err := Parse(s)
    if err != nil {
        panic("invalid config: " + err.Error())
    }
    return cfg
}

// Recover at boundary
func safeWorker() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("panic: %v", r)
        }
    }()
    // ... work
}
```

**Error:**
- Returned as value.
- Caller handles.
- Program continues.
- Use for expected failures.

```go
func readData(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("reading %s: %w", path, err)
    }
    return data, nil
}
```

**When to use panic:**
- `init()` failures.
- Unrecoverable conditions.

**When to use error:**
- Library functions.
- I/O operations.

**Common mistakes:**
- Using panic for normal errors.
- Ignoring errors.
- Panicking in library code.
- Not using `errors.Is`/`errors.As`.
- Using `log.Fatal` instead of error.

Go: What is the difference between panic and error?