Defer Statement

Introduction

In the Go programming language, managing resources such as file handles or network connections is crucial. Ensuring that these resources are properly closed after their use can prevent memory leaks and other runtime errors. The defer statement provides a convenient way to ensure that a function call is performed later in a program’s execution, typically for purposes of cleanup.

Concept

The defer statement schedules a function call to be executed later in the current goroutine's execution. These deferred calls are executed in LIFO (Last In, First Out) order, meaning the last deferred function will run first. This is particularly useful when you need to ensure that certain operations, like closing files or releasing resources, occur after other code has been executed.

Syntax

The basic syntax of a defer statement is:

defer func() {
    // cleanup code here
}()

You can also defer calls to named functions:

func cleanup() {
    // cleanup code here
}

defer cleanup()

Examples

Let's explore some practical examples to understand how the defer statement works.

Example 1: Basic Defer Usage

Consider a simple example where we open a file and ensure it is closed after its contents are read:

package main

import (
    "fmt"
    "os"
)

func readFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // Ensure the file is closed after this function returns

    data := make([]byte, 100)
    n, err := file.Read(data)
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }

    fmt.Printf("Read %d bytes: %s\n", n, string(data))
}

func main() {
    readFile("example.txt")
}

In this example, `defer file.Close()` ensures that the file is closed after the `readFile` function completes, regardless of whether it returns normally or due to an error.

### Example 2: Multiple Defer Statements

You can use multiple `defer` statements in a single function. They will be executed in reverse order:

```go
package main

import "fmt"

func example() {
    fmt.Println("Function started")
    defer fmt.Println("Second defer statement")
    defer fmt.Println("First defer statement")
    fmt.Println("Function ended")
}

func main() {
    example()
}

The output of this program will be:

<OutputBlock>
{`Function started
Function ended
First defer statement
Second defer statement`}
</OutputBlock>

### Example 3: Defer with Arguments

The arguments to a deferred function are evaluated when the `defer` statement is executed, not when the function is called later:

```go
package main

import "fmt"

func example() {
    i := 1
    defer fmt.Println("Deferred:", i)
    i++
    fmt.Println("After incrementing:", i)
}

func main() {
    example()
}

The output will be:

<OutputBlock>
{`After incrementing: 2
Deferred: 1`}
</OutputBlock>

This demonstrates that the value of `i` at the time of the `defer` statement is captured and used later.

## What's Next?

In the next section, we will explore how to handle runtime errors using `panic` and `recover`. These mechanisms provide a way to manage unexpected situations in your Go programs, ensuring that your application can gracefully handle errors and continue running or terminate cleanly.