Error handling strategy for Golang functions

Go language provides the following error handling mechanism: Handle errors directly: check the err variable in the function body. Use defer: Execute code when the function exits, regardless of whether the function returns normal or error, for cleaning up resources or printing an error message. Use recover: Capture runtime panics, usually caused by unhandled errors. Custom types and error wrapping: Create custom error types and wrap other errors using the errors.Is and errors.As functions, allowing type assertions.

Error handling strategy for Go functions

The Go language provides a powerful error handling mechanism that allows developers to handle errors in a clear and unified manner. This article will introduce different strategies for error handling in Go and demonstrate them through practical cases.

Definition and return of error values

In Go, error values ​​are represented by the error interface, which is just a method that implements the Error() type. Error values ​​are usually created via the nil or errors.New() function. Here's how to define and return an error value:

func myFunction() error {
    return errors.New("error message")
}

Handling Errors Directly

The easiest way is to handle errors directly by checking the err variable in the function body :

func main() {
    if err := myFunction(); err != nil {
        log.Println(err)
    }
}

Using the defer

defer statement allows code to be executed when a function exits, regardless of whether the function returns normal or an error. This can be used to clean up resources or print error messages:

func main() {
    defer func() {
        if err := recover(); err != nil {
            log.Println(err)
        }
    }()

    myFunction()
}

Runtime panics can be captured using the recover

##recover function, which is usually caused by Caused by unhandled errors. Unhandled errors can be handled by calling recover in the main function:

func main() {
    if err := recover(); err != nil {
        log.Println(err)
    }

    myFunction()
}

Custom types and error wrappers

For complex scenarios, You can create custom error types and wrap other errors using the

errors.Is and errors.As functions. This allows type assertions within the error hierarchy:

type MyError struct {
    error
}

func main() {
    if err := myFunction(); err != nil {
        if myError, ok := err.(MyError); ok {
            log.Println(myError)
        } else {
            log.Println(err)
        }
    }
}

Practical Example

Consider an application that needs to connect to a database and execute queries. Applications can handle errors as follows:

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    rows, err := db.Query("SELECT * FROM table")
    if err != nil {
        log.Println(err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var name string
        if err := rows.Scan(&name); err != nil {
            log.Println(err)
            continue
        }
        log.Println(name)
    }
}

Applications use the

defer statement to ensure that database and query handles are properly closed when an error is encountered. It also uses direct error handling to print error messages and continue processing to avoid interrupting the entire application due to a single error.

The above is the detailed content of Error handling strategy for Golang functions. For more information, please follow other related articles on the PHP Chinese website!