Why defer is used in Go - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to ensure the file is closed after opening it.

Go

file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
[1] file.Close()

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

Afunc

Bgo

Cdefer

Dreturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'go' instead of 'defer' causes the file to close immediately or not at the right time.

The defer keyword schedules the file.Close() call to run after the surrounding function finishes, ensuring the file is closed properly.

2fill in blank

medium

Complete the code to print 'Done' after the function finishes.

Go

func process() {
    [1] fmt.Println("Done")
    fmt.Println("Processing...")
}

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

Afunc

Bgo

Creturn

Ddefer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'go' runs the print concurrently, not after the function ends.

Using defer before fmt.Println("Done") delays printing 'Done' until process finishes.

3fill in blank

hard

Fix the error by completing the code to close the database connection after use.

Go

func queryDB() {
    db, err := sql.Open("driver", "source")
    if err != nil {
        log.Fatal(err)
    }
    [1] db.Close()
    // perform queries
}

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

Adefer

Bgo

Creturn

Dfunc

Attempts:

3 left

💡 Hint

Common Mistakes

Not using defer causes the connection to remain open longer than needed.

defer ensures db.Close() runs after queryDB finishes, properly closing the connection.

4fill in blank

hard

Fill both blanks to defer closing the file and unlocking the mutex.

Go

func safeWrite() {
    mu.Lock()
    [1] mu.Unlock()
    file, err := os.Create("data.txt")
    if err != nil {
        log.Fatal(err)
    }
    [2] file.Close()
    // write data
}

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

Adefer

Bgo

Creturn

Dfunc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'go' instead of 'defer' causes unlocking or closing to happen too early or concurrently.

Using defer before mu.Unlock() and file.Close() ensures both run after safeWrite finishes, keeping code safe and clean.

5fill in blank

hard

Fill all three blanks to defer closing the file, unlocking the mutex, and printing 'Finished'.

Go

func processFile() {
    mu.Lock()
    [1] mu.Unlock()
    file, err := os.Open("file.txt")
    if err != nil {
        log.Fatal(err)
    }
    [2] file.Close()
    [3] fmt.Println("Finished")
    // process file
}

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

Ago

Bdefer

Creturn

Dfunc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'go' runs the functions concurrently and immediately, not after the function ends.

All three calls are deferred to run after processFile ends, ensuring proper cleanup and final message.

Practice

1. What is the main purpose of using defer in Go?

easy

A. To create a new goroutine

B. To run a function immediately

C. To delay a function call until the surrounding function finishes

D. To declare a variable

Solution

1. Step 1: Understand the behavior of defer

   The defer keyword postpones the execution of a function until the surrounding function returns.

2. Step 2: Compare options with this behavior

   Only To delay a function call until the surrounding function finishes correctly describes this delaying behavior, while others describe unrelated actions.

3. Final Answer:

   To delay a function call until the surrounding function finishes -> Option C

4. Quick Check:

   Defer delays function calls = A [OK]

Hint: Defer means 'do later' when function ends [OK]

Common Mistakes:

• Thinking defer runs function immediately
• Confusing defer with goroutine creation
• Assuming defer declares variables

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

easy

A. defer cleanup()

B. defer = cleanup()

C. defer: cleanup()

D. defer -> cleanup()

Solution

1. Step 1: Recall Go's defer syntax

   The correct syntax is the keyword defer followed by the function call without any assignment or punctuation.

2. Step 2: Check each option

   Only defer cleanup() matches the correct syntax. Others use invalid symbols or assignment.

3. Final Answer:

   defer cleanup() -> Option A

4. Quick Check:

   Defer syntax is 'defer function()' = A [OK]

Hint: Defer always followed by function call without extra symbols [OK]

Common Mistakes:

• Adding '=' after defer
• Using ':' or '->' instead of space
• Omitting parentheses on function call

3. What will be 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\nSecond\nFirst

B. Second\nFirst\nThird

C. First\nSecond\nThird

D. Third\nFirst\nSecond

Solution

1. Step 1: Identify the order of deferred calls

   Deferred calls run after the surrounding function ends, in reverse order of their defer statements. So "Second" runs before "First".

2. Step 2: Trace the print statements

   "Third" prints immediately, then deferred prints run: "Second", then "First".

3. Final Answer:

   Third\nSecond\nFirst -> Option A

4. Quick Check:

   Deferred calls run last in reverse order = C [OK]

Hint: Deferred calls run last, in reverse order [OK]

Common Mistakes:

• Assuming deferred calls run in order declared
• Thinking deferred calls run immediately
• Mixing up print order

4. Identify the error in this Go code snippet:

func process() {
    defer close(file)
    file, err := os.Open("data.txt")
    if err != nil {
        return
    }
    // process file
}

medium

A. File is closed twice due to defer and explicit close

B. Defer is used before file is assigned, causing a compile error

C. Defer cannot be used with file operations

D. No error, code works fine

Solution

1. Step 1: Analyze the order of statements

   The defer statement tries to close file before file is assigned by os.Open. This causes a compile error because file is undefined at defer time.

2. Step 2: Understand defer evaluation timing

   Arguments to deferred functions are evaluated immediately, so file must be assigned before defer.

3. Final Answer:

   Defer is used before file is assigned, causing a compile error -> Option B

4. Quick Check:

   Defer arguments evaluated immediately = B [OK]

Hint: Defer arguments evaluated immediately, assign variables first [OK]

Common Mistakes:

• Placing defer before variable assignment
• Thinking defer delays argument evaluation
• Assuming defer can't be used with files

5. You want to open multiple files and ensure all are closed properly even if an error occurs. Which approach using defer is best?

func openFiles() {
    f1, _ := os.Open("file1.txt")
    f2, _ := os.Open("file2.txt")
    // What is the best way to defer closing these files?
}

hard

A. Use defer only for the last file opened

B. Defer closing both files together at the end of the function

C. Close files manually without defer

D. Defer closing each file immediately after opening it

Solution

1. Step 1: Understand resource management with defer

   Deferring the close immediately after opening each file ensures each file is closed properly even if the function returns early.

2. Step 2: Compare options

   Defer closing each file immediately after opening it defers closing right after opening, which is safe. Defer closing both files together at the end of the function delays both closes until the end, risking leaks if errors occur. Close files manually without defer is error-prone. Use defer only for the last file opened misses closing one file.

3. Final Answer:

   Defer closing each file immediately after opening it -> Option D

4. Quick Check:

   Defer resource cleanup immediately after acquisition = D [OK]

Hint: Defer cleanup right after resource acquisition [OK]

Common Mistakes:

• Deferring all closes at once at the end
• Not deferring close for every opened file
• Closing files manually without defer