How do you handle errors returned by functions in Go?

In Go, error handling is a crucial aspect as it ensures the robustness and reliability of the program. Go handles errors by returning error values rather than using exceptions. Typically, functions that may return errors include an error type in their return values.

Basic Steps of Error Handling

1. Check for Errors: After calling any function that may return an error, immediately check if the error is nil. If the error is not nil, it indicates an error occurred.

go
data, err := ioutil.ReadFile("filename.txt")
if err != nil {
    // Error handling
    log.Fatal(err)
}

1. Error Handling: If an error is detected, several actions can be taken:

• Log the error and terminate the program.
• Return the error to the caller for higher-level handling.
• Attempt to fix the error, such as implementing retry logic, and continue execution.

1. Designing Error Returns: When writing your own functions, if an exceptional situation or error occurs, design a suitable error object to return.

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

Advanced Usage of Error Handling

• Custom Error Types: By implementing the error interface, you can create more specific error types to convey additional information about the error.

go
type MyError struct {
    Msg    string
    File   string
    Line   int
}

func (e *MyError) Error() string {
    return fmt.Sprintf("%s:%d: %s", e.File, e.Line, e.Msg)
}

• Using the pkg/errors Package: This package provides functionality for wrapping and unwrapping errors while preserving the original stack trace.

go
import "github.com/pkg/errors"

func myFunc() error {
    _, err := someOtherFunc()
    if err != nil {
        return errors.Wrap(err, "someOtherFunc failed")
    }
    return nil
}

Example

Assume we write a simple program to open and read the contents of a file. If an error occurs, log the error details and terminate the program.

go
package main

import (
    "io/ioutil"
    "log"
)

func main() {
    data, err := ioutil.ReadFile("/path/to/file.txt")
    if err != nil {
        log.Fatalf("Failed to read file: %s", err)
    }
    log.Printf("File contents: %s", data)
}

In this example, we use ioutil.ReadFile to read the file, which returns the data and an error. We check if err is not nil to determine if an error occurred. If an error occurs, we use log.Fatalf to log the error details and terminate the program.

Through this approach, Go's error handling is both simple and explicit, helping to write clear and maintainable code.