In Go, errors are represented as values of the built-in error
type. To handle errors, you typically use the following pattern:
result, err := someFunctionThatReturnsAnError()
if err != nil {
// Handle the error
// For example, log the error or return an error to the caller
log.Println(“An error occurred:”, err)
return err
}
// Use the result
In this pattern, you call a function that returns a result and an error. You check if the error is nil
(indicating success) and handle it if it’s not. If there is no error, you can use the result.
Some functions in Go may return multiple values, including an error. In these cases, you can use the blank identifier (_
) to discard the values you don’t need. For example:
_, err := someFunctionThatReturnsAnError()
if err != nil {
// Handle the error
}
In addition to the built-in error
type, Go also provides the fmt.Errorf()
function for creating custom error messages. This function returns an error
value that you can use in the same way as other errors.
return fmt.Errorf("Failed to do something: %v", someValue)
Overall, Go’s error handling approach encourages explicit handling of errors and makes it easy to propagate errors up the call stack.