在 Go 中使用 defer：最佳实践和常见用例

func examplefunction() {
    fmt.println("start of function")

    defer fmt.println("first defer: executed last")
    defer fmt.println("second defer: executed second")
    defer fmt.println("third defer: executed first")

    fmt.println("end of function")
}

start of function
end of function
third defer: executed first
second defer: executed second
first defer: executed last

func processfile(filename string) error {
    file, err := os.open(filename)
    if err != nil {
        return err // return the error if opening the file fails
    }
    defer file.close() // ensure the file is closed when the function exits

    // process the file...
    return nil
}

var mu sync.mutex

func criticalsection() {
    mu.lock()
    defer mu.unlock() // ensure the mutex is unlocked when the function exits

    // critical section...
}

func querydatabase() error {
    db, err := sql.open("driver", "database=example")
    if err != nil {
        return err
    }
    defer db.close() // ensure the database connection is closed when the function exits

    // query the database...
    return nil
}

func changedirectory() error {
    olddir, err := os.getwd()
    if err != nil {
        return err
    }
    err = os.chdir("/tmp")
    if err != nil {
        return err
    }
    defer os.chdir(olddir) // restore the working directory when the function exits

    // work in /tmp...
    return nil
}

func safefunction() {
    defer func() {
        if r := recover(); r != nil {
            log.println("recovered from panic:", r)
        }
    }()
    // code that might panic...
}

func measuretime() {
    start := time.now()
    defer func() {
        duration := time.since(start)
        log.printf("execution time: %v", duration)
    }()

    // code to measure...
}

func bufferedwrite() {
    buf := bufio.newwriter(os.stdout)
    defer buf.flush() // ensure the buffer is flushed when the function exits

    buf.writestring("hello, world!")
}

func handlerequest(req *http.request) error {
    // ensure that the request body is closed when the function exits
    defer func() {
        if err := req.body.close(); err != nil {
            log.println("error closing request body:", err)
        }
    }()

    body, err := io.readall(req.body)
    if err != nil {
        return err
    }

    // process the body...
    fmt.println("request body:", string(body))

    return nil
}

file, err := os.open(filename)
if err != nil {
    return err // handle error
}
// risk: if something goes wrong before this point, the file might never be closed
// additional operations here...
file.close() // attempt to close the file later

file, err := os.Open(fileName)
defer file.Close() // Incorrect: This should be deferred after the error check
if err != nil {
    return err // Handle error
}
// Additional operations here...