Skip to main content
Mapagam

Working with Closures

1. Understanding Closure Syntax ({ })

Aspect Description Example
Basic Syntax Enclosed in braces {}, takes parameters and returns a value 
let closure = { (param: String) -> String in
    return "Hello, \(param)"
}
Inference Swift infers parameter and return types when possible 
let inferred = { (name: String) in
    print("Hello, \(name)")
}
Trailing Closures When a function takes a closure as the last parameter, it can be placed outside parentheses 
func performAction(completion: () -> Void) {
    completion()
}
performAction() { 
    print("Completed") 
}
Capturing Values Closures can capture and store references to variables from their surrounding context 
var counter = 0
let increment = {
    counter += 1
}
increment()
print(counter) // 1

2. Using Trailing Closures

Property Description Example
Trailing Closure Syntax When the last parameter of a function is a closure, it can be written outside the parentheses. 
func performOperation(_ numbers: [Int], operation: (Int) -> Int) -> [Int] {
    return numbers.map(operation)
}

let result = performOperation([1, 2, 3]) { number in
    return number * 2
}
Multiple Trailing Closures Functions can accept multiple trailing closures, which must be specified in order. 
func processItems(_ items: [String], filter: (String) -> Bool, transform: (String) -> String) -> [String] {
    return items.filter(filter).map(transform)
}

let filtered = processItems(["apple", "banana", "cherry"]) { item in
    return item.hasPrefix("a")
} transform: { item in
    return item.uppercased()
}

Example: Trailing Closure with Higher-Order Functions

let numbers = [1, 2, 3, 4, 5]

// Using trailing closure with map
let doubled = numbers.map { number in
    number * 2
}

// Using trailing closure with filter
let evenNumbers = numbers.filter { number in
    number % 2 == 0
}
Note: Trailing closures are particularly useful when working with higher-order functions like map, filter, and reduce.

3. Using Shorthand Argument Names ($0, $1)

In Swift, when you're working with closures and the parameters are used only once, you can use shorthand argument names to make your code more concise. These shorthand arguments are represented as $0, $1, and so on, where $0 refers to the first argument, $1 to the second, and so forth.

Shorthand Argument Description Usage Example
$0 Represents the first argument in a closure. 
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6, 8, 10]
$1 Represents the second argument in a closure. 
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum) // 15
Note: Shorthand argument names are only available in closures where the parameters are used directly. If you need to reference a parameter more than once or use it in a complex expression, you should name the parameters explicitly.

4. Understanding Capturing Values

Closure Type Description Example
Value Capture Closures can capture and store references to variables from their surrounding context. 
func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}
let counter = makeCounter()
print(counter()) // 1
print(counter()) // 2
Strong Reference Cycles When a closure holds a strong reference to an object, it can lead to retain cycles. 
class MyClass {
    var closure: (() -> Void)?
    
    deinit {
        print("MyClass deinitialized")
    }
}
let obj = MyClass()
obj.closure = { [weak obj] in
    print("Closure executed")
    obj?.toString() // Safe access using weak reference
}
Unowned References Use unowned when you're sure the captured reference will not be deallocated before closure execution. 
class Parent {
    var child: Child?
    
    deinit {
        print("Parent deinitialized")
    }
}
class Child {
    unowned let parent: Parent
    
    init(parent: Parent) {
        self.parent = parent
    }
}
Note: Use [weak self] or [unowned self] in closures to prevent retain cycles when referencing self.

5. Using Escaping Closures

Closures that are not immediately executed and are instead stored for later use are called escaping closures. They must be marked with the escaping keyword in the function signature.

Property Description Notes
escaping Marks a closure that is stored for later execution Required when passing closures to functions that store them

Example: Storing an Escaping Closure

class DataFetcher {
    var completion: (() -> Void)? = nil

    func fetchData(completionHandler: @escaping () -> Void) {
        completion = completionHandler
    }

    func triggerCompletion() {
        completion?()
    }
}

let fetcher = DataFetcher()
fetcher.fetchData { 
    print("Data fetched asynchronously") 
}
fetcher.triggerCompletion()
Note: The @escaping attribute is required when a closure is stored for later use, such as in asynchronous operations or callbacks.

6. Using Autoclosures

An autoclosure is a closure that is automatically wrapped in a closure by the compiler. It allows you to pass a value or expression to a function without explicitly wrapping it in braces.

Property Description Example
@autoclosure Attribute that converts a parameter into an autoclosure func execute(_ closure: @autoclosure () -> String) { ... }

Example: Basic Autoclosure Usage

func printMessage(_ message: @autoclosure () -> String) {
    print(message())
}

let greeting = "Hello, Swift!"
printMessage(greeting)

Example: Autoclosure with Default Values

func processIfTrue(_ condition: @autoclosure () -> Bool, action: () -> Void) {
    if condition() {
        action()
    }
}

let value = 10
processIfTrue(value > 5) {
    print("Value is greater than 5")
}
Note: Autoclosures are useful for lazy evaluation and can help reduce boilerplate code when working with conditional logic or optional values.

