Error handling in Golang: Create custom errors using errors.New function

Error handling in Golang: Create custom errors using errors.New function

Error handling is an integral part of software development. In Golang, error handling is handled by returning error information as a return value. Golang itself provides some error types, such as the error interface and functions in the errors package. This article will focus on how to use the errors.New function to create custom errors.

In Golang, the errors.New function is used to create a new error type value. This function accepts a string as a parameter and returns it as an error message.

Here is a simple example that demonstrates how to create a custom error using the errors.New function:

package main

import (
    "errors"
    "fmt"
)

func divide(a int, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

In the above example, we implemented an object called divide function, which is used to calculate the division of two integers. If the divisor is 0, a custom error is created and returned. In the main function, we call the divide function and process it based on the returned error information.

By running the above code, we will get the following output:

Error: division by zero

You can see that since the divider is zero, the divide function returns an error and passes it given to the caller. The caller receives this error in the err variable and prints it.

Creating custom errors using the errors.New function is very simple and is very suitable for some simple error scenarios. But in complex applications, we may need to customize more detailed error types to better distinguish different error conditions and provide more information.

In order to implement a custom error type, we can define a new structure and make it implement the error interface provided by Golang.

The following is a sample code that demonstrates how to define a custom error type:

package main

import "fmt"

type MyError struct {
    Code    int
    Message string
}

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

func main() {
    err := &MyError{Code: 500, Message: "Internal Server Error"}
    fmt.Println(err.Error())
}

In the above example, we defined a structure named MyError type, and added the Error method to it, making it implement the error interface. In the Error method, we use the fmt.Sprintf function to format the error message.

In the main function, we create a value of type MyError, convert it into a string by calling its Error method, and print it.

By running the above code, we will get the following output:

Error 500: Internal Server Error

As you can see, the custom error type MyError successfully implements the error interface, and we can Provide more error information.

To sum up, Golang’s error handling mechanism is very simple and flexible. By using the errors.New function we can quickly create custom errors. For more complex applications, we can define our own error types and implement the error interface provided by Golang to provide more error information and fine-grained control of errors.

The above is the detailed content of Error handling in Golang: Create custom errors using errors.New function. For more information, please follow other related articles on the PHP Chinese website!