This is a contrived example, but imagine a situation where I have a file I want to write on disk and then have a reference to it in a database. If I have a flow like:
func UpdateUser(user *User) (err error) {
f, err := os.Create("/some/file.txt")
if err != nil {
return err
}
defer CheckClose(f, &err)
if _, err := f.Write(somedata); err != nil {
return err
}
if err := db.UpdateUser(user, "/some/file.txt"); err != nil {
return err
}
return
}
This function might have updated the user in the database with a new file despite the fact that `CheckClose` (defined up-thread) does check to see if the `Close` failed and returned an error. The calling code won't have known this has happened.
The core problem is that the error checking is not done soon enough, either because Go programmers are conditioned to `defer f.Close()` from nearly all example code -- most of it demonstrating reads, not writes -- or because they are handling the error, but only in a deferred function, not earlier.
A more correct way to do this would be:
func UpdateUser(user *User) error {
f, err := os.Create("/some/file.txt")
if err != nil {
return err
}
defer f.Close()
if _, err := f.Write(somedata); err != nil {
return err
}
if err := f.Sync(); err != nil {
return err
}
if err := f.Close(); err != nil {
return err
}
if err := db.UpdateUser(user, "/some/file.txt"); err != nil {
return err
}
}
`Sync()` flushes the data to disk, and `Close()` gives a "last-chance" opportunity to return an error. The `defer f.Close()` exists as a way to ensure resource cleanup if an error occurs before the explicit `f.Close()` toward the end of the function. As I mentioned in an update to the post, double `Close()` is fine.