Guard let for early exit in Swift - Mini Project: Build & Apply

Guard let for early exit

📖 Scenario: Imagine you are writing a simple Swift program that processes user input for an app. The app needs to check if the user has entered a valid email address before continuing.

🎯 Goal: You will build a Swift program that uses guard let to safely unwrap an optional email string and exit early if the email is missing or empty.

📋 What You'll Learn

Create an optional string variable called email with the value "[e-mail]".

Create a constant called minimumLength and set it to 5.

Use a guard let statement to unwrap email and check that its length is at least minimumLength.

If the guard let condition fails, print "Invalid email" and exit the function early.

If the email is valid, print "Email is valid: <email>".

💡 Why This Matters

🌍 Real World

Checking user input safely is very common in apps to avoid crashes and handle errors gracefully.

💼 Career

Understanding optionals and early exit with <code>guard let</code> is essential for Swift developers working on iOS apps.

1

Create the optional email variable

Create an optional string variable called email and set it to "[e-mail]".

Swift

# Create an optional string variable called email and set it to "[e-mail]"
# Your code here

Hint

Use var email: String? = "[e-mail]" to create an optional string variable.

2

Create the minimum length constant

Create a constant called minimumLength and set it to 5.

Swift

var email: String? = "[e-mail]"
# Create a constant called minimumLength and set it to 5
# Your code here

Hint

Use let minimumLength = 5 to create a constant.

3

Use guard let to unwrap and check email

Write a function called checkEmail(). Inside it, use guard let to unwrap email into a constant called unwrappedEmail. Also check that unwrappedEmail.count is at least minimumLength. If the check fails, print "Invalid email" and return early.

Swift

var email: String? = "[e-mail]"
let minimumLength = 5

func checkEmail() {
    # Use guard let to unwrap email and check length
    # Your code here
}

Hint

Use guard let unwrappedEmail = email, unwrappedEmail.count >= minimumLength else { print("Invalid email"); return } inside the function.

4

Print valid email after guard let

Inside the checkEmail() function, after the guard let statement, print "Email is valid: <unwrappedEmail>". Then call checkEmail() to run the function.

Swift

var email: String? = "[e-mail]"
let minimumLength = 5

func checkEmail() {
    guard let unwrappedEmail = email, unwrappedEmail.count >= minimumLength else {
        print("Invalid email")
        return
    }
    # Print valid email here
}

# Call checkEmail() here
# Your code here

Hint

Use print("Email is valid: \(unwrappedEmail)") and call checkEmail().

Practice

1. What is the main purpose of using guard let in Swift?

easy

A. To declare a constant that cannot be changed

B. To create a loop that runs until a condition is met

C. To handle errors using try-catch blocks

D. To safely unwrap optionals and exit early if the value is nil

Solution

1. Step 1: Understand the role of guard let

   guard let is used to unwrap optionals safely in Swift.

2. Step 2: Recognize early exit behavior

   If the optional is nil, guard let forces an early exit from the current scope, keeping code clean.

3. Final Answer:

   To safely unwrap optionals and exit early if the value is nil -> Option D

4. Quick Check:

   guard let = unwrap + early exit [OK]

Hint: Remember: guard lets you exit early if optional is nil [OK]

Common Mistakes:

• Confusing guard let with if let
• Using guard let without an exit in else block
• Thinking guard let creates loops
• Assuming guard let declares variables only

2. Which of the following is the correct syntax for using guard let to unwrap an optional name?

easy

A. guard let name = name else { return }

B. guard let name == name else { return }

C. guard let name : name else { return }

D. guard let name <- name else { return }

Solution

1. Step 1: Recall correct guard let syntax

   The syntax is guard let constantName = optionalValue else { exit }.

2. Step 2: Match syntax with options

   guard let name = name else { return } matches the correct syntax with single equals and else block.

3. Final Answer:

   guard let name = name else { return } -> Option A

4. Quick Check:

   Correct syntax uses single = and else block [OK]

Hint: Use single = to assign inside guard let [OK]

Common Mistakes:

• Using == instead of = in guard let
• Missing else block after guard let
• Using colon : instead of =
• Using incorrect arrow <-

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

func greet(_ name: String?) {
    guard let unwrappedName = name else {
        print("No name provided")
        return
    }
    print("Hello, \(unwrappedName)!")
}

greet(nil)
greet("Alice")

medium

A. Hello, nil!\nHello, Alice!

B. No name provided\nHello, Alice!

C. No name provided\nNo name provided

D. Hello, Alice!\nNo name provided

Solution

1. Step 1: Analyze first call greet(nil)

   Since name is nil, guard fails, prints "No name provided" and returns early.

2. Step 2: Analyze second call greet("Alice")

   Optional unwraps successfully, prints "Hello, Alice!".

3. Final Answer:

   No name provided\nHello, Alice! -> Option B

4. Quick Check:

   nil triggers else block, non-nil prints greeting [OK]

Hint: guard else runs only if optional is nil [OK]

Common Mistakes:

• Assuming guard lets code run even if nil
• Confusing print order
• Ignoring early return in else block
• Thinking nil prints as string

4. Identify the error in this Swift code using guard let:

func checkAge(_ age: Int?) {
    guard let age = age {
        print("Age is \(age)")
    } else {
        print("Age not provided")
    }
}

medium

A. Using the same variable name 'age' for unwrapped constant causes error

B. Missing else block after guard let

C. The else block is placed after the code block instead of immediately after guard let

D. The function should return a value

Solution

1. Step 1: Check guard let structure

   In Swift, the else block must immediately follow the guard condition without code before it.

2. Step 2: Identify misplaced else block

   Here, the print statement is inside the guard block before else, which is invalid syntax.

3. Final Answer:

   The else block is placed after the code block instead of immediately after guard let -> Option C

4. Quick Check:

   guard else must come immediately after condition [OK]

Hint: Place else block immediately after guard condition [OK]

Common Mistakes:

• Putting code before else block in guard
• Omitting else block entirely
• Thinking guard lets run code before else
• Confusing variable shadowing with error

5. You want to write a function that takes an optional string and prints its uppercase version only if the string is non-empty. Using guard let, which code correctly implements this behavior?

hard

A. func printUpper(_ text: String?) {
guard let text = text, !text.isEmpty else {
return
}
print(text.uppercased())
}

B. func printUpper(_ text: String?) {
if let text = text, text.isEmpty {
print(text.uppercased())
}
}

C. func printUpper(_ text: String?) {
guard let text = text else {
print(text!.uppercased())
return
}
}

D. func printUpper(_ text: String?) {
guard text != nil else {
print(text!.uppercased())
return
}
}

Solution

1. Step 1: Understand requirements

   Function must unwrap optional and check string is not empty before printing uppercase.

2. Step 2: Analyze options

   func printUpper(_ text: String?) { guard let text = text, !text.isEmpty else { return } print(text.uppercased()) } uses guard let to unwrap and checks !text.isEmpty in same condition, then prints uppercase. Others either misuse guard or risk force unwrapping nil.

3. Final Answer:

   func printUpper(_ text: String?) { guard let text = text, !text.isEmpty else { return } print(text.uppercased()) } -> Option A

4. Quick Check:

   guard let + condition filters nil and empty [OK]

Hint: Combine unwrap and condition in guard let for clean checks [OK]

Common Mistakes:

• Force unwrapping optionals without guard
• Using if let but missing empty check
• Placing print inside else block
• Checking nil without unwrapping