7. Understanding Closure Reference Cycles

A closure in Swift captures and stores references to any constants or variables from the context in which it is defined. When a closure holds a strong reference to an object (like self in a class), it can create a retain cycle, preventing the object from being deallocated.

Reference Type Closure Capture Impact
Strong Reference self or object Prevents deallocation if closure holds reference
Weak Reference weak self Does not increase reference count; can be nil
Unowned Reference unowned self Assumes object will not be deallocated; crashes if used after deallocation

Example: Retain Cycle

class Person {
    let name: String
    var room: Room?

    init(name: String) {
        self.name = name
    }

    deinit {
        print("Person " + name + " is being deallocated")
    }
}

class Room {
    let roomName: String
    weak var person: Person?

    init(roomName: String) {
        self.roomName = roomName
    }

    deinit {
        print("Room " + roomName + " is being deallocated")
    }
}

var person: Person? = Person(name: "Alice")
var room: Room? = Room(roomName: "Conference Room")

person?.room = room
room?.person = person

// Both objects retain each other, causing a retain cycle
// Deinitializers will not be called when these are set to nil

person = nil
room = nil

Example: Fixing Retain Cycles with Weak References

class Person {
    let name: String
    var room: Room?

    init(name: String) {
        self.name = name
    }

    deinit {
        print("Person " + name + " is being deallocated")
    }
}

class Room {
    let roomName: String
    weak var person: Person? // Using weak to break the cycle

    init(roomName: String) {
        self.roomName = roomName
    }

    deinit {
        print("Room " + roomName + " is being deallocated")
    }
}

var person: Person? = Person(name: "Alice")
var room: Room? = Room(roomName: "Conference Room")

person?.room = room
room?.person = person

// Using weak reference prevents retain cycle
// Deinitializers will be called when these are set to nil

person = nil
room = nil
Note: When using weak, the captured reference becomes optional, so you must unwrap it before use.
Warning: Using unowned can lead to runtime crashes if the referenced object is deallocated before the closure is executed.

8. Using Weak and Unowned References

Reference Type Description Use Case Memory Management
Weak Reference Does not increase the reference count of the object it points to. When the referenced object can be deallocated, and the reference should become nil. Automatically set to nil when the referenced object is deallocated.
Unowned Reference Does not increase the reference count of the object it points to. When the referenced object is guaranteed to exist for the lifetime of the reference. Assumes that the referenced object will not be deallocated before the reference is used.

Example: Weak Reference in Closures

class ViewController: UIViewController {
    var completion: (() -> Void)? = nil

    func setupClosure() {
        completion = { [weak self] in
            guard let self = self else { return }
            print("View controller is still alive")
        }
    }
}

Example: Unowned Reference in Closures

class Button {
    var action: (() -> Void)? = nil

    func setupAction() {
        action = { [unowned self] in
            print("Button action executed")
        }
    }
}
Note: Use weak when the referenced object might be deallocated, and unowned when it's guaranteed to exist.
Warning: Using unowned without ensuring the object's lifetime can lead to runtime crashes.

9. Using Map, Filter, Reduce with Closures

Example: Transforming an Array with Map

let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6, 8, 10]
Method Description Return Type Example
map Transforms each element in a collection New array with transformed elements array.map { element in element * 2 }
filter Creates a new array with elements that pass a test New array with filtered elements array.filter { element in element > 5 }
reduce Combines all elements into a single value Single accumulated value array.reduce(0) { sum, element in sum + element }

Example: Filtering and Reducing

let scores = [85, 92, 78, 96, 88]
let passingScores = scores.filter { $0 >= 80 }
let totalScore = passingScores.reduce(0, +)
print(totalScore) // 359
Note: Closures in map, filter, and reduce can use shorthand argument names like $0, $1 for the first, second argument, etc.

Example: Nested Operations with Closures

let words = ["hello", "world", "swift"]
let lengths = words
    .filter { $0.count > 3 }
    .map { $0.uppercased() }
    .reduce("") { $0 + $1 + " " }
print(lengths) // "HELLO WORLD SWIFT "

10. Creating Custom Higher-Order Functions

Higher-order functions are functions that take other functions as parameters or return functions. In Swift, you can create custom higher-order functions to encapsulate reusable patterns.

Function Description Example
map Transforms each element in a collection using a closure. 
let numbers = [1, 2, 3, 4]
let doubled = numbers.map { $0 * 2 }
// Result: [2, 4, 6, 8]
filter Creates a new array containing only elements that satisfy a condition. 
let numbers = [1, 2, 3, 4, 5]
let even = numbers.filter { $0 % 2 == 0 }
// Result: [2, 4]
reduce Combines all elements of a collection into a single value. 
let numbers = [1, 2, 3, 4]
let sum = numbers.reduce(0) { $0 + $1 }
// Result: 10

Example: Custom Higher-Order Function

func applyTwice(_ function: (Int) -> Int, to value: Int) -> Int {
    return function(function(value))
}

let result = applyTwice({ $0 + 1 }, to: 5)
// Result: 7

Was this article helpful?

Related Cheat Sheets