Implicitly unwrapped optionals in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of accessing an implicitly unwrapped optional

What is the output of this Swift code?

Swift

var name: String! = "Alice"
print(name.count)

A Runtime error

B Optional(5)

C nil

D 5

💡 Hint

Implicitly unwrapped optionals can be used like normal values without unwrapping.

The variable 'name' is an implicitly unwrapped optional containing "Alice". Accessing 'name.count' works like a normal String, so it prints 5.

❓ Predict Output

intermediate

Behavior when implicitly unwrapped optional is nil

What happens when you run this Swift code?

Swift

var number: Int! = nil
print(number + 1)

A 1

B Runtime error: unexpectedly found nil while unwrapping an Optional value

C Optional(1)

D 0

💡 Hint

Implicitly unwrapped optionals behave like normal values but crash if nil.

Since 'number' is nil, trying to use it as a normal Int causes a runtime crash due to forced unwrapping of nil.

🔧 Debug

advanced

Identify the cause of runtime crash with implicitly unwrapped optional

Why does this Swift code crash at runtime?

Swift

class Person {
    var pet: String!
    func printPet() {
        print(pet.uppercased())
    }
}

let p = Person()
p.printPet()

A The 'pet' property is nil and is force-unwrapped causing a crash

B The 'uppercased()' method is not available on String

C The 'printPet' method is not called correctly

D The 'Person' class must initialize 'pet' in the initializer

💡 Hint

Implicitly unwrapped optionals crash if nil when accessed.

The 'pet' property is implicitly unwrapped optional but is never assigned a value, so it is nil. Accessing 'pet.uppercased()' forces unwrapping nil, causing a runtime crash.

🧠 Conceptual

advanced

Understanding implicitly unwrapped optional declaration

Which statement about implicitly unwrapped optionals in Swift is true?

A They must always be initialized with a non-nil value and never change to nil.

B They behave like normal optionals and require explicit unwrapping every time.

C They can be used as normal values but cause a runtime error if nil when accessed.

D They automatically convert to non-optional types without any risk.

💡 Hint

Think about how implicitly unwrapped optionals behave differently from normal optionals.

Implicitly unwrapped optionals can be used like normal values without explicit unwrapping, but if they are nil when accessed, the program crashes at runtime.

❓ Predict Output

expert

Output of chained implicitly unwrapped optionals

What is the output of this Swift code?

Swift

class Node {
    var value: Int
    var next: Node!
    init(_ value: Int) {
        self.value = value
    }
}

let first = Node(1)
let second = Node(2)
first.next = second
second.next = nil

print(first.next.next.value)

A Runtime error: unexpectedly found nil while unwrapping an Optional value

B 2

C 1

D Optional(2)

💡 Hint

Consider what happens when accessing 'next' of a nil implicitly unwrapped optional.

The 'second.next' is nil. Accessing 'first.next.next.value' tries to access 'next' of nil, causing a runtime crash due to forced unwrapping of nil.