Go: What is the difference between error and exception?

error — a Go interface type that represents an expected failure. Exception — not a Go concept (languages like Java/C++ use try-catch; Go uses panic/recover).

The error interface:

1type error interface {
2    Error() string
3}

• Any type with an Error() string method implements this interface.
• Errors are values — you can create, return, check, and wrap them.
• Errors propagate explicitly through return values.

Creating custom errors:

1// Using errors.New for simple errors
2var ErrNotFound = errors.New("resource not found")
3
4// Custom error type for structured errors
5type ValidationError struct {
6    Field   string
7    Message string
8}
9
10func (e *ValidationError) Error() string {
11    return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
12}
13
14// Wrapping errors with context
15func readConfig(path string) (*Config, error) {
16    data, err := os.ReadFile(path)
17    if err != nil {
18        return nil, fmt.Errorf("reading config: %w", err) // wrap
19    }
20    // ...
21}

Error checking patterns:

1// Direct comparison
2if err == ErrNotFound {
3    // handle specific error
4}
5
6// Errors.Is for wrapped errors
7if errors.Is(err, ErrNotFound) {
8    // works even if wrapped with fmt.Errorf
9}
10
11// errors.As for custom error types
12var valErr *ValidationError
13if errors.As(err, &valErr) {
14    fmt.Println(valErr.Field)
15}

Go philosophy on errors:

• Errors are values, not exceptional control flow.
• "Don't just check errors, handle them thoughtfully."
• Explicit is better than implicit — you see exactly where errors are handled.

Common mistakes:

• Ignoring errors (result, _ := doSomething()).
• Not wrapping errors (losing context makes debugging hard).
• Comparing errors with == instead of errors.Is() (doesn't work with wrapped errors).
• Treating Go errors like exceptions (panic/recover is NOT the equivalent).
• Overusing panic where an error return would be appropriate.