एक closure अपने द्वारा संदर्भित variables को capture करता है, जिससे वे जीवित रहते हैं। जब एक closure self को capture करता है और self भी closure को रखता है (एक stored property), तो वे एक-दूसरे को हमेशा के लिए जीवित रखते हैं — एक जो memory लीक करता है। जैसी एक उस cycle को तोड़ देती है।
[weak self]ARC एक object को तब मुक्त करता है जब उसका reference count शून्य हो जाता है। एक strong capture उस count को बढ़ा देता है।
final class Downloader {
var onDone: (() -> Void)? // stored closure -> strong
func start() {
// BAD: closure captures self strongly, self holds closure -> cycle
onDone = { self.cleanup() }
// GOOD: weak capture, self can deallocate
onDone = { [weak self] in
guard let self else { return } // safely unwrap; bail if gone
self.cleanup()
}
}
func cleanup() {}
}
[weak self] — self एक optional बन जाता है; यदि object मुक्त हो गया तो यह nil होता है। जब object closure से अधिक समय तक जीवित रह सकता हो, तो safe default।[unowned self] — non-optional, कोई ARC overhead नहीं, लेकिन यदि self पहले ही जा चुका है तो crash कर जाता है। केवल तब उपयोग करें जब self का closure से अधिक जीवित रहना सुनिश्चित हो।Task { [weak self] in
let data = await self?.fetch() // self? short-circuits if deallocated
}
Non-escaping closures (जैसे map, filter, forEach) synchronously चलते हैं और captures को तुरंत release कर देते हैं — कोई cycle नहीं, कोई [weak self] की जरूरत नहीं। जोखिम escaping, stored closures के साथ है: completion handlers, Timer, NotificationCenter, Combine sinks, delegate blocks।
Retain cycles iOS में सबसे आम memory leak हैं, और ये तब तक अदृश्य रहते हैं जब तक Instruments बढ़ती memory नहीं दिखाता। यह ठीक-ठीक जानना कि एक closure कब escape करता है और [weak self] की क्यों जरूरत है — बजाय इसके कि हर जगह प्रतिवर्ती रूप से उसका सहारा लिया जाए — उन engineers को अलग करता है जो ARC समझते हैं उनसे जो इसे cargo-cult करते हैं।
विस्तृत उत्तरों के साथ IT इंटरव्यू प्रश्नों की एक लाइब्रेरी — जूनियर से सीनियर तक।
दान करें