Guard for early exit pattern in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use a guard statement that exits early if the number is not positive.

Swift

func checkNumber(_ number: Int) {
    guard [1] else {
        print("Number is not positive")
        return
    }
    print("Number is positive")
}

Drag options to blanks, or click blank then click option'

Anumber > 0

Bnumber == 0

Cnumber < 0

Dnumber >= 0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'number == 0' which allows zero as positive.

Using 'number < 0' which is the opposite condition.

The guard statement checks if the number is greater than zero. If not, it exits early.

2fill in blank

medium

Complete the guard statement to unwrap the optional string safely.

Swift

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

Drag options to blanks, or click blank then click option'

Aname!

BString(name)

CunwrappedName

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'name!' which force unwraps and can cause a crash.

Using 'unwrappedName' which is the new constant, not the optional.

The guard statement unwraps the optional 'name' safely using 'let'.

3fill in blank

hard

Fix the error in the guard statement to check if the array is not empty.

Swift

func process(items: [Int]) {
    guard [1] else {
        print("No items to process")
        return
    }
    print("Processing \(items.count) items")
}

Drag options to blanks, or click blank then click option'

Aitems.count == 0

Bitems.isEmpty

C!items.isEmpty

Ditems.count > 0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'items.isEmpty' which exits early when array has items.

Using 'items.count == 0' which is true when empty, opposite of needed.

The guard statement should check that the array is NOT empty using '!items.isEmpty'.

4fill in blank

hard

Fill both blanks to unwrap an optional integer and check it is positive.

Swift

func validate(_ value: Int?) {
    guard let number = [1], number [2] 0 else {
        print("Invalid number")
        return
    }
    print("Valid number: \(number)")
}

Drag options to blanks, or click blank then click option'

Avalue

B>

C>=

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' instead of '>' which allows zero as valid.

Using 'number' instead of 'value' to unwrap.

First unwrap the optional 'value' with 'let'. Then check if 'number' is greater than zero.

5fill in blank

hard

Fill all three blanks to unwrap two optionals and check the second is not empty.

Swift

func process(user: String?, email: String?) {
    guard let username = [1], let userEmail = [2], !userEmail.[3] else {
        print("Missing or empty email")
        return
    }
    print("User: \(username), Email: \(userEmail)")
}

Drag options to blanks, or click blank then click option'

Auser

Bemail

CisEmpty

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'count' instead of 'isEmpty' which requires a comparison.

Not unwrapping both optionals before checking.

Unwrap 'user' and 'email' optionals, then check that 'userEmail' is not empty using '!userEmail.isEmpty'.

Practice

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

easy

A. To define functions with multiple parameters

B. To create loops that run a fixed number of times

C. To check a condition and exit early if it is false

D. To declare constants and variables

Solution

1. Step 1: Understand the role of guard

   guard is used to check a condition and exit the current scope early if the condition is false.

2. Step 2: Compare with other options

   Options A, B, and C describe functions, loops, and variable declarations, which are unrelated to guard.

3. Final Answer:

   To check a condition and exit early if it is false -> Option C

4. Quick Check:

   Guard = early exit on false condition [OK]

Hint: Guard exits early if condition fails, keeping code clean [OK]

Common Mistakes:

• Confusing guard with if statements
• Thinking guard creates loops
• Using guard to declare variables

2. Which of the following is the correct syntax for a guard statement in Swift?

easy

A. guard condition { return }

B. guard (condition) { return }

C. guard else condition { return }

D. guard condition else { return }

Solution

1. Step 1: Recall the syntax of guard

   The correct syntax is guard condition else { ... } where the else block handles the early exit.

2. Step 2: Check each option

   guard condition else { return } matches the correct syntax. Options A, B, and D have missing else, extra parentheses, or misplaced keywords.

3. Final Answer:

   guard condition else { return } -> Option D

4. Quick Check:

   Guard syntax = guard condition else { } [OK]

Hint: Remember: guard condition else { exit code } [OK]

