Module 11: Closures in Swift – Syntax, Usage & Capturing Values
Closures are self-contained blocks of functionality that can be passed around and used in your code. They are similar to anonymous functions or lambdas in other languages. Swift’s closures are powerful and flexible, enabling you to write concise, expressive code, especially for tasks like sorting, filtering, and asynchronous callbacks.
What is a Closure?
A closure is a block of code that can be assigned to a variable, passed as a parameter, or returned from a function. Closures can capture and store references to variables and constants from the surrounding context.
Closure Syntax
Closures come in several forms, from full syntax to very short shorthand syntax:
- Full syntax: includes parameters, return type, and in keyword
- Shorthand syntax: uses implicit returns and shorthand argument names
Example of a closure that adds two numbers:
let sumClosure = { (a: Int, b: Int) -> Int in return a + b }
Using Closures as Function Parameters
Closures are often used as callback functions. You can pass a closure to a function as a parameter to customize behavior.
Example:
func performOperation(_ operation: (Int, Int) -> Int, a: Int, b: Int) {
let result = operation(a, b)
print("Result: \\(result)")
}
You can call this function with a closure:
performOperation({ (x, y) in x * y }, a: 5, b: 3)
Trailing Closures
If a function’s last parameter is a closure, you can use trailing closure syntax to write the closure outside the parentheses for cleaner code.
Example:
performOperation(a: 5, b: 3) { (x, y) in
return x + y
}
Capturing Values
Closures can capture and store references to variables from the context where they were created, allowing them to retain state between calls.
Example:
func makeIncrementer(amount: Int) -> () -> Int {
var total = 0
let incrementer = {
total += amount
return total
}
return incrementer
}
Using it:
let incrementByTwo = makeIncrementer(amount: 2)
print(incrementByTwo()) // 2
print(incrementByTwo()) // 4
Closures and Value Types
Closures capture variables by reference, but when capturing value types like structs, they keep a copy. This allows closures to maintain their own independent state.
Summary
- Closures are blocks of code you can assign and pass around.
- They come with flexible syntax: full or shorthand.
- Closures capture values from their creation context.
- Trailing closure syntax improves code readability.
- Closures are key for asynchronous code, callbacks, and functional programming patterns.
Mastering closures will help you write cleaner, more concise Swift code that handles asynchronous tasks and custom behaviors with ease.