What are the different types of errors in Go?

What are the different types of errors in Go?

In Go, errors are typically represented by the built-in error type. There are several types of errors, including:

1. Standard Errors: These are returned by functions that fail, like os.Open.
2. Custom Errors: You can create your own error types by implementing the Error() method.
3. Wrapped Errors: Go 1.13 introduced error wrapping, allowing you to add context to errors using fmt.Errorf with %w.
4. Panic and Recover: These are not errors in the traditional sense but are used for handling unexpected situations.

Can you explain how to create a custom error?

Sure! To create a custom error in Go, you define a new type that implements the error interface. Here's a simple example:

package main

import "fmt"

// Define a custom error type
type MyError struct {
    Message string
}

// Implement the Error() method
func (e *MyError) Error() string {
    return e.Message
}

func main() {
    err := &MyError{Message: "This is a custom error"}
    fmt.Println(err)
}

This way, you can create and return your own error types.

What is error wrapping and how do I use it?

Error wrapping in Go allows you to add context to an error while preserving the original error. You can use fmt.Errorf with the %w verb. Here's an example:

package main

import (
    "errors"
    "fmt"
)

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

func main() {
    err := doSomething()
    if err != nil {
        wrappedErr := fmt.Errorf("an error occurred: %w", err)
        fmt.Println(wrappedErr)
    }
}

This will print: "an error occurred: original error".