What is the difference between error and exception?

Question

Accepted Answer

**error** — a Go interface for expected failures (value-based). **Exception** — a concept from other languages (Java/C++) not directly present in Go (Go uses panic/recover).

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

**Creating errors:**
```go
// Simple sentinel errors
var (
    ErrNotFound     = errors.New("not found")
    ErrUnauthorized = errors.New("unauthorized")
)

// Custom error types
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("field %s: %s", e.Field, e.Message)
}

// Wrapping errors
func loadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("reading config: %w", err)
    }
    // ...
}
```

**Error handling:**
```go
// errors.Is for sentinel errors (works with wrapping)
if errors.Is(err, ErrNotFound) {
    // handle not found
}

// errors.As for custom error types
var valErr *ValidationError
if errors.As(err, &valErr) {
    fmt.Println(valErr.Field)
}

// Type switch
switch e := err.(type) {
case *ValidationError:
    // handle validation
case *os.PathError:
    // handle file error
}
```

**Go philosophy:**
- "Errors are values" — first-class citizens.
- Explicit handling — no hidden control flow.
- Handle errors where they occur or propagate them.

**Common mistakes:**
- Ignoring errors.
- Not wrapping errors with context.
- Using `==` instead of `errors.Is()`.
- Creating error strings starting with capitals.
- Overusing panic where error return is appropriate.

Go: What is the difference between error and exception?