Answer.

History of the question:

Optional chaining emerged in Swift for convenient work with nested optionals, allowing for writing compact and safe code without endless nil checks. This is especially useful when accessing properties and methods of objects that may not exist.

Problem:

When working with optional chaining, it is easy to misinterpret what the result will be if one of the objects in the chain is nil, or if the return value is handled incorrectly, you may encounter runtime errors or unexpected behavior.

Solution:

Optional chaining is a mechanism that allows safe access to nested properties, methods, and subscripts of objects that can be nil. If any element in the chain is nil, the entire construction returns nil, without causing an error.

Code example:

class Address {
    var city: String?
}

class User {
    var address: Address?
}

let user: User? = User()
user?.address?.city = "Moscow"

if let city = user?.address?.city {
    print(city)
} else {
    print("City not found")
}

Key features:

• Allows chaining access to properties and methods, even if a value in the middle of the chain is nil.
• The return value will always be optional, regardless of the type of the target property.
• Can be used to call methods, subscripts, and even assignments, but care must be taken with unhandled nil values.

Tricky questions.

Does a runtime error occur when trying to call a method or access a property through optional chaining if the object is nil?

No, a runtime error does not occur. The whole expression through optional chaining returns nil, and execution stops without an error.

Code example:

let email: String? = nil
let lowercased = email?.lowercased() // lowercased will be nil, no error will occur

Will an assignment via optional chaining occur if the intermediate object is missing?

No, if the object or the intermediate property is nil, the assignment will not occur and will not change memory.

Code example:

var user: User? = nil
user?.address?.city = "Kazan" // nothing will happen, user is nil

Can the result of optional chaining be non-optional?

No, the result of any expression through optional chaining is always optional, even if the original property is not optional.

Code example:

class Test { var number: Int = 10 }
let t: Test? = nil
let value = t?.number // value: Int? (optional)

Typical errors and anti-patterns

• Ignoring the optional result and treating it as non-optional, leading to compiler errors or logical violations.
• Incorrect attempts to force unwrap after optional chaining.
• The chain is too long and convoluted, making it hard to read and debug.

Real-life example

Negative case

In the code, access user?.address?.city without checking for the city's existence and immediately output city!. This leads to a crash if any link is nil.

Pros:

• Conciseness of code.

Cons:

• High chance of crash at runtime.
• Poor readability.

Positive case

In the code, use if let or guard let to check user?.address?.city and only then work with the value.

Pros:

• Guarantees safety.
• More understandable logic.

Cons:

• More code (but reliable).