What is the difference between panic and error?

Question

Accepted Answer

**panic** — immediate runtime failure that stops execution. **error** — expected failure returned as a value.

**Panic behavior:**
- Stops current goroutine.
- Runs deferred functions.
- Propagates for `recover()`.
- Without `recover()`, crashes program.
- Use for programmer errors.

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

// Recover at goroutine boundary
func safeGo(fn func()) {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                log.Printf("panic recovered: %v", r)
            }
        }()
        fn()
    }()
}
```

**Error behavior:**
- Returned as function value.
- Caller decides handling.
- Program continues.
- Use for expected failures.

```go
// Idiomatic error handling
func readJSON(path string, v interface{}) error {
    data, err := os.ReadFile(path)
    if err != nil {
        return fmt.Errorf("reading %s: %w", path, err)
    }
    if err := json.Unmarshal(data, v); err != nil {
        return fmt.Errorf("parsing %s: %w", path, err)
    }
    return nil
}
```

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

**When to use error:**
- 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.

Go: What is the difference between panic and error?