Swift Academy · Lektion

Ordning för flera defer-block

Förstå defer-blockens omvända körordning.

Lektion 2 av 413 steg

Ordning för flera defer-block är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 2 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.

Flera defer-block

Ett scope kan innehålla flera defer-block. Alla körs när scopet avslutas.

func demo() {
    defer { print("A") }
    defer { print("B") }
    print("body")
}
demo()

Omvänd ordning (LIFO)

Uppskjutna block körs i omvänd ordning jämfört med deklarationen: det senast deklarerade körs först.

func order() {
    defer { print("1") }
    defer { print("2") }
    defer { print("3") }
    print("start")
}
order()

Varför LIFO

LIFO-ordningen speglar hur initiering och upprensning nästlas: den senaste initieringen ångras först.

func resources() {
    print("open A")
    defer { print("close A") }
    print("open B")
    defer { print("close B") }
    print("use both")
}
resources()

Mental modell: en stack

Tänk på defer-block som en stack: varje defer lägger en uppgift på stacken, och uppgifterna tas bort i omvänd ordning när scopet avslutas.

func stack() {
    defer { print("pop first-declared last") }
    defer { print("pop last-declared first") }
    print("push done")
}
stack()

defer och lokalt tillstånd

Varje defer fångar de omgivande variablerna och ser deras slutliga värden när det körs.

func state() {
    var x = 1
    defer { print("x is", x) }
    x = 42
}
state()

defer i en loop

Inuti en loop registrerar och kör varje iteration sina egna defer-block i LIFO-ordning i slutet av iterationen.

for i in 1...2 {
    defer { print("late", i) }
    defer { print("early", i) }
    print("body", i)
}

Kapslade scope

Defer-block körs när deras eget scope avslutas, så ett defer i ett inre block körs före ett i ett yttre block.

func nested() {
    defer { print("outer defer") }
    do {
        defer { print("inner defer") }
        print("inner body")
    }
    print("outer body")
}
nested()

Förutsägbar upprensning

LIFO-ordningen innebär att matchade par av öppning och stängning naturligt stängs i rätt ordning.

func files() {
    print("open log")
    defer { print("flush log") }
    print("open db")
    defer { print("disconnect db") }
    print("transaction")
}
files()

Läsa av ordningen

För att förutsäga utskriften läser du defer-blocken nerifrån och upp: det sista defer i scopet skriver ut först.

func quiz() {
    defer { print("one") }
    defer { print("two") }
    print("body runs first")
}
quiz()

Kombinera med return

Alla registrerade defer-block körs fortfarande i LIFO-ordning även när funktionen avslutas tidigt med return.

func early(_ skip: Bool) {
    defer { print("cleanup 1") }
    defer { print("cleanup 2") }
    if skip { return }
    print("full body")
}
early(true)

Bästa praxis

Deklarera varje upprensning direkt efter initieringen och lita på att LIFO-ordningen återställer dem korrekt.

func pattern() {
    print("acquire 1")
    defer { print("release 1") }
    print("acquire 2")
    defer { print("release 2") }
    print("work")
}
pattern()

Snabbkontroll

Testa ordningen för defer-block.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Flera defer-block körs i omvänd ordning (LIFO) när scopet avslutas: det senast deklarerade körs först. Detta återställer naturligt kapslade par av initiering och upprensning i rätt ordning, även vid en tidig retur.

func demo() {
    defer { print("1") }
    defer { print("2") }
    print("body")
}
demo()

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 ”Ordning för flera defer-block” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Ordning för flera defer-block”, 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 ”Ordning för flera defer-block”?

Förstå defer-blockens omvända körordning. 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 2 av 4.

Hur lång tid tar lektionen ”Ordning för flera defer-block”?

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

← Tillbaka till Swift Academy