闭包直接捕获值的内存语义及方法捕获安全性问询

Great question—this is a really neat but often misunderstood Swift feature! Let’s break down what’s happening here and whether this practice is safe.

First: What Does Capturing an Instance Method Actually Do? #

When you write [showErrorAlert, populate] in a capture list, you’re not just capturing the method itself—Swift implicitly creates a closure that binds the method to your current self instance. By default, this closure holds a strong reference to self, because the instance method needs self to execute (it can’t run without the instance it belongs to).

Is This Practice Safe? (Spoiler: Usually Not, Unless You’re Careful) #

This approach carries the same risk of retain cycles as directly capturing self strongly. If the closure you’re passing (like the onNext handler in your example) is stored in a property that’s owned by self (or part of a cycle that includes self), you’ll end up with a retain cycle:

• self holds a reference to the object that owns the subscription
• The subscription holds a reference to the onNext closure
• The closure holds a strong reference to self (via the captured methods)

This will prevent self from being deallocated properly, leading to memory leaks.

How Does This Compare to [weak self] + strongSelf? #

It’s not equivalent to the standard [weak self] pattern. The [weak self] approach explicitly captures a weak reference to self, breaking potential cycles. When you capture an instance method directly, you’re effectively doing the same as capturing self strongly—you’re just hiding the self reference behind the method name.

How to Use This Pattern Safely #

If you want to keep the clean syntax of capturing methods, you can explicitly capture them as weak references by binding them to self with a weak qualifier:

.subscribe(onNext: { [weak showErrorAlert = self.showErrorAlert, weak populate = self.populate] result in
    guard let showErrorAlert = showErrorAlert, let populate = populate else { return }
    switch result {
    case .success(let book):
        populate(book)
    case .error(_):
        showErrorAlert(L10n.errorExecutingOperation.localized)
    }
})

This way, you’re capturing weak references to the method closures, which won’t retain self—mirroring the safety of the [weak self] + optional binding pattern.

Key Takeaway #

Capturing instance methods directly in a capture list is convenient, but it’s not safe by default. It implicitly retains self strongly, which can lead to retain cycles. To make it safe, you need to explicitly mark the captured methods as weak, just like you would with self.

内容的提问来源于stack exchange，提问作者emenegro