Optionals

Handling missing values safely.

Optionals in Swift

Optionals are arguably the most important concept in Swift. An optional represents a value that might exist or might not exist (be nil). Instead of crashing your app when a value is missing, Swift forces you to handle the possibility of nil — making your code safer and more reliable.

var name: String? = "Alice"
print(name) // Optional("Alice")

var middleName: String? = nil
print(middleName) // nil

Try it Yourself ->

Unwrapping with if let

The safest way to unwrap an optional is with if let. This creates a new constant with the unwrapped value, but only runs the code block if the optional actually contains a value. If it's nil, the block is simply skipped.

var nickname: String? = "Nick"

if let unwrapped = nickname {
    print("Hello, \(unwrapped)!")
} else {
    print("Hello, stranger!")
}
// Hello, Nick!

nickname = nil

if let unwrapped = nickname {
    print("Hello, \(unwrapped)!")
} else {
    print("Hello, stranger!")
}
// Hello, stranger!

Try it Yourself ->

Unwrapping with guard let

guard let is similar to if let, but it's used when you want to exit early if the value is nil. It unwraps the optional and makes the value available for the rest of the function. It's especially useful at the beginning of functions.

func greetUser(name: String?) {
    guard let name = name else {
        print("Hello, stranger!")
        return
    }
    print("Hello, \(name)!")
}

greetUser(name: "Alice") // Hello, Alice!
greetUser(name: nil)     // Hello, stranger!

Try it Yourself ->

Force Unwrapping

You can force unwrap an optional with the ! operator. This tells Swift "I'm absolutely certain this value is not nil." Use it carefully — if you're wrong and the value IS nil, your app will crash immediately.

let possibleNumber = "123"
let converted = Int(possibleNumber) // Optional(123)

// Force unwapping — safe here because we know it's not nil
let number = converted!
print(number) // 123

// This would crash if uncommented:
// let bad: String? = nil
// print(bad!) // 💥 Fatal error

Try it Yourself ->

Optional Chaining

Optional chaining lets you safely access properties and methods on optional values. If any part of the chain is nil, the entire expression returns nil instead of crashing. It's like a safety net for nested optional values.

struct Address {
    var city: String
}

struct User {
    var address: Address?
}

let user = User(address: Address(city: "Paris"))
let city = user.address?.city
print(city) // Optional("Paris")

let noAddressUser = User(address: nil)
let noCity = noAddressUser.address?.city
print(noCity) // nil

Try it Yourself ->

Nil Coalescing

The nil coalescing operator (??) provides a default value when an optional is nil. It unwraps the optional if it has a value, or returns the default value if it's nil. It's a concise alternative to if let when you just need a fallback.

let username: String? = nil

// Nil coalescing — use the default if nil
let displayName = username ?? "Anonymous"
print(displayName) // Anonymous

let score: Int? = 95
let finalScore = score ?? 0
print(finalScore) // 95

Try it Yourself ->

🧪 Quick Quiz

What is an optional?

← Enumerations

Structs →