Guard

A guard statement is a conditional control flow construct that enforces early exit from a scope if one or more evaluated conditions evaluate to false. It acts as a strict prerequisite check, ensuring that subsequent code within the current scope executes only if the specified requirements are satisfied.

func evaluateCondition(condition: Bool) {
    guard condition else {
        // Control transfer statement required (return, break, continue, throw)
        return
    }
    // Execution continues here if condition is true
}

Core Mechanics and Compiler Enforcement

Unlike an if statement, a guard statement strictly requires an else clause. The Swift compiler enforces a non-fallthrough rule for this else block: it must transfer control out of the scope in which the guard statement appears.

To satisfy the compiler, the else block must terminate using one of the following control transfer statements:

• return
• break
• continue
• throw

Alternatively, it can call a function or method that returns the Never type, such as fatalError() or preconditionFailure().

Optional Binding and Scope

A defining characteristic of the guard statement is its interaction with optional binding (guard let or guard var). When an optional is successfully unwrapped within a guard statement’s condition, the resulting bound constant or variable is introduced into the enclosing scope containing the guard statement. It becomes available for use immediately after the guard declaration.

func printStringLength(optionalString: String?) {
    guard let unwrappedString = optionalString else {
        return
    }

    // unwrappedString is now available in the enclosing scope
    print(unwrappedString.count) 
}

This contrasts with if let bindings, where the unwrapped variable is strictly confined to the inner scope of the if block. If the guard condition fails, the else block executes, and the bound variable is never initialized in the outer scope.

Compound Conditions

guard statements support compound conditions separated by commas (,). These commas function as logical AND (&&) operators. The compiler evaluates these conditions sequentially and employs short-circuit evaluation; if any condition evaluates to false or fails to unwrap, evaluation halts immediately and control transfers to the else block.

enum ExecutionError: Error {
    case invalidState
}

func processCoordinates(optionalX: Int?, optionalY: Int?) throws {
    guard let unwrappedX = optionalX,
          let unwrappedY = optionalY,
          unwrappedX > 0,
          unwrappedY != unwrappedX else {
        throw ExecutionError.invalidState
    }
    
    // unwrappedX and unwrappedY are available here
    print(unwrappedX + unwrappedY)
}

Compound conditions can mix optional bindings, boolean expressions, and pattern matching (such as case statements) within a single guard declaration. All bindings established in the compound condition become available in the subsequent enclosing scope.

Master Swift with Deep Grasping Methodology!

Learn More