Why defer is used in Go - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go code using defer?

Look at this Go program. What will it print when run?

Go

package main
import "fmt"
func main() {
    defer fmt.Println("First")
    fmt.Println("Second")
    defer fmt.Println("Third")
}

A

Second
First
Third

B

First
Second
Third

C

Third
First
Second

D

Second
Third
First

💡 Hint

Remember defer calls run after the surrounding function finishes, in reverse order.

The deferred calls are stacked and executed after main ends. So "Second" prints first, then deferred calls print "Third" then "First".

🧠 Conceptual

intermediate

Why use defer in Go functions?

Which of these best explains why Go programmers use defer?

A To run a function immediately before the current line

B To delay execution of a function until the surrounding function returns

C To run a function only if an error occurs

D To run a function repeatedly in a loop

💡 Hint

Think about when deferred functions run compared to normal calls.

Defer schedules a function to run after the current function finishes, useful for cleanup tasks like closing files.

🔧 Debug

advanced

What error occurs in this Go code using defer?

This Go code tries to defer closing a file. What error will it cause?

Go

package main
import (
    "fmt"
    "os"
)
func main() {
    f, err := os.Open("nofile.txt")
    if err != nil {
        fmt.Println("Error opening file")
        return
    }
    defer f.Close()
    fmt.Println("File opened")
}

A panic: runtime error: invalid memory address or nil pointer dereference

B compile error: missing return statement

C no error, prints "File opened"

D runtime error: index out of range

💡 Hint

What happens if os.Open fails and returns nil for the file?

If os.Open fails, f is nil but defer f.Close() still runs, causing a nil pointer dereference panic.

❓ Predict Output

advanced

What is the output order of deferred calls in this Go program?

Predict the output of this Go program with multiple defers.

Go

package main
import "fmt"
func main() {
    for i := 1; i <= 3; i++ {
        defer fmt.Print(i)
    }
}

A 123

B 111

C 321

D Error: cannot use i in defer

💡 Hint

Deferred calls run in last-in, first-out order.

The loop defers printing 1, then 2, then 3. They run in reverse order: 3 2 1.

🧠 Conceptual

expert

What is a key benefit of using defer for resource management in Go?

Why is defer especially useful for managing resources like files or locks in Go?

A It ensures cleanup code runs even if the function returns early or panics

B It speeds up the execution of resource allocation

C It allows resources to be shared between goroutines automatically

D It prevents any errors from occurring during resource use

💡 Hint

Think about functions that might exit in many ways.

Defer guarantees cleanup code runs no matter how the function exits, preventing resource leaks.