golang capture error type

In the Go language, error handling is an important task. Error handling means you need to be able to check that the function performed the correct operation, and in some cases, you need to take action to avoid further errors or damage. In this article, I will discuss the error handling mechanism in golang and how to catch error types.

The error handling mechanism of Go language is handled through the error interface. Error is a predefined interface type in the Go language, defined as follows:

type error interface {
    Error() string
}

All types that implement the Error() method implement the error interface, and therefore can be regarded as error types. In golang, when a function fails to execute or encounters an error, it usually returns a value of type error. For example:

func foo() error {
    if err := doSomething(); err != nil {
        return err
    }
    return nil
}

In the above example, the function foo() will return the error value when the doSomething() function returns an error, otherwise it will return nil.

When we are using functions, we can use if statements to check if an error occurs and take appropriate action as needed. Here is an example:

func main() {
    err := foo()
    if err != nil {
        log.Printf("An error occurred: %v", err)
    }
}

In the above code, if the foo() function returns an error, it will be logged, otherwise nothing will be done.

In some cases we need to check the type of error so that we can take appropriate action. For example, in an http application, we might need to return different HTTP status codes based on the type of error. To do this, we can use type assertions to convert the error type to a specific type of error. For example:

func handleRequest(w http.ResponseWriter, r *http.Request) {
    …
    if err != nil {
        switch err := err.(type) {
        case *myCustomError:
            http.Error(w, err.Error(), http.StatusBadRequest)
        case *otherCustomError:
            http.Error(w, err.Error(), http.StatusInternalServerError)
        default:
            http.Error(w, err.Error(), http.StatusInternalServerError)
        }
    }
}

In the above code, we first use type assertion to convert the error into a specific type of error. Then, in the switch statement, different HTTP status codes are returned based on the error type. If the error type is not any of the known ones, we can return a default status code.

Through type assertion, we can convert the error type into other specific types of error types. The following is a sample code:

type myCustomError struct {
    message string
}

func (e *myCustomError) Error() string {
    return e.message
}

func main() {
    err := &myCustomError{message: "Something went wrong!"}
    if err != nil {
        if customErr, ok := err.(*myCustomError); ok {
            log.Printf("A custom error occurred: %s", customErr.message)
        }
    }
}

In this example, we first create a custom error type myCustomError, which implements the Error() method. In the main() function we convert the error to myCustomError type and check its type. If this type of error occurs, log it. Otherwise, no action is performed.

In short, through the error interface and type assertion mechanism of the Go language, we can easily handle errors and capture error types. I hope this article can help you better understand the error handling mechanism in the Go language.

The above is the detailed content of golang capture error type. For more information, please follow other related articles on the PHP Chinese website!