Property observers (willSet, didSet) in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using willSet?

Consider this Swift code with a property observer willSet. What will be printed when score is set to 10?

Swift

class Game {
    var score: Int = 0 {
        willSet {
            print("Score will change from \(score) to \(newValue)")
        }
    }
}

let game = Game()
game.score = 10

A Score will change from 10 to 0

B Score will change from 0 to 10

C Score will change from 0 to 0

D No output

💡 Hint

Remember that willSet runs before the property value changes, and newValue holds the new value.

The willSet observer runs just before the property changes. The old value is still accessible via the property itself (score), and the new value is available as newValue. So it prints the old value 0 and the new value 10.

❓ Predict Output

intermediate

What is printed by this Swift code using didSet?

Look at this Swift code with a didSet observer. What will be printed after setting temperature to 30?

Swift

struct Weather {
    var temperature: Int = 20 {
        didSet {
            print("Temperature changed from \(oldValue) to \(temperature)")
        }
    }
}

var today = Weather()
today.temperature = 30

A Temperature changed from 20 to 30

B Temperature changed from 30 to 20

C Temperature changed from 20 to 20

D No output

💡 Hint

didSet runs after the property value changes, and oldValue holds the previous value.

The didSet observer runs after the property changes. The oldValue is 20, and the new value is 30, so it prints the change correctly.

🔧 Debug

advanced

Why does this Swift code cause a runtime error?

This Swift code uses didSet to update the property. Why does it crash when setting value to 5?

Swift

class Counter {
    var value: Int = 0 {
        didSet {
            value = 10
        }
    }
}

let counter = Counter()
counter.value = 5

A It causes infinite recursion because didSet sets value again inside didSet.

B It causes a syntax error because didSet cannot modify the property.

C It causes a compile-time error because value is a constant.

D It runs fine and sets value to 5 without error.

💡 Hint

Think about what happens when you assign to the property inside didSet.

Assigning to the property inside didSet triggers didSet again, causing infinite recursion and a runtime crash.

🧠 Conceptual

advanced

Which statement about willSet and didSet is true?

Choose the correct statement about Swift's property observers willSet and didSet:

A willSet runs after the property value changes, and didSet runs before the change.

B willSet provides the old value as newValue, and didSet provides the new value as oldValue.

C Both willSet and didSet run only when the property is initialized.

D willSet runs before the property value changes, and didSet runs after the change.

💡 Hint

Think about the timing of these observers relative to the property change.

willSet runs just before the property changes, giving access to the new value as newValue. didSet runs just after the property changes, giving access to the old value as oldValue.

❓ Predict Output

expert

What is the final output of this Swift code with nested property observers?

Analyze this Swift code with two properties having observers. What will be printed after setting outer.value to 3?

Swift

class Inner {
    var value: Int = 0 {
        willSet {
            print("Inner willSet: \(value) -> \(newValue)")
        }
        didSet {
            print("Inner didSet: \(oldValue) -> \(value)")
        }
    }
}

class Outer {
    var value: Int = 0 {
        willSet {
            print("Outer willSet: \(value) -> \(newValue)")
        }
        didSet {
            print("Outer didSet: \(oldValue) -> \(value)")
            inner.value = value * 2
        }
    }
    var inner = Inner()
}

let outer = Outer()
outer.value = 3

A

Inner willSet: 0 -> 6
Inner didSet: 0 -> 6
Outer willSet: 0 -> 3
Outer didSet: 0 -> 3

B

Outer willSet: 0 -> 3
Inner willSet: 0 -> 6
Outer didSet: 0 -> 3
Inner didSet: 0 -> 6

C

Outer willSet: 0 -> 3
Outer didSet: 0 -> 3
Inner willSet: 0 -> 6
Inner didSet: 0 -> 6

D

Outer didSet: 0 -> 3
Outer willSet: 0 -> 3
Inner didSet: 0 -> 6
Inner willSet: 0 -> 6

💡 Hint

Remember the order: willSet runs before the property changes, didSet after. Also, didSet of outer triggers inner.value change.

First, outer.value's willSet runs printing the old and new values. Then outer.value changes, triggering outer.didSet, which prints old and new values and sets inner.value to 6. Setting inner.value triggers inner's willSet and didSet in order.