Escaping closure captures mutating ‘self’ parameter

Escaping Closure Captures Mutating ‘self’ Parameter

When using closures in Swift, it is important to be cautious of capturing the mutating ‘self’ parameter. Closures are reference types, and by default, they capture and store references to any constants or variables from the surrounding context in which they are defined.

In certain scenarios, when defining a closure that captures a mutable instance of a class or structure, Swift requires you to explicitly declare the closure as “escaping” to prevent retain cycles. A retain cycle occurs when an instance holds a strong reference to a closure, and the closure holds a strong reference back to the instance, creating a memory leak.

Example:

    class MyClass {
        var value = 10
        
        func performClosure() {
            let closure = { [weak self] in
                self?.value += 5 // Mutating 'self' parameter captured inside the closure
            }
            
            closure()
        }
    }
    
    let instance = MyClass()
    instance.performClosure()
    print(instance.value) // Output: 15
  

In the above example, we have a simple class called MyClass with a variable ‘value’. Inside the performClosure() method, we define a closure that captures ‘self’ by using the [weak self] capture list to avoid a strong reference cycle.

Within the closure, we mutate the ‘value’ property of the captured instance ‘self’ by adding 5 to it. Finally, we call the closure and print the updated value, which will be 15.

By declaring self as weak, we allow it to be deallocated if there are no other strong references to it, thus avoiding the retain cycle. Additionally, we use optional chaining (self?.value) to safely access and modify the property, considering the possibility of self being nil at the point of execution.

Note that escaping closures can also be used when passing a closure as an argument to a function/method and storing it for later use.