Conquering Optionals in Swift — A Deep Dive

In Swift optionals are a fundamental concept to deal with the possible absence of value for any type. They are used to represent a variable or a constant that might not have a value. They are pretty much ubiquitous in any iOS application that relies on user input, network requests or decoding of data.

Optionals force engineers to thing about the presence or absence of data leading to better error handling, clear intention when writing code and more robust code. We should not make the mistake of thinking about optionals as an invalid state. For example, a user profile without a profile picture is a perfectly valid state and that property that holds the image data should be represented as an optional.

Optionals help prevent runtime errors due to null point exceptions that can come up when the software tries to access a null value.

Optionals are only a single bit larger than their wrapped value type and are optimised by the compiler and in runtime.

Syntax

In the Swift Programming Language an optional type is declared by adding a ? to the end of any type. To set an optional variable to no value we use the keyword nil and values can be assigned to an optional just like any regular variable.

var name: String? = nil
name = "Tim Cook"

Unwrapping Optionals

To access an optional value safely we must perform the unwrapping of the optional, since it may not have a value. We can use ! to force unwrap the optional but that is risky since the value might be absent and the app crashes.

var uppercased = name!.uppercased()
// !! This is not safe!

A safer way to do it is to use an if let or a guard let statement.

if let name {
    print("Unwrapped name: \(name)")
}

The guard let statement offers several advantages, as it improves readability, helps avoid nesting code and can be more concise specially when combined with where clauses.

guard let name where name.contains("Cook") else {
    return
}

print("Unwrapped name: \(name)")

On the other hand, we can use nil coalescing to provide a default value if the optional variable or constant is nil .

let unwrappedString = name ?? "Default name"

We can also use optional chaining to call different methods on optionals that we don’t know if they will have a value. The method will only execute if the optional has a value.

let uppercasedName = name?.uppercased()

Transforming optionals with map, flatMap and compactMap

We can use map when our goal is to obtain a straightforward transformation of one optional value. It is useful to avoid manual unwrapping and it keeps the code more readable and concise.

For example, we can transform a String value to an Integer using the map operation.

let answer: String? = "42"
let integerNumber = answer.map { Int($0) }

On the other hand, flatMap should be used when we want to avoid and prevent nested optionals, as this high-order function “flattens” the result.

let user: [String: Any?] = ["name": "Alice", "age": 25, "city": nil]
let city = user["city"].flatMap { $0 as? String }

In the example above, user[city] is an optional value and using flatMap we can cast it to String? avoiding nested optionals.

Finally, we can also use compactMap . This function essentially works as a flatMap combined with a filter that removes nil values.

let arrayOfOptionals: [Int?] = [1, nil, 3, nil, 5]
let unwrappedNumbers = numbers.compactMap { $0 }

// Returns [1, 3, 5]

Swift optionals help us write more expressive, safe and efficient code that avoids common mistakes, unexpected crashes and unclear logic.