How to handle errors in Go

package main

import (
	"errors"
	"fmt"
)

// An error is an ordinary value: anything with an Error() string method.
func half(n int) (int, error) {
	if n%2 != 0 {
		return 0, errors.New("half: n must be even")
	}
	return n / 2, nil
}

// fmt.Errorf when the message needs the offending values in it.
func withdraw(balance, amount int) (int, error) {
	if amount > balance {
		return balance, fmt.Errorf("withdraw %d: balance is only %d", amount, balance)
	}
	return balance - amount, nil
}

func main() {
	v, err := half(10)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println("half:", v)

	// The if-scoped form: err exists only inside the if.
	if _, err := half(7); err != nil {
		fmt.Println("error:", err)
	}

	if left, err := withdraw(50, 80); err != nil {
		fmt.Println("error:", err, "- balance still", left)
	}
}

package main

import (
	"errors"
	"fmt"
)

var ErrNotFound = errors.New("not found")

func fetchRow(id int) error {
	return ErrNotFound // pretend the database driver returned this
}

func loadUser(id int) error {
	if err := fetchRow(id); err != nil {
		return fmt.Errorf("load user %d: %w", id, err)
	}
	return nil
}

func handler() error {
	if err := loadUser(7); err != nil {
		return fmt.Errorf("GET /users/7: %w", err)
	}
	return nil
}

func main() {
	err := handler()
	fmt.Println(err)

	// %w keeps the original reachable from the top of the chain.
	fmt.Println(errors.Is(err, ErrNotFound))

	// Unwrap peels exactly one layer at a time.
	fmt.Println(errors.Unwrap(err))
	fmt.Println(errors.Unwrap(errors.Unwrap(err)))

	// %v formats the same text but severs the chain.
	flat := fmt.Errorf("GET /users/7: %v", ErrNotFound)
	fmt.Println(flat)
	fmt.Println(errors.Is(flat, ErrNotFound))
}

package main

import (
	"errors"
	"fmt"
	"io"
	"strings"
)

// Sentinels are package-level values, conventionally named Err...
var (
	ErrNotFound   = errors.New("user not found")
	ErrPermission = errors.New("permission denied")
)

func find(name string) error {
	switch name {
	case "ada":
		return nil
	case "root":
		return fmt.Errorf("find %q: %w", name, ErrPermission)
	default:
		return fmt.Errorf("find %q: %w", name, ErrNotFound)
	}
}

func status(name string) string {
	err := find(name)
	switch {
	case err == nil:
		return "200 " + name
	case errors.Is(err, ErrNotFound):
		return "404 " + err.Error()
	case errors.Is(err, ErrPermission):
		return "403 " + err.Error()
	default:
		return "500 " + err.Error()
	}
}

func main() {
	fmt.Println(status("ada"))
	fmt.Println(status("bob"))
	fmt.Println(status("root"))

	// The standard library ships sentinels too -- io.EOF is the famous one.
	r := strings.NewReader("hi")
	buf := make([]byte, 8)
	for {
		n, err := r.Read(buf)
		if errors.Is(err, io.EOF) {
			fmt.Println("done")
			break
		}
		fmt.Println("read", n, "bytes:", string(buf[:n]))
	}
}

package main

import (
	"errors"
	"fmt"
	"strconv"
)

// A custom error type is any struct with an Error() string method.
// The fields are the point: callers read them instead of parsing text.
type ValidationError struct {
	Field  string
	Value  string
	Reason string
}

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

func validateAge(raw string) error {
	n, err := strconv.Atoi(raw)
	if err != nil {
		return &ValidationError{Field: "age", Value: raw, Reason: "not a number"}
	}
	if n < 0 {
		return &ValidationError{Field: "age", Value: raw, Reason: "must not be negative"}
	}
	return nil
}

func main() {
	err := validateAge("-3")
	fmt.Println(err)

	// A type assertion reads the fields back -- but only when err is
	// exactly this type, never when someone has wrapped it.
	if ve, ok := err.(*ValidationError); ok {
		fmt.Println("field:", ve.Field, "| reason:", ve.Reason)
	}

	// errors.As is the wrap-proof version: it searches the whole chain
	// for a value of the target type. Here is strconv's own error type,
	// found two layers down.
	_, perr := strconv.Atoi("12x")
	wrapped := fmt.Errorf("load config: %w", fmt.Errorf("port: %w", perr))
	fmt.Println(wrapped)

	var ne *strconv.NumError
	if errors.As(wrapped, &ne) {
		fmt.Println("func:", ne.Func, "| input:", ne.Num, "| cause:", ne.Err)
	}
	fmt.Println(errors.Is(wrapped, strconv.ErrSyntax))
}

package main

import "fmt"

// A named result plus a deferred recover turns a panic back into an error.
func safeDivide(a, b int) (result int, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("safeDivide: %v", r)
		}
	}()
	return a / b, nil
}

// panic is for "this should be impossible", not for expected failure.
func mustGet(cfg map[string]string, key string) (v string, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("mustGet: %v", r)
		}
	}()
	val, ok := cfg[key]
	if !ok {
		panic("no config key " + key)
	}
	return val, nil
}

// defer runs on every exit path -- which is why it is the cleanup tool,
// not the error-handling tool.
func process(name string) error {
	fmt.Println("open", name)
	defer fmt.Println("close", name)
	if name == "bad.txt" {
		return fmt.Errorf("process %s: unreadable", name)
	}
	fmt.Println("read", name)
	return nil
}

func main() {
	fmt.Println(safeDivide(10, 2))
	fmt.Println(safeDivide(10, 0))

	cfg := map[string]string{"port": "8080"}
	fmt.Println(mustGet(cfg, "port"))
	if _, err := mustGet(cfg, "host"); err != nil {
		fmt.Println(err)
	}

	fmt.Println(process("ok.txt"))
	fmt.Println(process("bad.txt"))
}

package main

import (
	"errors"
	"fmt"
	"strings"
)

var (
	ErrTooShort = errors.New("password too short")
	ErrNoDigit  = errors.New("password needs a digit")
)

func checkPassword(pw string) error {
	var errs []error
	if len(pw) < 8 {
		errs = append(errs, ErrTooShort)
	}
	if !strings.ContainsAny(pw, "0123456789") {
		errs = append(errs, ErrNoDigit)
	}
	return errors.Join(errs...) // nil when errs is empty
}

func main() {
	err := checkPassword("abc")
	fmt.Println(err) // one message per line
	fmt.Println(errors.Is(err, ErrTooShort), errors.Is(err, ErrNoDigit))

	fmt.Println("valid:", checkPassword("hunter2000") == nil)

	// fmt.Errorf accepts more than one %w since Go 1.20, and joins them.
	both := fmt.Errorf("check failed: %w; %w", ErrTooShort, ErrNoDigit)
	fmt.Println(both)
	fmt.Println(errors.Is(both, ErrNoDigit))
}