> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift 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.
```swift theme={"dark"}
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.
```swift theme={"dark"}
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.
```swift theme={"dark"}
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.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
