guard / guard let / guard var

// Basic guard statement
guard condition else {
    // Runs when the condition is not met (return/throw/break required)
    return
}

// guard let — unwrap an Optional
guard let constantName = optionalValue else {
    return
}
// constantName is available as a non-Optional from here on

// Multiple conditions
guard let x = optX, let y = optY, x > 0 else {
    return
}

// Unwrap an Optional with guard let
func greet(name: String?) {
    guard let name = name else {
        print("No name provided")
        return
    }
    // name is a non-Optional String from here on
    print("Hello, \(name)!")
}

greet(name: "Taro")
greet(name: nil)

// guard with multiple conditions
func processOrder(userID: Int?, amount: Double?) {
    guard let userID = userID, let amount = amount, amount > 0 else {
        print("Invalid order information")
        return
    }
    print("Order from user \(userID): $\(amount)")
}

processOrder(userID: 42, amount: 1500.0)
processOrder(userID: nil, amount: 500.0)
processOrder(userID: 10, amount: -100.0)

// Comparison with if let (guard produces less nesting)
func checkAge(age: Int?) {
    guard let age = age, age >= 18 else {
        print("Under 18 or age unknown")
        return
    }
    print("Age \(age) is valid")
}

checkAge(age: 25)
checkAge(age: 15)

The else clause of a guard statement must always end with a control transfer statement such as return, throw, break, or continue. This guarantees that any code after the guard only runs when all conditions have been met.

Constants and variables unwrapped by guard let are available throughout the enclosing scope — everywhere except inside the else clause itself. Unlike if let, this lets you work with unwrapped values without additional nesting. Forgetting the control transfer statement at the end of the else clause causes a compile error.

For the basics of Optionals, see Optional / ? / !.