Error Handling in Go

#

Go’s approach to error handling is explicit and straightforward. Errors are values that are returned from functions, not thrown as exceptions.

The error Type

#

The error type is a built-in interface:

type error interface {
    Error() string
}

// Using errors
import "errors"

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

Creating Custom Errors

#

Create custom error types by implementing the error interface:

type ValidationError struct {
    Field string
    Message string
}

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

func validateAge(age int) error {
    if age < 0 {
        return &ValidationError{
            Field: "age",
            Message: "cannot be negative",
        }
    }
    return nil
}

Error Wrapping

#

Wrap errors to add context using fmt.Errorf with %w:

import (
    "fmt"
    "errors"
)

func readConfig(filename string) error {
    _, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("failed to read config: %w", err)
    }
    return nil
}

func main() {
    err := readConfig("config.json")
    if err != nil {
        fmt.Println(err)
        
        // Unwrap to check original error
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("Config file not found")
        }
    }
}

Error Checking Patterns

#

Common patterns for checking specific errors:

// errors.Is - check if error matches a value
if errors.Is(err, os.ErrNotExist) {
    // Handle file not found
}

// errors.As - check if error is of a specific type
var validationErr *ValidationError
if errors.As(err, &validationErr) {
    fmt.Println("Field:", validationErr.Field)
}

// Type assertion
if netErr, ok := err.(*net.Error); ok {
    if netErr.Timeout() {
        // Handle timeout
    }
}

Panic and Recover

#

For unrecoverable errors, use panic and recover:

func riskyOperation() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from:", r)
        }
    }()
    
    // This will panic
    panic("something went wrong")
}

// Use panic sparingly, only for truly exceptional situations
func mustConnect(addr string) *Connection {
    conn, err := connect(addr)
    if err != nil {
        panic(fmt.Sprintf("failed to connect to %s: %v", addr, err))
    }
    return conn
}

Best Practices

#

Guidelines for effective error handling:

// 1. Always check errors
f, err := os.Open("file.txt")
if err != nil {
    return err
}
defer f.Close()

// 2. Provide context with error messages
if err != nil {
    return fmt.Errorf("failed to process user %d: %w", userID, err)
}

// 3. Handle errors at the appropriate level
func processFile(filename string) error {
    // Handle specific errors here
    if err := validateFile(filename); err != nil {
        return err
    }
    
    // Let unexpected errors bubble up
    return processData(filename)
}

// 4. Use named return values for error handling
func operation() (result int, err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("operation failed: %w", err)
        }
    }()
    
    // Do work...
    return
}