What the meaning of question mark '?' in swift?

swift

programming

question-mark

syntax

optional-binding

What the meaning of question mark '?' in swift?

Master System Design with Codemia

Enhance your system design skills with over 120 practice problems, detailed solutions, and hands-on exercises.

Start Practicing Learn More

Introduction

The question mark ? in Swift serves multiple purposes, all related to handling values that might be absent. It declares optional types (Int?), enables optional chaining (object?.property), provides nil-coalescing defaults (value ?? fallback), performs conditional casting (as?), and marks failable initializers (init?). Understanding these uses is fundamental to Swift because optionals are the language's primary mechanism for null safety — they replace null pointer exceptions with compile-time checks.

Declaring Optionals

swift

1var name: String? = "Alice"   // Can hold a String or nil
2var age: Int? = nil            // Currently holds no value
3
4// Non-optional — MUST always have a value
5var greeting: String = "Hello" // Cannot be nil
6// greeting = nil  // Compile error!

An optional is a wrapper that either contains a value or contains nil. String? is syntactic sugar for Optional<String>.

Unwrapping Optionals

Optional Binding with if let

swift

1var name: String? = "Alice"
2
3if let unwrapped = name {
4    print("Name is \(unwrapped)")  // "Name is Alice"
5} else {
6    print("Name is nil")
7}
8
9// Shorthand (Swift 5.7+) — reuses the same variable name
10if let name {
11    print("Name is \(name)")
12}

Guard let (Early Exit)

swift

1func greet(name: String?) {
2    guard let name = name else {
3        print("No name provided")
4        return
5    }
6    // name is non-optional from here
7    print("Hello, \(name)")
8}

Force Unwrapping with !

swift

1var name: String? = "Alice"
2print(name!)  // "Alice" — crashes if name is nil!
3
4var empty: String? = nil
5// print(empty!)  // Runtime crash: "Unexpectedly found nil while unwrapping"

Force unwrapping is unsafe and should be used only when you are certain the value is not nil.

Optional Chaining

The ? enables safe access to properties, methods, and subscripts on optional values:

swift

1class Address {
2    var city: String = "New York"
3}
4
5class Person {
6    var address: Address?
7}
8
9let person = Person()
10person.address = Address()
11
12// Optional chaining — returns String? (optional)
13let city = person.address?.city
14print(city)  // Optional("New York")
15
16// Without optional chaining — would need explicit unwrapping
17// let city = person.address!.city  // Crashes if address is nil
18
19// Chaining multiple levels
20class Company {
21    var ceo: Person?
22}
23
24let company = Company()
25let ceoCity = company.ceo?.address?.city  // nil (ceo is nil)

If any link in the chain is nil, the entire expression evaluates to nil without crashing.

Nil-Coalescing Operator (??)

swift

1let name: String? = nil
2let displayName = name ?? "Anonymous"
3print(displayName)  // "Anonymous"
4
5let age: Int? = 25
6let displayAge = age ?? 0
7print(displayAge)  // 25 (age is not nil, so ?? is not used)
8
9// Chaining multiple fallbacks
10let primary: String? = nil
11let secondary: String? = nil
12let fallback = primary ?? secondary ?? "Default"
13print(fallback)  // "Default"

?? returns the left side if it is not nil, otherwise returns the right side.

Conditional Casting (as?)

swift

1class Animal {}
2class Dog: Animal {
3    func bark() { print("Woof!") }
4}
5class Cat: Animal {
6    func meow() { print("Meow!") }
7}
8
9let animal: Animal = Dog()
10
11// as? returns an optional — nil if the cast fails
12if let dog = animal as? Dog {
13    dog.bark()  // "Woof!"
14}
15
16if let cat = animal as? Cat {
17    cat.meow()  // Not executed — cast fails, returns nil
18}

as? is the safe cast operator. Use as! for force casting (crashes if the cast fails).

Failable Initializers (init?)

swift

1struct Temperature {
2    let celsius: Double
3
4    init?(celsius: Double) {
5        // Absolute zero is -273.15°C — reject lower values
6        guard celsius >= -273.15 else { return nil }
7        self.celsius = celsius
8    }
9}
10
11let valid = Temperature(celsius: 100)    // Optional(Temperature)
12let invalid = Temperature(celsius: -300) // nil
13
14if let temp = Temperature(celsius: 20) {
15    print("Temperature: \(temp.celsius)°C")
16}

Standard library examples include Int("hello") which returns Int? — nil if the string is not a valid integer.

Implicitly Unwrapped Optionals (!)

swift

1// Declared with ! instead of ?
2var label: UILabel!  // Implicitly unwrapped optional
3
4// Used in Interface Builder outlets
5@IBOutlet weak var titleLabel: UILabel!
6
7// Access without explicit unwrapping
8// titleLabel.text = "Hello"  // Works if not nil, crashes if nil

Implicitly unwrapped optionals are used when a value is nil initially but is guaranteed to have a value before first use (like @IBOutlet connections set during view loading).

Optional Map and FlatMap

swift

1let number: Int? = 5
2
3// map — transforms the value if it exists
4let doubled = number.map { $0 * 2 }
5print(doubled)  // Optional(10)
6
7let nilNumber: Int? = nil
8let result = nilNumber.map { $0 * 2 }
9print(result)  // nil
10
11// flatMap — unwraps one level of optional nesting
12let str: String? = "42"
13let parsed = str.flatMap { Int($0) }  // Int? (not Int??)
14print(parsed)  // Optional(42)

Common Pitfalls

Force unwrapping (!) without checking for nil: This is the most common cause of Swift runtime crashes. Always use if let, guard let, or ?? instead of ! unless you have absolute certainty the value exists.
Confusing ? (optional) with ! (implicitly unwrapped): String? requires explicit unwrapping. String! auto-unwraps but still crashes on nil. Use ! declarations only for outlets and cases where the value is guaranteed after initialization.
Optional chaining returning an optional: person.address?.city returns String?, not String. If you need a non-optional, combine with ?? or if let.
Comparing optionals to nil instead of using if let: if name != nil { print(name!) } forces an unwrap. if let name = name { print(name) } is safer and more idiomatic.
Nested optionals (Int??): Chaining operations on optionals can produce double-wrapped optionals. Use flatMap instead of map to avoid Optional(Optional(value)).

Summary

Type? declares an optional that can hold a value or nil
if let and guard let safely unwrap optionals without risk of crashes
?. (optional chaining) safely accesses properties on optional values, returning nil if any link is nil
?? (nil-coalescing) provides a default value when an optional is nil
as? performs safe type casting that returns nil on failure
Avoid force unwrapping (!) except when you are certain the value is not nil