Go Programming: Custom Error Types

Introduction

Error handling is a critical aspect of software development. In Go, the built-in error interface is used for error handling. However, there are situations where the standard error type may not be sufficient. In such cases, you can create custom error types to provide more context and information about the error.

Creating a Basic Custom Error

To create a custom error type in Go, you need to define a new type that implements the error interface. The error interface has a single method, Error(), which returns a string.

type MyError struct {
    Message string
}

func (e *MyError) Error() string {
    return e.Message
}

In this example, we define a struct MyError with a single field Message. We then implement the Error() method for this struct to return the error message.

Using the Custom Error

Once you have defined a custom error type, you can use it just like any other error. You can create instances of your custom error and return them from functions.

func doSomething() error {
    return &MyError{Message: "Something went wrong"}
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println(err)
    }
}

In this example, the doSomething function returns an instance of MyError. In the main function, we check if an error was returned and print it.

Adding More Context to Custom Errors

You can add more fields to your custom error struct to provide additional context about the error. For example, you might want to include the function name or an error code.

type DetailedError struct {
    Message    string
    Function   string
    ErrorCode  int
}

func (e *DetailedError) Error() string {
    return fmt.Sprintf("Error in %s: %s (code: %d)", e.Function, e.Message, e.ErrorCode)
}

In this example, the DetailedError struct includes fields for the error message, function name, and an error code. The Error() method formats these fields into a single string.

Example: Handling Custom Errors

Here is a complete example that demonstrates how to define, use, and handle custom errors in Go.

package main

import (
    "fmt"
)

type MyError struct {
    Message string
    Code    int
}

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

func doSomething() error {
    return &MyError{Message: "Something went wrong", Code: 123}
}

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

In this example, we define a custom error type MyError with a message and an error code. The doSomething function returns an instance of MyError. In the main function, we use a type switch to handle the custom error specifically.

Conclusion

Custom error types in Go allow you to provide more detailed and context-specific error information. By defining your own error types, you can make your code more robust and easier to debug. Remember to implement the Error() method for your custom error types to satisfy the error interface.