Defer execution order in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to defer printing "First".

Go

package main
import "fmt"
func main() {
    [1] fmt.Println("First")
    fmt.Println("Second")
}

Drag options to blanks, or click blank then click option'

Ago

Bdefer

Cfunc

Dprint

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'go' instead of 'defer' causes the function to run concurrently.

Forgetting 'defer' causes immediate execution.

The defer keyword delays the execution of the function until the surrounding function returns.

2fill in blank

medium

Complete the code to print "Third" last using defer.

Go

package main
import "fmt"
func main() {
    defer fmt.Println("[1]")
    fmt.Println("First")
    fmt.Println("Second")
}

Drag options to blanks, or click blank then click option'

AThird

BFirst

CSecond

DLast

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'First' or 'Second' will print them immediately, not deferred.

Using 'Last' is not the exact string to print.

The deferred call prints "Third" after the other prints because defer delays execution until the function ends.

3fill in blank

hard

Fix the error in the defer statement to print "Done" last.

Go

package main
import "fmt"
func main() {
    defer fmt.Println([1])
    fmt.Println("Start")
}

Drag options to blanks, or click blank then click option'

Adone

BDone

C"Done"

D'Done'

Attempts:

3 left

💡 Hint

Common Mistakes

Using unquoted Done causes a compile error.

Using single quotes 'Done' is invalid for strings.

Strings in Go must be enclosed in double quotes. Using "Done" correctly passes a string literal.

4fill in blank

hard

Fill both blanks to defer two prints so "Second" prints before "First".

Go

package main
import "fmt"
func main() {
    defer fmt.Println([1])
    defer fmt.Println([2])
    fmt.Println("Start")
}

Drag options to blanks, or click blank then click option'

A"First"

B"Start"

C"Second"

D"End"

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the strings will print in the wrong order.

Using unrelated strings confuses the output order.

Deferred calls run in last-in-first-out order. The second defer prints "Second" before the first defer prints "First".

5fill in blank

hard

Fill all three blanks to defer prints so output order is: Start, Third, Second, First.

Go

package main
import "fmt"
func main() {
    fmt.Println("Start")
    defer fmt.Println([1])
    defer fmt.Println([2])
    defer fmt.Println([3])
}

Drag options to blanks, or click blank then click option'

A"Start"

B"First"

C"Second"

D"Third"

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing the order of deferred prints changes output order.

Not quoting strings causes compile errors.

The immediate print shows "Start" first. Deferred prints run in reverse order: last defer prints "Third", then the middle defer prints "Second", then the first defer prints "First".

Practice

1. What happens when multiple defer statements are used in a Go function?

easy

A. Deferred calls execute in last-in, first-out order when the function returns.

B. Deferred calls execute immediately when encountered.

C. Deferred calls execute in the order they appear in the code.

D. Deferred calls never execute automatically.

Solution

1. Step 1: Understand defer behavior

   In Go, deferred functions are postponed until the surrounding function returns.

2. Step 2: Execution order of deferred calls

   Deferred calls run in reverse order of their appearance, like a stack (last-in, first-out).

3. Final Answer:

   Deferred calls execute in last-in, first-out order when the function returns. -> Option A

4. Quick Check:

   Defer order = last-in, first-out [OK]

Hint: Remember: defer calls run backwards at function end [OK]

Common Mistakes:

• Thinking defer calls run immediately
• Assuming defer calls run in code order
• Believing defer calls never run

2. Which of the following is the correct syntax to defer a function call in Go?

easy

A. defer() fmt.Println("Hello")

B. defer := fmt.Println("Hello")

C. defer fmt.Println("Hello")

D. defer call fmt.Println("Hello")

Solution

1. Step 1: Recall defer syntax

   The keyword defer is followed directly by the function call without assignment or parentheses around defer.

2. Step 2: Identify correct syntax

   defer fmt.Println("Hello") correctly uses defer fmt.Println("Hello"). Other options misuse defer syntax.

3. Final Answer:

   defer fmt.Println("Hello") -> Option C

4. Quick Check:

   defer + function call = correct syntax [OK]

Hint: Use 'defer' directly before function call without extra symbols [OK]

Common Mistakes:

• Adding := after defer
• Using parentheses after defer keyword
• Writing extra words like 'call' after defer

3. What is the output of this Go program?

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

medium

A. Third
First
Second

B. Third
Second
First

C. First
Second
Third

D. Second
First
Third

Solution

1. Step 1: Identify immediate and deferred prints

   "Third" is printed immediately. The two deferred prints run after main ends.

2. Step 2: Determine deferred call order

   Deferred calls run last-in, first-out, so "Second" prints before "First".

3. Final Answer:

   Third Second First -> Option B

4. Quick Check:

   Immediate then deferred reverse order = Third, Second, First [OK]

Hint: Immediate prints first; deferred prints run backward after [OK]

Common Mistakes:

• Assuming deferred prints run in code order
• Thinking deferred prints run before immediate prints
• Confusing the order of deferred calls

4. Consider this Go code snippet:

func example() {
    defer fmt.Println("A")
    defer fmt.Println("B")
    defer fmt.Println("C")
    fmt.Println("D")
}

If the output is not as expected, what is the likely mistake?

medium

A. The function does not call fmt.Println("D") before defers.

B. The deferred calls are not in reverse order.

C. The deferred calls are missing parentheses.

D. The deferred calls execute immediately, not at function end.

Solution

1. Step 1: Understand expected output order

   "D" should print first immediately, then deferred calls print "C", "B", "A" in reverse order.

2. Step 2: Identify cause of unexpected output

   If "D" is missing or not printed before defers, output order changes unexpectedly.

3. Final Answer:

   The function does not call fmt.Println("D") before defers. -> Option A

4. Quick Check:

   Immediate prints must run before deferred calls [OK]

Hint: Ensure immediate prints run before deferred calls [OK]

Common Mistakes:

• Expecting deferred calls to run in code order
• Forgetting to call immediate print before defers
• Misunderstanding when deferred calls execute

5. You want to open three files in a Go function and ensure all are closed properly using defer. Which code snippet correctly closes the files in the right order?

hard

A. file1.Close()
file2.Close()
file3.Close()

B. defer file3.Close()
defer file2.Close()
defer file1.Close()

C. defer Close(file1)
defer Close(file2)
defer Close(file3)

D. defer file1.Close()
defer file2.Close()
defer file3.Close()

Solution

1. Step 1: Understand defer closing order

   Deferred calls run last-in, first-out, so the last deferred closes first.

2. Step 2: Apply to file closing

   Deferring file1.Close() first, then file2.Close(), then file3.Close() means file3 closes first, then file2, then file1, matching open order reversed.

3. Final Answer:

   defer file1.Close() defer file2.Close() defer file3.Close() -> Option D

4. Quick Check:

   Defer in open order closes files in reverse [OK]

Hint: Defer closes in reverse order of defer statements [OK]

Common Mistakes:

• Deferring closes in reverse order of opening
• Calling Close() immediately without defer
• Using incorrect function calls for closing