Optional chaining with ?. in Swift - Step-by-Step Execution

Concept Flow - Optional chaining with ?.

Start with Optional Variable

↓

Use Optional Chaining ? to access property/method

↓

Is Optional nil?

Yes→Return nil, stop

No↓

Access property/method safely

↓

Return Optional result

Optional chaining tries to access a property or method on an optional value. If the optional is nil, it stops and returns nil safely.

Execution Sample

Swift

class Person {
  var pet: Pet?
}
class Pet {
  var name: String
  init(name: String) { self.name = name }
}

let person = Person()
let petName = person.pet?.name

This code tries to get the pet's name from a person who may or may not have a pet, using optional chaining.

Execution Table

Step	Expression	Optional Value	Action	Result
1	person.pet	nil	Check if pet exists	nil (pet is nil)
2	person.pet?.name	nil	Optional chaining stops, returns nil	nil

💡 person.pet is nil, so optional chaining returns nil without error

Variable Tracker

Variable	Start	After 1	Final
person.pet	nil	nil	nil
petName	undefined	nil	nil

Key Moments - 2 Insights

Why does person.pet?.name return nil instead of causing an error?

Because person.pet is nil, optional chaining safely stops and returns nil instead of trying to access name on a nil value (see execution_table step 2).

What happens if person.pet is not nil?

Optional chaining accesses the pet's name normally and returns it wrapped as an optional (not shown in this trace but would be a non-nil value).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of person.pet at step 1?

A nil

B A Pet object

C An error

D Undefined

💡 Hint

Check the 'Optional Value' column in execution_table row 1

At which step does optional chaining stop because the optional is nil?

A Step 1

B Step 2

C It never stops

D After step 2

💡 Hint

Look at the 'Action' column in execution_table row 2

If person.pet was not nil, what would person.pet?.name return?

A nil

B An error

C The pet's name wrapped in an optional

D Undefined

💡 Hint

Recall that optional chaining returns nil only if the optional is nil, otherwise it returns the accessed value as optional

Concept Snapshot

Optional chaining with ? allows safe access to properties or methods on optionals.
If the optional is nil, the whole expression returns nil without error.
Syntax: optionalValue?.property or optionalValue?.method()
Useful to avoid crashes when optionals might be nil.
Returns an optional result.

Full Transcript

This visual trace shows how optional chaining works in Swift. We start with an optional property person.pet which is nil. When we try to access person.pet?.name, optional chaining checks if pet is nil. Since it is nil, it stops and returns nil safely without causing an error. This prevents crashes from trying to access properties on nil. If pet was not nil, optional chaining would access the name property and return it wrapped as an optional. The variable tracker shows person.pet remains nil and petName becomes nil after the optional chaining expression. Key moments clarify why optional chaining stops safely and what happens if the optional is not nil. The quiz tests understanding of these steps and results.

Practice

1. What does the ?. operator do in Swift when used with optionals?

easy

A. It forces unwraps the optional and crashes if nil.

B. It converts the optional to a non-optional value automatically.

C. It safely accesses a property or method and returns nil if the optional is nil.

D. It assigns a default value if the optional is nil.

Solution

1. Step 1: Understand optional chaining purpose

   The ?. operator is used to safely access properties or methods on an optional value.

2. Step 2: Behavior when optional is nil

   If the optional is nil, the chaining stops and returns nil instead of crashing.

3. Final Answer:

   It safely accesses a property or method and returns nil if the optional is nil. -> Option C

4. Quick Check:

   Optional chaining = safe access with nil return [OK]

Hint: Remember: ? stops if nil, no crash happens [OK]

Common Mistakes:

• Confusing optional chaining with forced unwrapping
• Thinking it unwraps optionals automatically
• Assuming it provides default values

2. Which of the following is the correct syntax to safely access the name property of an optional person object using optional chaining?

easy

A. person->name

B. person!.name

C. person.name?

D. person?.name

Solution

1. Step 1: Identify correct optional chaining syntax

   Optional chaining uses ?. between the optional variable and the property.

2. Step 2: Check each option

   person?.name uses person?.name, which is correct syntax. person!.name forces unwraps with !. person.name? places ? incorrectly. person->name uses invalid operator.

3. Final Answer:

   person?.name -> Option D

4. Quick Check:

   Optional chaining syntax = variable?.property [OK]

Hint: Use ?. right before the property to chain safely [OK]

Common Mistakes:

• Using ! instead of ? for optional chaining
• Placing ? after the property name
• Using invalid operators like ->

3. Consider the following Swift code:

class Person {
  var pet: Pet?
}
class Pet {
  var name: String
  init(name: String) { self.name = name }
}

let person = Person()
let petName = person.pet?.name
print(petName)

What will be printed?

medium

A. Optional(nil)

B. nil

C. An empty string

D. Runtime error

Solution

1. Step 1: Analyze the optional chaining result

   Since person.pet is nil (not assigned), person.pet?.name returns nil of type String?.

2. Step 2: Understand print output of optional nil

   Printing an optional value that is nil in Swift shows Optional(nil) because the variable itself is an optional.

3. Final Answer:

   Optional(nil) -> Option A

4. Quick Check:

   print(String? nil) = Optional(nil) [OK]

Hint: Printing optional nil shows 'Optional(nil)', not 'nil' [OK]

Common Mistakes:

• Thinking print shows nil
• Expecting empty string output
• Thinking it causes runtime error

4. The following Swift code causes a compile error. What is the mistake?

struct Car {
  var owner: Person?
}

let car = Car()
let ownerName = car.owner?.name!

medium

A. Using forced unwrap (!) after optional chaining without parentheses

B. Missing initialization of car variable

C. Incorrect use of optional chaining operator

D. Person type does not have a name property

Solution

1. Step 1: Identify forced unwrap misuse

   The code uses car.owner?.name! which tries to force unwrap the property without parentheses.

2. Step 2: Correct syntax for forced unwrap after optional chaining

   Forced unwrap must be applied to the entire optional chaining expression with parentheses like (car.owner?.name)!.

3. Final Answer:

   Using forced unwrap (!) after optional chaining without parentheses -> Option A

4. Quick Check:

   Force unwrap after optional chaining needs parentheses [OK]

Hint: Wrap optional chain in () before ! to force unwrap [OK]

Common Mistakes:

• Forgetting parentheses around optional chain before !
• Assuming optional chaining can be forced unwrapped directly
• Ignoring compiler error details

5. Given the following classes:

class Address {
  var city: String?
}
class User {
  var address: Address?
}

let user = User()

Which code safely prints the city name if it exists, or "Unknown" if city or address is nil?

hard

A. print(user.address.city ?? "Unknown")

B. print(user.address?.city ?? "Unknown")

C. print(user.address!.city!)

D. print(user.address?.city!)

Solution

1. Step 1: Understand optional chaining with nil coalescing

   Using user.address?.city safely accesses city, returning nil if address or city is nil.

2. Step 2: Use nil coalescing operator to provide default

   The ?? "Unknown" provides "Unknown" if the optional is nil, avoiding crashes.

3. Final Answer:

   print(user.address?.city ?? "Unknown") -> Option B

4. Quick Check:

   Optional chaining + ?? = safe access with default [OK]

Hint: Combine ?. with ?? to provide default value safely [OK]

Common Mistakes:

• Forcing unwraps causing runtime crashes
• Not handling nil for nested optionals
• Using optional chaining without default fallback