ਇੱਕ closure ਉਹਨਾਂ variables ਨੂੰ capture ਕਰਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਇਹ reference ਦਿੰਦੀ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਜ਼ਿੰਦਾ ਰੱਖਦੀ ਹੈ। ਜਦੋਂ ਇੱਕ 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 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 ਸਮਝਦੇ ਹਨ ਉਹਨਾਂ ਤੋਂ ਜੋ ਇਸਨੂੰ ਬਿਨਾਂ ਸੋਚੇ ਨਕਲ ਕਰਦੇ ਹਨ।
ਵਿਸਤ੍ਰਿਤ ਜਵਾਬਾਂ ਨਾਲ IT ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ — ਜੂਨੀਅਰ ਤੋਂ ਸੀਨੀਅਰ ਤੱਕ।
ਦਾਨ ਕਰੋ