Error Basics in Go

Handling errors in Go is an essential skill for writing robust programs. The language emphasizes simplicity and readability, so error handling follows a straightforward pattern. This guide provides an introduction to Go's error handling mechanisms with practical examples.

Basic Error Handling

In Go, the error type is a built-in interface. Functions that might encounter errors typically return an error value.

Example of Basic Error Handling

package main

import (
	"errors"
	"fmt"
)

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(4, 0)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Result:", result)
}

Custom Error Types

You can define custom error types by implementing the Error() string method. This is helpful in providing more context or structured error messages.

Example of Custom Error Type

package main

import (
	"fmt"
)

type NegativeSqrtError float64

func (e NegativeSqrtError) Error() string {
	return fmt.Sprintf("cannot find sqrt of negative number: %v", float64(e))
}

func sqrt(value float64) (float64, error) {
	if value < 0 {
		return 0, NegativeSqrtError(value)
	}
	// Implement sqrt logic here.
	return value * 0.5, nil // Placeholder implementation
}

func main() {
	result, err := sqrt(-16)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Result:", result)
}

Wrapping Errors

Starting with Go 1.13, you can wrap errors to add context with fmt.Errorf() and the %w format verb, allowing error chain processing.

Example of Error Wrapping and Unwrapping

package main

import (
	"errors"
	"fmt"
)

func complicatedFunction() error {
	return errors.New("original error")
}

func wrapperFunction() error {
	if err := complicatedFunction(); err != nil {
		return fmt.Errorf("wrapperFunction failed: %w", err)
	}
	return nil
}

func main() {
	err := wrapperFunction()
	if err != nil {
		fmt.Println("Error:", err)
	}
}

Best Practices

• Use Meaningful Error Messages: Provide clear and actionable error messages that help identify the failure quickly.
• Return Early: Use early returns on error checks to keep the code clean and reduce nesting.
• Use Custom Error Types for Context: Implement custom error types when additional context is necessary.
• Properly Wrap Errors: Use error wrapping to maintain context across function calls.

Common Pitfalls

• Ignoring Errors: Never ignore an error; always check and handle it appropriately.
• Using Generic Error Messages: Avoid generic messages like "something went wrong." Be specific to help with debugging.
• Misusing Panic for Errors: Use panic only for unrecoverable situations, not as a regular error-handling mechanism.

Performance Tips

• Avoid Complex Logic in Error Checking: Keep error checks straightforward to minimize overhead in critical code paths.
• Minimize Error Allocations: Where performance is critical, minimize allocations by reusing error variables if possible. However, this should not compromise clarity and correctness.