Swift Academy · Lekcja

Kolejność wielu bloków defer

Poznanie odwrotnej kolejności wykonywania instrukcji defer.

Kolejność wielu bloków defer to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wiele instrukcji defer

Zakres może zawierać kilka bloków defer. Wszystkie wykonują się przy opuszczaniu zakresu.

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

Kolejność odwrotna (LIFO)

Odroczone bloki wykonują się w odwrotnej kolejności deklaracji: ostatni zadeklarowany wykonuje się jako pierwszy.

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

Dlaczego LIFO

Kolejność LIFO odzwierciedla sposób zagnieżdżania konfiguracji i sprzątania: ostatnia wykonana konfiguracja jest wycofywana jako pierwsza.

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

Model stosu

Wyobraźcie sobie instrukcje defer jako stos: każda dodaje zadanie, a po zakończeniu zakresu zadania są zdejmowane w odwrotnej kolejności.

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

Instrukcje defer a stan lokalny

Każda instrukcja defer przechwytuje otaczające zmienne i widzi ich końcowe wartości w chwili wykonania.

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

Instrukcje defer w pętli

Wewnątrz pętli każda iteracja rejestruje i wykonuje własne instrukcje defer w kolejności LIFO na końcu tej iteracji.

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

Zagnieżdżone zakresy

Instrukcje defer wykonują się po opuszczeniu własnego zakresu, dlatego defer z wewnętrznego bloku wykonuje się przed defer z bloku zewnętrznego.

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

Przewidywalne sprzątanie

Kolejność LIFO sprawia, że odpowiadające sobie pary otwarcia i zamknięcia są naturalnie zamykane we właściwej kolejności.

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

Odczytywanie kolejności

Aby przewidzieć wynik, czytajcie instrukcje defer od dołu do góry: ostatnia instrukcja defer w zakresie wypisuje wynik jako pierwsza.

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

Połączenie z return

Wszystkie zarejestrowane instrukcje defer nadal wykonują się w kolejności LIFO, nawet gdy funkcja kończy działanie przedwcześnie.

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

Dobra praktyka

Deklarujcie każde sprzątanie bezpośrednio po konfiguracji i polegajcie na kolejności LIFO, aby poprawnie je wycofać.

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

Szybkie sprawdzenie

Sprawdźcie kolejność wykonywania defer.

Podsumowanie

Wiele bloków defer wykonuje się w odwrotnej kolejności (LIFO) przy opuszczaniu zakresu: ostatni zadeklarowany wykonuje się jako pierwszy. Dzięki temu zagnieżdżone pary konfiguracji i sprzątania są naturalnie wycofywane we właściwej kolejności, nawet przy przedwczesnym return.

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

Często zadawane pytania

Czy lekcja „Kolejność wielu bloków defer” jest bezpłatna?

Tak — pełny tekst „Kolejność wielu bloków defer” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Kolejność wielu bloków defer”?

Poznanie odwrotnej kolejności wykonywania instrukcji defer. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Kolejność wielu bloków defer”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy