Why Use Defer In Golang

Go Programming

When it comes to programming in Go (Golang), there are many features and concepts that make it a powerful and efficient language. One such feature is the use of the defer statement. In this article, I will explain why using defer in Golang is not only a good practice but can also improve the readability and maintainability of your code.

First of all, what does the defer statement actually do? In simple terms, it allows you to schedule a function call to be executed when the surrounding function returns. This means that the deferred function will be invoked regardless of how the surrounding function exits – whether it returns normally or panics.

One of the main advantages of using defer is that it helps to ensure that certain cleanup tasks are always performed before exiting a function. For example, if you open a file or acquire a lock within a function, you can use defer to ensure that the file is closed or the lock is released, even if an error occurs in the function.

Let me give you a real-life example to illustrate the power of defer. Imagine you are writing a function that opens a file, reads its contents, and then closes the file. Without using defer, you would need to manually close the file before returning from the function, taking care of both successful and error paths. This can easily lead to code duplication and errors.

However, by using defer, you can simply defer the file close operation right after opening the file, like this:

func readFile(filename string) ([]byte, error) {
  file, err := os.Open(filename)
  if err != nil {
    return nil, err
  defer file.Close()
  ... // Read the file and process its contents

With this approach, you can be sure that the file will always be closed, no matter how the function exits. This not only reduces the chances of resource leaks but also makes the code more concise and easier to read.

Another benefit of using defer is that it allows you to separate the logic of acquiring and releasing resources, making the code more modular and reusable. In the example above, the file close operation is clearly associated with the file open operation, improving the code’s readability and maintainability.

It is worth noting that defer statements are executed in a last-in, first-out (LIFO) order. This means that if you have multiple defer statements in a function, they will be executed in the reverse order of their appearance. Understanding this behavior is crucial when dealing with functions that return values.

For example, consider the following code:

func process() (int, error) {
  defer fmt.Println("Second defer")
  defer fmt.Println("First defer")
  return 42, nil

The output of calling this function would be:

First defer

Second defer

This order of execution can be surprising at first, but it becomes intuitive once you understand the LIFO behavior of defer statements.

In conclusion, using the defer statement in Golang is a powerful tool that can greatly enhance the readability and maintainability of your code. It ensures that cleanup tasks are always performed, reduces code duplication, and makes your code more modular and reusable. By understanding the LIFO behavior of defer, you can leverage this feature effectively in your applications.


As a Golang developer, I highly recommend using the defer statement in your code. It not only helps to improve the robustness and reliability of your applications but also makes your code more elegant and concise. By incorporating defer into your programming toolbox, you can take full advantage of this powerful language feature.