Swift Academy · Lekcja

defer z błędami i wczesnymi zwrotami

Zapewnianie sprzątania nawet podczas zgłaszania błędu lub wczesnego zwrotu.

defer z błędami i wczesnymi zwrotami to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 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.

defer wykonuje się przy return

Blok defer wykonuje się nawet wtedy, gdy funkcja kończy działanie przedwcześnie za pomocą return.

func check(_ value: Int) {
    defer { print("cleanup ran") }
    if value < 0 {
        print("negative, returning early")
        return
    }
    print("value is", value)
}
check(-5)

Sprzątanie na każdej ścieżce

Niezależnie od tego, która instrukcja return zostanie wykonana, odroczone sprzątanie wykona się dokładnie raz.

func classify(_ n: Int) {
    defer { print("done classifying") }
    if n == 0 { print("zero"); return }
    if n > 0 { print("positive"); return }
    print("negative")
}
classify(0)

defer wykonuje się przy throw

Gdy funkcja zgłasza wyjątek, zarejestrowane instrukcje defer nadal wykonują się podczas wycofywania zakresów.

enum MyError: Error { case bad }
func risky(_ fail: Bool) throws {
    defer { print("cleanup on the way out") }
    if fail { throw MyError.bad }
    print("no failure")
}
try? risky(true)

Połączenie return i throw

Niezależnie od tego, czy funkcja zwróci wynik normalnie, czy zgłosi wyjątek, ta sama instrukcja defer zostanie wykonana.

enum E: Error { case oops }
func op(_ flag: Bool) throws -> Int {
    defer { print("op finishing") }
    if flag { throw E.oops }
    return 42
}
let r = try? op(false)
print(r ?? -1)

Sprzątanie przed propagacją błędu

Instrukcja defer wykonuje się, zanim zgłoszony błąd dotrze do wywołującego, dzięki czemu zasoby zostają zwolnione wcześniej.

enum E: Error { case fail }
func load(_ broken: Bool) throws {
    print("open")
    defer { print("close") }
    if broken { throw E.fail }
    print("read")
}
do {
    try load(true)
} catch {
    print("caught:", error)
}

guard z defer

Typowy schemat to: pobranie zasobu, odroczone sprzątanie za pomocą defer, a następnie guard z przedwczesnymi zwrotami, które nadal uruchamiają sprzątanie.

func process(_ items: [Int]) {
    print("start")
    defer { print("finished") }
    guard !items.isEmpty else {
        print("nothing to do")
        return
    }
    print("processing", items.count, "items")
}
process([])

defer i pętle zgłaszające wyjątki

Instrukcja defer umieszczona w pętli wykonuje się na końcu każdej iteracji, nawet jeśli późniejsza instrukcja zgłosi wyjątek.

enum E: Error { case stop }
func loop() throws {
    for i in 1...3 {
        defer { print("end", i) }
        if i == 2 { throw E.stop }
        print("body", i)
    }
}
try? loop()

Kolejność przy przedwczesnym return

Wiele instrukcji defer nadal wykonuje się w kolejności LIFO przy przedwczesnym return.

func multi(_ skip: Bool) {
    defer { print("A") }
    defer { print("B") }
    if skip { return }
    print("body")
}
multi(true)

Rejestrowanie niepowodzeń

Używajcie defer do spójnego rejestrowania zakończenia lub niepowodzenia na wszystkich ścieżkach wyjścia.

enum E: Error { case bad }
func attempt(_ fail: Bool) throws {
    var success = false
    defer { print("attempt success:", success) }
    if fail { throw E.bad }
    success = true
}
try? attempt(true)

Przywracanie stanu przy throw

defer doskonale nadaje się do wycofywania tymczasowych zmian stanu, gdy operacja zgłosi wyjątek.

enum E: Error { case fail }
func transaction(_ fail: Bool) throws {
    var inProgress = true
    defer { inProgress = false; print("inProgress:", inProgress) }
    if fail { throw E.fail }
    print("committed")
}
try? transaction(true)

Dobra praktyka

Polegajcie na defer przy sprzątaniu, które musi wykonać się mimo przedwczesnych zwrotów i zgłoszonych błędów, aby żadna ścieżka wyjścia nie pozostawiła wyciekających zasobów.

enum E: Error { case x }
func safe(_ fail: Bool) throws {
    print("acquire")
    defer { print("release") }
    if fail { throw E.x }
    print("use")
}
try? safe(true)

Szybkie sprawdzenie

Sprawdźcie działanie defer wraz z błędami i zwrotami.

Podsumowanie

defer wykonuje się przy każdym opuszczeniu zakresu, także przy przedwczesnym return i zgłoszeniu błędu, przed propagacją tego błędu. Dzięki temu jest niezawodnym miejscem na sprzątanie i przywracanie stanu na wszystkich ścieżkach wyjścia, z zachowaniem kolejności LIFO.

func f(_ skip: Bool) {
    defer { print("cleanup") }
    if skip { return }
    print("work")
}
f(true)

Często zadawane pytania

Czy lekcja „defer z błędami i wczesnymi zwrotami” jest bezpłatna?

Tak — pełny tekst „defer z błędami i wczesnymi zwrotami” 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 „defer z błędami i wczesnymi zwrotami”?

Zapewnianie sprzątania nawet podczas zgłaszania błędu lub wczesnego zwrotu. Ć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 4 z 4.

Ile czasu zajmuje lekcja „defer z błędami i wczesnymi zwrotami”?

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