How to use the keyword defer and recover in Golang function together

Golang is an efficient, concise and easy-to-learn programming language that was originally developed by Google and first released in 2009. It is designed to improve programmer productivity and code clarity. In Golang, the function keywords defer and recover are often used together to handle errors that may occur in the program. This article will introduce the use of these two keywords and illustrate their practical application through some examples.

1. How to use defer

defer is a keyword, which is used to delay the execution of some specific code after the function is executed. Delayed execution means that these codes are added to a stack and executed one after another before the function returns.

The syntax of the defer statement is as follows:

defer function_name(argument)

Where, function_name is the name of the function that needs to be delayed, and argument is an optional parameter list . When the function completes execution and the return statement is executed, all defer statements will be executed in sequence.

The following is a sample program that demonstrates the specific usage of the defer statement:

package main

import "fmt"

func main() {
    defer fmt.Println("Hello")
    fmt.Println("World")
}

This program will output "World
Hello" because after executing fmt.Println("World "), the program executes the defer statement and adds it to the stack. When the main() function returns, the stack is popped in sequence, and the last thing executed is the print statement in the defer statement.

2. How to use recover

When the program encounters an error, it will stop execution and exit. But in some cases, we may want the program to continue executing and handle errors. In Golang, we can use the recover keyword to achieve this.

recover is a built-in function only used in the defer statement, which is used to recover from panic. When a program panics, it will forcefully stop execution and resume program execution by calling the recover function in the defer statement.

The following is a sample program that demonstrates the specific usage of the recover statement:

package main

import (
    "fmt"
    "os"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()

    fmt.Println("Start")
    panic("Something wrong")
    fmt.Println("End")
    os.Exit(0)
}

In this program, we use the recover function in the defer statement of the main() function. The anonymous function in the defer statement determines whether panic occurs, prints relevant information and resumes program execution when panic occurs.

When executing this program, we will first see the output "Start", and then the program will throw a panic, the execution control flow will be interrupted, and the print statement will not be executed. But since we use the recover function to resume the execution of the program, "Recovered: Something wrong" will be output before the program is terminated.

3. Combined use of defer and recover

In actual programming, defer and recover are usually used together. For example, when a program needs to roll back when an operation fails, we can create a transaction before the operation starts, commit the transaction after the operation is completed, but when the operation fails, use the defer statement to roll back the operation. At the same time, when encountering an abnormal error, we can use the recover function to resume the execution of the program and perform specific operations.

The following is a sample program about database operations, which demonstrates how defer and recover are used together:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

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

    tx, err := db.Begin()
    if err != nil {
        log.Fatal(err)
    }
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Transaction Rollback:", r)
            tx.Rollback()
        }
    }()
    _, err = tx.Exec("INSERT INTO users(name) VALUES (?)", "Alice")
    if err != nil {
        panic(err)
    }
    _, err = tx.Exec("INSERT INTO users(name) VALUE (?)", "Bob")
    if err != nil {
        panic(err)
    }
    err = tx.Commit()
    if err != nil {
        panic(err)
    }
}

In this program, we open the database connection and create it before the operation starts. A transaction. When an abnormal error occurs during program execution, panic will be triggered, and the program control flow will immediately shift to the execution of the defer statement in the anonymous function. In this statement, we use the recover function to restore the normal execution of the program and perform transaction rollback.

When the program executes successfully, the transaction will be committed and the database connection will be closed. When an abnormal error occurs, the transaction will be rolled back after printing the error message, the database connection will be closed, and the program will exit.

4. Summary

defer and recover are important keywords in Golang. They are often used to handle exception errors that occur in programs. We can use the defer keyword to delay the execution of code that requires special processing after the function is executed. When an abnormal error occurs in the program, we can use the recover keyword to resume the execution of the program and handle the error. In actual programming, we can use these two keywords in combination to handle abnormal situations that may occur in the program and ensure program stability and reliability.

The above is the detailed content of How to use the keyword defer and recover in Golang function together. For more information, please follow other related articles on the PHP Chinese website!