Swift Academy · Pelajaran

Daftar Penangkapan dan Weak Self

Hindari siklus retain dengan [weak self].

Daftar Penangkapan dan Weak Self adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Risiko Siklus Retensi

Ketika sebuah objek menyimpan closure yang keluar dan closure tersebut menangkap self secara kuat, keduanya saling mempertahankan selamanya — terbentuk siklus retensi yang menyebabkan kebocoran memori.

Siklus Kuat

Closure menangkap self secara kuat dan self menyimpan closure tersebut — tidak satu pun pernah dibebaskan:

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)

Daftar Tangkapan

Daftar tangkapan di awal closure, { [weak self] in ... }, mengatur cara setiap referensi yang ditangkap disimpan: weak atau unowned, bukan secara kuat.

Memutus Siklus dengan self Lemah

[weak self] menangkap self sebagai nilai opsional yang tidak membuatnya tetap hidup:

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)

weak Menjadikan self Opsional

Dengan [weak self], self menjadi Self?, jadi Anda harus membukanya:

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"

Pola guard let self

Ikat kembali self sejak awal agar bagian closure selanjutnya menggunakan referensi kuat yang tidak opsional:

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"

weak vs unowned

weak menghasilkan nilai opsional dan aman jika objek mungkin sudah tidak ada. unowned tidak opsional dan lebih cepat, tetapi menyebabkan crash jika diakses setelah objek dibatalkan alokasinya — gunakan hanya ketika self dijamin hidup lebih lama daripada closure.

Menggunakan unowned

Pilih unowned ketika closure tidak mungkin hidup lebih lama daripada self:

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

Menangkap Properti Tertentu

Tangkap hanya hal yang Anda perlukan, bukan seluruh self — terkadang cara ini sepenuhnya menghindari siklus:

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

Closure yang Tidak Keluar Tidak Memerlukan weak

Closure sinkron yang tidak keluar (seperti map) tidak menyebabkan siklus, jadi menangkap self secara kuat di dalamnya tidak masalah:

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]

Aturan Praktis

Gunakan [weak self] untuk closure yang disimpan atau keluar dan merujuk self. Gunakan unowned hanya ketika self dijamin tetap hidup. Lewati daftar tangkapan untuk closure yang tidak keluar.

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"

Pemeriksaan Singkat

Mengapa menggunakan [weak self] dalam closure yang disimpan dan keluar?

Ringkasan

Anda telah mempelajari daftar tangkapan:

self yang kuat dalam closure yang disimpan dan keluar membuat siklus retensi (kebocoran)
[weak self] memutuskannya; self menjadi opsional — gunakan guard let self
unowned tidak opsional dan lebih cepat, tetapi menyebabkan crash jika self sudah tidak ada
Closure yang tidak keluar tidak memerlukan daftar tangkapan

Berikutnya: autoclosures.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Daftar Penangkapan dan Weak Self” gratis?

Ya — teks lengkap “Daftar Penangkapan dan Weak Self” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Daftar Penangkapan dan Weak Self”?

Hindari siklus retain dengan [weak self]. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Daftar Penangkapan dan Weak Self” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy