Clever use of delayed execution of golang functions

The deferred execution feature of the Go language allows programmers to execute function calls after the function returns. Its main use cases include: Lazy initialization: Delay initialization of large objects or structures until needed. Post-processing: Perform cleanup or post-processing operations after the function returns. Concurrent programming: Scheduling background tasks to run outside of the main goroutine.

The clever use of delayed execution of Go language functions

Delayed execution is a powerful feature in the Go language, which allows programmers to Schedules a function call to be executed after the current function returns. This is useful in various situations, such as:

• Lazy initialization: Defer initializing large or time-consuming objects or structures until they are actually needed.
• Post-processing: Perform cleanup or post-processing operations after the function returns.
• Concurrent programming: Schedule background tasks to run outside of the main goroutine.

Grammar

The syntax for delayed function execution is very simple:

func DeferExample() {
    defer deferFunction()
    return
}

func deferFunction() {
    // 此函数将在 DeferExample 返回后执行
}

Practical case

Lazy initialization of large objects

Let's create a LargeObject structure that contains a large slice:

type LargeObject struct {
    Values []int
}

We can use defer Defer its initialization until needed:

func NewLargeObject() *LargeObject {
    // 定义结构体
    obj := &LargeObject{}

    // 使用 defer 推迟初始化
    defer func() {
        for i := 0; i < 1000000; i++ {
            obj.Values = append(obj.Values, i)
        }
    }()

    // 直接返回结构体而不初始化
    return obj
}

Postprocessing

defer Can also be used to perform cleanup after a function returns or post-processing operations. For example, we can use defer to release the file lock before closing the file:

func OpenAndLockFile(fileName string) (*os.File, error) {
    file, err := os.Open(fileName)
    if err != nil {
        return nil, err
    }

    // 用 defer 在函数返回后关闭文件
    defer file.Close()

    // 使用 flock() 锁定文件
    if err := flock.Lock(file, flock.LockExclusive); err != nil {
        return nil, err
    }

    return file, nil
}

Concurrent Programming

defer can be used for Schedule background tasks to run outside of the main goroutine. For example, we can use defer to start a new goroutine and print a message after the function returns:

func DeferConcurrent() {
    defer func() {
        fmt.Println("任务完成！")
    }()

    // 继续执行其他代码
}

Conclusion

defer is a very useful feature in the Go language. Used wisely, it can greatly improve the clarity, readability, and maintainability of your code.

The above is the detailed content of Clever use of delayed execution of golang functions. For more information, please follow other related articles on the PHP Chinese website!