How do you create a custom error type in Go?

In Go, creating custom error types is often used to provide more detailed error information or to categorize errors. Go provides a highly flexible error handling mechanism through its built-in error interface. The error interface is very simple, defined as follows:

go
type error interface {
    Error() string
}

Any type that implements the Error() string method can be used as an error type. This offers significant flexibility for creating custom error types.

Here are the steps to create and use custom error types:

Step 1: Define a Custom Error Type

First, define a struct that implements the error interface. This struct can include any fields you want, which can be used to describe additional details about the error.

go
// MyError is a custom error struct
type MyError struct {
    Code    int
    Message string
}

// Implement the error interface
func (e *MyError) Error() string {
    return fmt.Sprintf("Code: %d, Message: %s", e.Code, e.Message)
}

Step 2: Use Custom Error Types

With your custom error type, you can create instances of it in functions and return them when appropriate.

go
func doSomething() error {
    // This is an example; assume a failure condition
    if true { // Some condition causes an error
        return &MyError{
            Code:    404,
            Message: "Resource not found",
        }
    }
    return nil
}

Step 3: Handle Custom Error Types

When your function returns a custom error, you can use type assertions to retrieve more information about the error.

go
func main() {
    err := doSomething()
    if err != nil {
        switch e := err.(type) {
        case *MyError:
            fmt.Println("MyError occurred:", e)
        default:
            fmt.Println("Generic error occurred:", err)
        }
    }
}

This example demonstrates how to define and use custom error types. By using type assertions, you can check the specific error type and handle it differently based on the error type, which is very helpful for building maintainable and scalable systems.