Escaping Closures

func functionName(_ completion: @escaping () -> Void) {
    storage.append(completion)   // stored and called later
}

func other(_ action: () -> Void) {
    action()                     // non-escaping: run before returning
}

// Declare a mutable variable `savedCompletions` (a `[() -> Void]`), initialized to `[]`
var savedCompletions: [() -> Void] = []
// Define the function `saveCompletion` taking `completion`
func saveCompletion(_ completion: @escaping () -> Void) {
    // Append `completion` to `savedCompletions`
    savedCompletions.append(completion)
}
saveCompletion { print("Completion 1 ran") }
saveCompletion { print("Completion 2 ran") }
// Loop over `savedCompletions`, binding each item to `completion`
for completion in savedCompletions {
    completion()
}

// Define the function `runImmediately` taking `action`
func runImmediately(_ action: () -> Void) {
    // Print "About to run" to the console
    print("About to run")
    action()
    // Print "Finished running" to the console
    print("Finished running")
}
runImmediately {
    // Print "Running the action now" to the console
    print("Running the action now")
}

Trailing Closures · Capturing Values · Autoclosures · Closure Shorthand Syntax

1. Forgetting to mark a closure parameter @escaping when it's stored in a property or called after the function returns -- the compiler will flag this.
2. Assuming all closures need @escaping; a closure only needs it if it outlives the function call, e.g. stored for later or used asynchronously.
3. Creating a strong reference cycle by capturing self strongly inside a stored escaping closure without using [weak self].

• A closure parameter must be marked @escaping if it's stored or called after the function returns.
• Non-escaping closures (the default) must be used only during the function call itself.
• Escaping closures are common for completion handlers and asynchronous callbacks.
• Capturing self in a stored escaping closure risks a retain cycle unless handled carefully.