Swift Academy · Lektion

Closure-fångstlistor och [weak self]

Använd fångstlistor för att förhindra att closures fångar objekt med starka referenser.

Lektion 4 av 412 steg

Closure-fångstlistor och [weak self] är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Välkommen

Closures fångar variabler från sin omgivande kontext. Fångstlistor (`[weak self]`, `[unowned self]`, `[value]`) styr exakt hur dessa fångster görs.

Stark infångning som standard

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` Som standard fångar closures *referenser* till variabler.

Grunderna i fångstlistor

```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 värdetyp listas i `[]` kopieras värdet i det ögonblick då closuren skapas.

Mönstret [weak self]

```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 förlängd livstid

Swift 5.3+: bind om `self` i guard-satsen utan skuggning: ```swift { [weak self] in guard let self else { return } // 'self' is now strong within this block doA() doB() doC() } ```

När [unowned self] är säkert

```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() } ```

Fånga flera värden

```swift let base = 100 let multiplier = 2 let compute = { [base, multiplier] in base * multiplier } print(compute()) // 200 ``` Fånga flera värden i samma lista och separera dem med kommatecken.

Fångstlista med namngivna bindningar

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Användbart när en specifik ögonblicksbild ska fångas under ett nytt namn.

Escaping kontra non-escaping

• En `@escaping`-closure kan lagras och anropas efter att funktionen har returnerat → risk för cykler • En non-escaping-closure anropas innan funktionen returnerar → ingen risk för cykler ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Felsöka fångstproblem

Om du misstänker en cykel: 1. Lägg till `deinit { print("deallocated") }` i klassen 2. Navigera bort eller sätt instansen till nil 3. Om deinit inte skriver ut något → det finns en cykel Lägg sedan till `[weak self]` i klassens closures.

Snabb kontroll

Vad gör `[weak self]` i en fångstlista?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktiga punkter: • Closures fångar referenser som standard • Fångstlistan `[value]` kopierar värdetyper när closuren skapas • `[weak self]` — ingen stark referens, blir automatiskt nil, använd `guard let self` • `[unowned self]` — ingen stark referens, är inte nil-säker • `@escaping`-closures behöver fångstlistor; non-escaping-closures behöver det vanligtvis inte Kursen är klar! Nästa: funktionell programmering i Swift.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Closure-fångstlistor och [weak self]” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Closure-fångstlistor och [weak self]”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Closure-fångstlistor och [weak self]”?

Använd fångstlistor för att förhindra att closures fångar objekt med starka referenser. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Closure-fångstlistor och [weak self]”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Så räknar ARC referenser
Retain-cykler: orsaker och identifiering
weak- och unowned-referenser
Closure-fångstlistor och [weak self]

← Tillbaka till Swift Academy