How do you handle errors in Go?

In Go, errors are explicit and are represented by the built-in ‘error‘ interface. Error-handling is crucial for writing robust and reliable programs. To handle errors in Go, follow these main steps:

1. Return errors from functions.

2. Check and handle the errors immediately after receiving them.

Let’s dive into each step in more detail.

**1. Return errors from functions**

In Go, you typically return an error as the last return value of the function. The ‘error‘ type is an interface type, hence user-defined types can implement this interface and provide custom error behavior. The most common implementation of the ‘error‘ interface is the ‘errors.New‘ function, which creates a new error with the given description.

For example, let’s create a function that divides two numbers and returns an error when the divisor is zero:

package main

import (
    "errors"
    "fmt"
)

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

Here, the ‘divide‘ function returns both the result and the error. When the divisor is zero, it returns an error with a message. Otherwise, it returns the result and a ‘nil‘ error.

**2. Check and handle the errors immediately after receiving them**

To handle the errors in Go, check the returned errors immediately and decide how to proceed based on the error value. Common ways to handle errors include logging the error, returning it up the call stack, or taking some fallback action.

Clarifying the error handling using the ‘divide‘ function example:

package main

import (
    "errors"
    "fmt"
)

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

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

In this example, the ‘main‘ function is calling the ‘divide‘ function and immediately checks if an error was returned. If there is an error, it prints the error message and exits the program; otherwise, it proceeds and prints the result.

Error handling can be further improved by using custom error types or the ‘fmt.Errorf‘ function to provide more context or additional information about the error. Wrapping errors in Go 1.13 and onwards can be done using the ‘%w‘ verb in ‘fmt.Errorf‘ to provide better error tracing.

Remember that:

- Errors in Go are explicit and should always be checked and handled.

- The ‘error‘ type is an interface, which allows for various implementations.

- Returning errors in functions and immediately handling them is a common practice to build robust Go programs.

Given a function that divides two numbers, a and b, return the result r and an error. If b is zero, return an error with an appropriate message:

$$r, err = \left\{ \begin{aligned} & \frac{a}{b}, \quad \text{nil} & \text{if} \quad b \neq 0 \\ & 0, \quad \text{"division by zero is not allowed"} & \text{if} \quad b = 0 \end{aligned} \right.$$