What is the difference between error and exception?

Question

Accepted Answer

**error** — a Go interface type representing expected failures. **Exception** — a concept from other languages (Java/C++) not directly present in Go (Go uses panic/recover instead).

**The error interface:**
```go
type error interface {
    Error() string
}
```
Any type with `Error() string` method implements this interface.

**Error creation patterns:**
```go
// Simple errors
var ErrNotFound = errors.New("not found")
var ErrPermission = errors.New("permission denied")

// Custom error types
type APIError struct {
    StatusCode int
    Message    string
}

func (e *APIError) Error() string {
    return fmt.Sprintf("API error %d: %s", e.StatusCode, e.Message)
}

// Error wrapping (Go 1.13+)
func fetchData(url string) ([]byte, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("fetching %s: %w", url, err)
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
```

**Error handling:**
```go
// Direct comparison
if err == ErrNotFound {
    // handle
}

// Wrapped error comparison
if errors.Is(err, ErrNotFound) {
    // works with wrapped errors
}

// Type assertion for custom errors
var apiErr *APIError
if errors.As(err, &apiErr) {
    fmt.Println(apiErr.StatusCode)
}
```

**Go philosophy:**
- "Errors are values" — they can be stored, passed, checked.
- Explicit error handling — no hidden control flow.
- "Don't just check errors, handle them thoughtfully."

**Common mistakes:**
- Ignoring errors completely.
- Not wrapping errors with context.
- Using `==` instead of `errors.Is()` for comparison.
- Creating error strings that start with capitals or end with punctuation (Go convention).
- Overusing `panic` where `error` return is appropriate.

Go: What is the difference between error and exception?