Swift Academy · leksjon

Capture-lister for closures og [weak self]

Bruk capture-lister for å hindre closures i å holde objekter med sterke referanser.

Leksjon 4 av 412 trinn

Capture-lister for closures og [weak self] er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Velkommen

Closures fanger opp variabler fra det omsluttende området. Capture-lister (`[weak self]`, `[unowned self]`, `[value]`) styrer nøyaktig hvordan disse variablene fanges opp.

Standard sterk capture

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` Som standard fanger closures opp *referanser* til variabler.

Grunnleggende om capture-lister

```swift var count = 10 let snapshot = { [count] in print(count) } // captures value count = 99 snapshot() // 10 — snapshot of count at capture time ``` Når en verditype listes i `[]`, kopieres verdien idet closuren opprettes.

[weak self]-mønsteret

```swift class API { func fetch(completion: @escaping () -> Void) { ... } } class VC { func load() { api.fetch { [weak self] in guard let self else { return } // self might be nil by now self.updateUI() } } } ```

guard let self med forlenget levetid

Swift 5.3+: bind `self` på nytt inne i guard uten shadowing: ```swift { [weak self] in guard let self else { return } // 'self' is now strong within this block doA() doB() doC() } ```

Når [unowned self] er trygt

```swift button.addTarget(self, action: #selector(tap), for: .touchUpInside) // If the button's closure is guaranteed not to outlive self: let action: () -> Void = { [unowned self] in self.handleTap() } ```

Fange opp flere verdier

```swift let base = 100 let multiplier = 2 let compute = { [base, multiplier] in base * multiplier } print(compute()) // 200 ``` Fang opp flere verdier i den samme listen, atskilt med komma.

Capture-liste med navngitte bindinger

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Nyttig når du vil fange et bestemt øyeblikksbilde under et nytt navn.

Escaping kontra non-escaping

• En `@escaping`-closure kan lagres og kalles etter at funksjonen returnerer → risiko for sykluser • En non-escaping-closure kalles før funksjonen returnerer → ingen risiko for sykluser ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Feilsøking av capture-problemer

Hvis du mistenker en syklus: 1. Legg til `deinit { print("deallocated") }` i klassen 2. Naviger bort eller sett instansen til nil 3. Hvis deinit ikke skriver ut noe → det finnes en syklus Legg deretter til `[weak self]` i closures i denne klassen.

Hurtigsjekk

Hva gjør `[weak self]` i en capture-liste?

Besvar den i den interaktive leksjonen

Oppsummering

Viktige poenger: • Closures fanger som standard opp referanser • Capture-listen `[value]` kopierer verdityper når den opprettes • `[weak self]` — beholder ikke, blir automatisk nil, bruk `guard let self` • `[unowned self]` — beholder ikke, er ikke nil-sikker • `@escaping`-closures trenger capture-lister; non-escaping-closures trenger dem vanligvis ikke Kurset er fullført! Neste: funksjonell programmering i Swift.

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 122
Leksjoner: 409

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Capture-lister for closures og [weak self]» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Capture-lister for closures og [weak self]», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Capture-lister for closures og [weak self]»?

Bruk capture-lister for å hindre closures i å holde objekter med sterke referanser. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Capture-lister for closures og [weak self]»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Slik teller ARC referanser
Retain-sykluser: årsaker og oppdagelse
weak- og unowned-referanser
Capture-lister for closures og [weak self]

← Tilbake til Swift Academy