Common Mistakes:

• Putting condition inside parentheses incorrectly
• Omitting else keyword
• Placing else before condition

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

func checkAge(_ age: Int?) {
    guard let age = age, age >= 18 else {
        print("Access denied")
        return
    }
    print("Access granted")
}

checkAge(nil)
checkAge(16)
checkAge(21)

medium

A. Access denied
Access denied
Access granted

B. Access granted
Access granted
Access granted

C. Access denied
Access granted
Access denied

D. Access granted
Access denied
Access denied

Solution

1. Step 1: Analyze the guard condition

   The guard checks if age is not nil and at least 18. If false, it prints "Access denied" and returns early.

2. Step 2: Evaluate each function call

   For checkAge(nil), age is nil -> prints "Access denied".
   For checkAge(16), age is 16 < 18 -> prints "Access denied".
   For checkAge(21), age is 21 ≥ 18 -> prints "Access granted".

3. Final Answer:

   Access denied Access denied Access granted -> Option A

4. Quick Check:

   Guard filters nil or under 18 = Access denied [OK]

Hint: Guard lets only valid age (18+) pass, else denies [OK]

Common Mistakes:

• Ignoring nil check in guard
• Assuming all calls print Access granted
• Confusing guard with if

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

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

medium

A. Incorrect use of optional binding in guard

B. Missing return or exit after guard else block

C. Using force unwrap (!) inside print

D. Guard condition should be inside parentheses

Solution

1. Step 1: Understand guard requirements

   The else block of a guard must exit the current scope (return, break, continue, or throw).

2. Step 2: Check the code

   The else block prints a message but does not return or exit, so the function continues and force unwraps a nil value, causing a runtime error.

3. Final Answer:

   Missing return or exit after guard else block -> Option B

4. Quick Check:

   Guard else must exit scope [OK]

Hint: Always exit after guard else block (return, throw, etc.) [OK]

Common Mistakes:

• Forgetting return after guard else
• Assuming print alone exits function
• Ignoring force unwrap risks

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, which code snippet correctly implements this behavior?

hard

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

B. func printUpper(_ text: String?) {
if let text = text, !text.isEmpty {
print(text.uppercased())
} else {
print("Empty or nil string")
}
}

C. func printUpper(_ text: String?) {
guard text != nil else {
print("Empty or nil string")
return
}
print(text!.uppercased())
}

D. func printUpper(_ text: String?) {
guard let text = text else {
print("Empty or nil string")
return
}
if text.isEmpty {
print("Empty or nil string")
}
print(text.uppercased())
}

Solution

1. Step 1: Understand the requirements

   The function must print uppercase only if the string is non-nil and not empty, else print a message and exit early.

2. Step 2: Evaluate each option

   func printUpper(_ text: String?) { guard let text = text, !text.isEmpty else { print("Empty or nil string") return } print(text.uppercased()) } uses a single guard with optional binding and emptiness check, then prints uppercase.
   func printUpper(_ text: String?) { if let text = text, !text.isEmpty { print(text.uppercased()) } else { print("Empty or nil string") } } uses if-else, not guard.
   func printUpper(_ text: String?) { guard text != nil else { print("Empty or nil string") return } print(text!.uppercased()) } only checks nil, not empty.
   func printUpper(_ text: String?) { guard let text = text else { print("Empty or nil string") return } if text.isEmpty { print("Empty or nil string") } print(text.uppercased()) } uses guard for nil, then if for empty that prints message but lacks return, so continues to print uppercased empty string, incorrect.

3. Final Answer:

   guard let text = text, !text.isEmpty else { print("Empty or nil string"); return } print(text.uppercased()) -> Option A

4. Quick Check:

   Guard with let and !isEmpty = correct early exit [OK]

Hint: Combine let binding and condition in one guard for clean code [OK]

Common Mistakes:

• Checking only nil but not empty
• Using if instead of guard for early exit
• Splitting checks into multiple statements unnecessarily