Optional declaration with ? suffix in Swift - Step-by-Step Execution

Concept Flow - Optional declaration with ? suffix

Declare variable with ?

↓

Variable can hold value or nil

↓

Use variable safely with checks

↓

Access value if not nil

↓

Handle nil case gracefully

This flow shows how a variable declared with ? can hold a value or nil, and how to safely use it by checking before access.

Execution Sample

Swift

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

This code declares an optional string, assigns a value, prints it, then sets it to nil and prints again.

Execution Table

Step	Action	Variable 'name' Value	Output
1	Declare 'name' as String? and assign "Alice"	Optional("Alice")
2	Print 'name'	Optional("Alice")	Optional("Alice")
3	Assign nil to 'name'	nil
4	Print 'name'	nil	nil

💡 Execution ends after printing nil value of optional variable.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
name	undefined	Optional("Alice")	nil	nil

Key Moments - 2 Insights

Why does printing 'name' show Optional("Alice") instead of just "Alice"?

Because 'name' is an optional, printing it shows the wrapped value with Optional(...) as seen in execution_table step 2.

What happens if we try to use 'name' without checking for nil?

Using 'name' without checking can cause runtime errors; optional must be safely unwrapped or checked as shown in the concept flow.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'name' after step 1?

A nil

B Optional("Alice")

C "Alice"

D undefined

💡 Hint

Check the 'Variable 'name' Value' column in row for step 1.

At which step does 'name' become nil?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Variable 'name' Value' column changes in the execution table.

If we print 'name' without assigning nil, what will the output be at step 4?

A Optional("Alice")

B "Alice"

C nil

D Error

💡 Hint

Refer to the output at step 2 in the execution table.

Concept Snapshot

Optional declaration with ? suffix:
- Syntax: var variableName: Type?
- Variable can hold a value or nil
- Printing shows Optional(value) if not nil
- Must check or unwrap before use
- Prevents runtime errors from nil values

Full Transcript

This visual execution shows how declaring a variable with a ? suffix in Swift makes it optional. The variable can hold a value or nil. Initially, 'name' is assigned "Alice" and printing it shows Optional("Alice") because it's wrapped. Then 'name' is set to nil and printing shows nil. This teaches that optionals must be handled carefully to avoid errors.

Practice

1. What does adding a ? after a type in Swift mean?

easy

A. The variable can hold a value or be nil (missing).

B. The variable is a constant and cannot change.

C. The variable must always have a value.

D. The variable is an array of that type.

Solution

1. Step 1: Understand the meaning of ? in Swift type declaration

   In Swift, adding ? after a type means the variable is optional and can hold either a value or nil.

2. Step 2: Compare with other options

   Other options describe constants, non-optional variables, or arrays, which are unrelated to the ? suffix.

3. Final Answer:

   The variable can hold a value or be nil (missing). -> Option A

4. Quick Check:

   Optional type = value or nil [OK]

Hint: Remember: ? means value can be missing [OK]

Common Mistakes:

• Thinking ? makes a constant
• Confusing optional with array type
• Assuming optional must always have a value

2. Which of these is the correct way to declare an optional integer in Swift?

easy

A. var number: Int?

B. var number: ?Int

C. var number: Int!

D. var number: OptionalInt

Solution

1. Step 1: Recall Swift syntax for optional declaration

   In Swift, an optional type is declared by placing ? after the type name, like Int?.

2. Step 2: Check each option

   var number: Int? uses Int? correctly. var number: ?Int places ? before the type, which is invalid. var number: Int! uses ! which is an implicitly unwrapped optional, different from ?. var number: OptionalInt uses a non-existent type OptionalInt.

3. Final Answer:

   var number: Int? -> Option A

4. Quick Check:

   Optional syntax = type followed by ? [OK]

Hint: Put ? right after the type name [OK]

Common Mistakes:

• Placing ? before the type
• Confusing ? with !
• Using non-existent types like OptionalInt

3. What will be the output of this Swift code?

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

medium

A. nil

B. Alice

C. Optional("Alice")

D. Error: Cannot print optional directly

Solution

1. Step 1: Understand printing an optional variable

   When printing an optional variable directly, Swift shows it wrapped as Optional(value) if it has a value.

2. Step 2: Check the variable value

   The variable name holds the string "Alice", so printing it shows Optional("Alice").

3. Final Answer:

   Optional("Alice") -> Option C

4. Quick Check:

   Printing optional shows Optional(value) [OK]

Hint: Printing optional shows Optional(...) wrapper [OK]

Common Mistakes:

• Expecting direct value without Optional()
• Assuming printing optional causes error
• Confusing nil with a string value

4. Identify the error in this Swift code:

var age: Int?
age = 25
print(age + 5)

medium

A. Variable age is not initialized.

B. Optional variables cannot be printed.

C. Missing semicolon after age = 25.

D. Cannot add Int? and Int directly.

Solution

1. Step 1: Analyze the operation on optional and Int

   The variable age is an optional Int (Int?), but adding it directly to an Int (5) is not allowed without unwrapping.

2. Step 2: Understand Swift's type safety

   Swift requires unwrapping optionals before using them in arithmetic operations to avoid runtime errors.

3. Final Answer:

   Cannot add Int? and Int directly. -> Option D

4. Quick Check:

   Optional must be unwrapped before arithmetic [OK]

Hint: Unwrap optionals before arithmetic operations [OK]

Common Mistakes:

• Trying to add optional and non-optional directly
• Ignoring need to unwrap optionals
• Thinking semicolons are required in Swift

5. Given this Swift code, how can you safely print the length of the optional string text?

var text: String? = "Hello"
// Your code here

hard

A. print(text ?? 0)

B. if let safeText = text { print(safeText.count) } else { print(0) }

C. print(text!)

D. print(text.count)

Solution

1. Step 1: Understand optional unwrapping with if let

   Using if let safely unwraps the optional text only if it has a value, avoiding crashes.

2. Step 2: Use unwrapped value to get length

   Inside the if let block, safeText.count gives the length. If text is nil, print 0.

3. Step 3: Check other options

   print(text.count) tries to access count on optional directly (error). print(text!) force unwraps without check (unsafe). print(text ?? 0) uses nil coalescing but mismatches types.

4. Final Answer:

   if let safeText = text { print(safeText.count) } else { print(0) } -> Option B

5. Quick Check:

   Use if let to safely unwrap optionals [OK]

Hint: Use if let to unwrap optionals safely [OK]

Common Mistakes:

• Forcing unwrap without checking nil
• Accessing properties on optional without unwrapping
• Using nil coalescing with wrong types