Defer execution order in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program with multiple defers?

Consider the following Go code snippet. What will it print when run?

Go

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

A

Start
First
Second
Third

B

Third
Second
First
Start

C

Start
Second
Third
First

D

Start
Third
Second
First

💡 Hint

Remember that deferred functions are executed in last-in, first-out order after the surrounding function returns.

The program first prints "Start" immediately. Then, when main returns, deferred calls run in reverse order: "Third", "Second", then "First".

❓ Predict Output

intermediate

What is the output when defers modify a variable?

What will this Go program print?

Go

package main
import "fmt"
func main() {
    x := 0
    defer fmt.Println(x)
    x = 5
    defer fmt.Println(x)
    x = 10
}

A

5
10

B

0
5

C

5
0

D

5
5

💡 Hint

Deferred function arguments are evaluated when the defer statement executes, not when the function runs.

The first defer captures x=0, but the argument is evaluated immediately, so it prints 0. The second defer captures x=5. But actually, in Go, the arguments are evaluated immediately, so the first defer prints 0, second prints 5. However, the order of execution is last-in, first-out, so output is 5 then 0.

Correction: The first defer prints 0, second prints 5, but they run in reverse order, so output is 5 then 0.

❓ Predict Output

advanced

What is the output of this Go program with deferred anonymous functions?

Analyze this code and select the correct output.

Go

package main
import "fmt"
func main() {
    x := 1
    defer func() { fmt.Println(x) }()
    x = 2
    defer func(x int) { fmt.Println(x) }(x)
    x = 3
}

A

2
3

B

3
2

C

3
3

D

1
2

💡 Hint

Deferred anonymous functions without parameters capture variables by reference; those with parameters capture by value.

The first deferred function has no parameters and prints the current value of x when it runs, which is 3. The second deferred function takes x as a parameter, so it captures the value 2 at defer time. Deferred functions run in reverse order, so output is 2 then 3.

❓ Predict Output

advanced

What error or output does this Go code produce?

What happens when you run this Go program?

Go

package main
import "fmt"
func main() {
    defer fmt.Println("A")
    defer fmt.Println("B")
    panic("error")
    defer fmt.Println("C")
}

A

B
A
panic: error

B

A
B
panic: error

C panic: error

D

C
B
A
panic: error

💡 Hint

Deferred functions run even if a panic occurs, but only those deferred before the panic.

The panic stops execution immediately after it runs. Deferred calls before panic run in reverse order: "B" then "A". The defer after panic is never reached. Then the panic message is printed.

❓ Predict Output

expert

What is the final value of x after this Go function runs?

Consider this Go function. What is the value of x printed at the end?

Go

package main
import "fmt"
func main() {
    x := 0
    defer func() {
        x += 1
        fmt.Println("defer1:", x)
    }()
    defer func() {
        x += 2
        fmt.Println("defer2:", x)
    }()
    x = 5
    fmt.Println("main:", x)
}

A

main: 5
defer1: 1
defer2: 3

B

main: 5
defer2: 7
defer1: 8

C

main: 0
defer2: 2
defer1: 3

D

main: 5
defer2: 3
defer1: 4

💡 Hint

Deferred functions run in reverse order and modify the same variable x.

First, main prints x=5. Then deferred functions run in reverse order:

• defer2 adds 2 to x (5+2=7) and prints "defer2: 7"
• defer1 adds 1 to x (7+1=8) and prints "defer1: 8"