Defer statement for cleanup in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using defer?

Consider the following Swift code snippet. What will be printed when it runs?

Swift

func testDefer() {
    print("Start")
    defer {
        print("Deferred 1")
    }
    defer {
        print("Deferred 2")
    }
    print("End")
}
testDefer()

A

Start
End
Deferred 2
Deferred 1

B

Start
End
Deferred 1
Deferred 2

C

Deferred 1
Deferred 2
Start
End

D

Start
Deferred 1
Deferred 2
End

💡 Hint

Remember that defer statements run in reverse order when the function exits.

Defer blocks execute in last-in, first-out order when the function returns. So the second defer runs before the first.

❓ Predict Output

intermediate

What happens if defer modifies a variable?

What is the value of count after running this Swift code?

Swift

func countTest() -> Int {
    var count = 0
    defer {
        count += 1
    }
    count += 2
    return count
}
let result = countTest()
print(result)

A 0

B 1

C 2

D 3

💡 Hint

Defer runs after the return value is set but before the function fully exits.

The return value is set to 2 before defer runs. The defer increments count to 3, but this does not affect the returned value.

🔧 Debug

advanced

Why does this defer block not execute?

Examine the code below. Why does the defer block not print anything?

Swift

func earlyExit() {
    defer {
        print("Cleanup")
    }
    return
    print("This will not print")
}
earlyExit()

A The defer block is skipped because return is before it.

B The defer block runs before return and prints "Cleanup".

C The defer block runs but print output is buffered and not shown.

D The defer block is ignored because it is after the return statement.

💡 Hint

Defer always runs when exiting the current scope, even if return is called.

Defer blocks run when the function exits, even if return is called early. So "Cleanup" is printed.

❓ Predict Output

advanced

What is the output when defer modifies a reference type?

What will be printed by this Swift code?

Swift

class Counter {
    var value = 0
}

func modifyCounter() {
    let counter = Counter()
    defer {
        counter.value += 10
        print("Deferred value: \(counter.value)")
    }
    counter.value += 5
    print("Current value: \(counter.value)")
}
modifyCounter()

A

Current value: 15
Deferred value: 15

B

Current value: 5
Deferred value: 5

C

Deferred value: 15
Current value: 5

D

Current value: 5
Deferred value: 15

💡 Hint

Defer runs after the print of current value, so it sees the updated value.

The counter's value is 5 when printed first. Then defer adds 10 and prints 15.

🧠 Conceptual

expert

How many times is the defer block executed in this loop?

Consider this Swift code. How many times will the defer block run?

Swift

func loopDefer() {
    for i in 1...3 {
        defer {
            print("Deferred in iteration \(i)")
        }
        print("Loop iteration \(i)")
    }
}
loopDefer()

A 3 times, once after each loop iteration

B 6 times, twice per iteration

C 0 times, defer inside loop is ignored

D 1 time, after the entire loop finishes

💡 Hint

Defer runs when the current scope exits. What is the scope of the defer inside the loop?

The defer is inside the loop's scope, so it runs once per iteration when that iteration's scope ends.