Closure પોતે reference કરેલા variable ને capture કરે છે, જેથી તેઓ જીવંત રહે છે. જ્યારે closure self ને capture કરે અને self પણ closure ને (stored property તરીકે) રાખે, ત્યારે તેઓ એકબીજાને હંમેશ માટે જીવંત રાખે છે — એ છે જે memory leak કરે છે. જેવી તે 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 કરતાં વધુ જીવે તેમ હોય ત્યારે સુરક્ષિત 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 closure (દા.ત. map, filter, forEach) synchronously ચાલે છે અને capture ને તરત મુક્ત કરે છે — કોઈ cycle નહીં, કોઈ [weak self] નહીં. જોખમ escaping, stored closure સાથે છે: completion handler, Timer, NotificationCenter, Combine sink, delegate block.
Retain cycle એ iOS માં સૌથી સામાન્ય memory leak છે, અને Instruments memory વધતું બતાવે ત્યાં સુધી તે અદૃશ્ય રહે છે. Closure ક્યારે escape થાય છે અને [weak self] શા માટે જરૂરી છે તે ચોક્કસ જાણવું — બધે reflex થી તેને વાપરવાને બદલે — એ ARC સમજતા engineer ને cargo-cult કરનારાથી અલગ પાડે છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો