Swift Academy · Ders

Yakalama Listeleri ve Weak Self

[weak self] ile saklama döngülerinden kaçının.

Yakalama Listeleri ve Weak Self, CoddyKit'te ücretsiz bir Swift Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Swift Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Swift Academy kursu toplamda 4 dersten oluşur.

Tutma Döngüsü Riski

Bir nesne, self değerini güçlü biçimde yakalayan bir kaçış yapan kapanış sakladığında, ikisi de birbirini sonsuza kadar canlı tutar — bu, bellek sızdıran bir tutma döngüsüdür.

Güçlü Bir Döngü

Kapanış self değerini güçlü biçimde yakalar ve self kapanışı tutar — ikisi de hiçbir zaman serbest bırakılmaz:

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { print(self.describe()) }  // strong self -> cycle
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (but leaks)

Yakalama Listeleri

Kapanışın başındaki bir yakalama listesi, { [weak self] in ... } ifadesinde her yakalanan referansın nasıl tutulacağını denetler: güçlü tutma yerine weak veya unowned.

Döngüyü Zayıf self ile Kırma

[weak self], self değerini onu canlı tutmayan isteğe bağlı bir değer olarak yakalar:

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { [weak self] in
            print(self?.describe() ?? "gone")
        }
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (no cycle)

Zayıf self İsteğe Bağlıdır

[weak self] ile self, Self? olur; bu nedenle açmanız gerekir:

class Worker {
    var tag = "W"
    lazy var job: () -> Void = { [weak self] in
        guard let self = self else { return }
        print(self.tag)
    }
}
let w = Worker()
w.job()  // "W"

self'i Güvenceyle Bağlama Deseni

Erken aşamada self değerini yeniden bağlayın; böylece kapanışın geri kalanında güçlü ve isteğe bağlı olmayan bir referans kullanılır:

class Service {
    var name = "S"
    lazy var run: () -> Void = { [weak self] in
        guard let self else { return }
        print(self.name)
        print("still \(self.name)")
    }
}
Service().run()  // "S" / "still S"

Zayıf ve Sahipsiz Karşılaştırması

weak isteğe bağlı bir değer üretir ve nesne ortadan kalkmış olabilirse güvenlidir. unowned isteğe bağlı değildir ve daha hızlıdır; ancak nesne serbest bırakıldıktan sonra erişilirse çöker — yalnızca self değerinin kapanıştan daha uzun yaşayacağı garanti edildiğinde kullanın.

Sahipsiz Kullanımı

Kapanışın self değerinden daha uzun yaşamayacağı kesin olduğunda unowned seçin:

class Timer2 {
    var ticks = 0
    lazy var tick: () -> Void = { [unowned self] in
        self.ticks += 1
    }
}
let t = Timer2()
t.tick(); t.tick()
print(t.ticks)  // 2

Belirli Özellikleri Yakalama

self değerinin tamamı yerine yalnızca ihtiyacınız olanı yakalayın — bu bazen döngüyü tamamen önler:

class VM {
    let id = 42
    lazy var printer: () -> Void = { [id] in print(id) }
}
VM().printer()  // 42

Kaçış Yapmayan Kapanışlarda Zayıf Referans Gerekmez

Eşzamanlı ve kaçış yapmayan kapanışlar (örneğin map) döngülere neden olmaz; bu nedenle burada self değerini güçlü biçimde yakalamak sorun değildir:

class Calc {
    let factor = 3
    func scale(_ xs: [Int]) -> [Int] {
        xs.map { $0 * self.factor }   // safe, non-escaping
    }
}
print(Calc().scale([1, 2]))  // [3, 6]

Pratik Kural

self'e başvuran saklanan veya kaçış yapan kapanışlar için [weak self] kullanın. unowned seçeneğine yalnızca self'in canlı kalacağı garanti edildiğinde başvurun. Kaçış yapmayan kapanışlar için yakalama listelerini atlayın.

class P {
    var n = "P"
    var stored: (() -> Void)?
    func arm() { stored = { [weak self] in print(self?.n ?? "-") } }
}
let p = P(); p.arm(); p.stored?()  // "P"

Hızlı Kontrol

Saklanan ve kaçış yapan bir kapanışta neden [weak self] kullanılır?

Özet

Yakalama listelerini öğrendiniz:

Saklanan ve kaçış yapan bir kapanışta güçlü self kullanmak, bir tutma döngüsü oluşturur (bellek sızıntısı)
[weak self] bunu kırar; self isteğe bağlı olur — guard let self kullanın
unowned isteğe bağlı değildir ve daha hızlıdır; ancak self ortadan kalkmışsa çöker
Kaçış yapmayan kapanışların yakalama listelerine ihtiyacı yoktur

Sırada: otomatik kapanışlar var.

Sıkça Sorulan Sorular

“Yakalama Listeleri ve Weak Self” dersi ücretsiz mi?

Evet — “Yakalama Listeleri ve Weak Self” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Swift Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Swift Academy kursu toplamda 4 dersten oluşur.

“Yakalama Listeleri ve Weak Self” dersinde ne öğreneceğim?

[weak self] ile saklama döngülerinden kaçının. Swift Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Swift Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Swift Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Yakalama Listeleri ve Weak Self” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Swift Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Swift Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Swift Academy Sayfasına Dön