Home > Article > Backend Development > 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!