What does golang defer mean?

In Golang, the defer statement is used to postpone the execution of a function or method until the current function or method block is executed. It is a very useful language construct that can help programmers complete important operations such as resource release and exception handling in many scenarios.

The defer statement can be used to handle the following scenarios:

1. Resource release

When processing resources such as files, network connections, database connections, etc., we must release them after use Release in time to avoid resource leakage. The defer statement can automatically execute the logic of releasing resources after the current function is executed, reducing the burden on programmers. For example:

func readFromFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }

    defer f.Close() // 在函数执行完毕后释放文件资源

    data, err := ioutil.ReadAll(f)
    if err != nil {
        return nil, err
    }

    return data, nil
}

2. Exception recovery

When the function is executed, an exception may occur and the function cannot end normally. In order to avoid program crashes caused by exceptions, we can use the defer statement to perform necessary exception handling when an exception occurs in the function. For example:

func doSomething() error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }

    defer func() {
        if p := recover(); p != nil { // 发生异常时处理事务回滚
            tx.Rollback()
            log.Println("panic:", p)
        }
    }()

    // 在函数执行完毕前提交事务
    err = tx.Commit()
    if err != nil {
        return err
    }

    return nil
}

In the above code, if an exception occurs when the function commits a transaction, the defer statement will capture the exception and perform a transaction rollback operation to ensure data consistency.

3. Performance analysis

It is very useful to perform performance analysis while the program is running. The execution time of a function can be calculated by printing timestamps at the beginning and end of the function. For example:

func myFunc() {
    defer func() {
        log.Printf("myFunc took %v", time.Since(start))
    }()

    start := time.Now()

    // 函数的具体实现

    return
}

In the above code, the current time point is recorded when the function starts, and the time difference is calculated when the function ends to calculate the function execution time.

In short, the defer statement is a very practical language construct in Golang that can help programmers simplify code implementation and handle some common scenarios. It should be noted that when using the defer statement, operations such as exceptions and resource release must be handled carefully to ensure the reliability and consistency of the code.

The above is the detailed content of What does golang defer mean?. For more information, please follow other related articles on the PHP Chinese website!