Mastering Golang: Error Handling

How Error Handling Works in Golang

Here’s how error handling works in Go:

Error Type:

In Go, an error is treated as a regular value that implements the built-in error interface. The error interface is defined as:

type error interface {
    Error() string
}

This means that any type that has a method named Error that returns a string can be treated as an error.

Returning Errors:

Functions that can potentially encounter errors often return an error value as the last return value. If the function executes successfully, this error value is typically nil, and if there’s an error, it contains a meaningful error message.

Example:

func doSomething() error {
    // ... some logic
    if somethingWrong {
        return fmt.Errorf("something went wrong")
    }
    return nil
}

Checking Errors:

To handle errors, you need to explicitly check the returned error after calling a function. This is usually done using an if statement.

Example:

err := doSomething()
if err != nil {
    fmt.Println("Error:", err)
    // Handle the error appropriately
}

Multiple Return Values:

Go often uses multiple return values to convey additional information along with errors. The last return value is usually an error. This allows you to handle both success and error cases efficiently.

Example:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

Custom Error Types:

You can define your custom error types by implementing the error interface. Custom error types can provide more context and information about the error.

Example:

type MyError struct {
    Message string
}

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

Panic and Recover:

While Go primarily uses explicit error handling, there’s also the concept of panicking and recovering from panics, similar to exceptions in other languages. However, this approach is not recommended for regular error handling. It’s mostly used in exceptional situations like unrecoverable errors.

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("something went horribly wrong")
}