Swift Academy · Lektion

Operatorer för felhantering

Återhämta er med catch, retry och replaceError.

Lektion 3 av 413 steg

Operatorer för felhantering är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 3 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.

Fel i Combine

Combine-publishers har en Failure-typ. När en publisher misslyckas avslutas strömmen – inga fler värden skickas ut. För att bygga robusta pipelines behöver du operatorer som hanterar, omvandlar eller återhämtar sig från fel.

Failure-typen

Varje publisher deklarerar en Output och en Failure. En pipeline kompilerar bara när feltyperna överensstämmer, så operatorer som ändrar fel är vanliga.

let publisher: AnyPublisher<Data, URLError> = apiClient.request()
// Output = Data, Failure = URLError

catch

catch fångar upp ett fel och ersätter den felande publishern med en ny. På så sätt kan du tillhandahålla reservvärden när något går fel.

apiClient.fetchUser()
    .catch { error in
        Just(User.guest)
    }
    .sink { user in
        print("Got", user.name)
    }
    .store(in: &cancellables)

replaceError

replaceError(with:) är en enklare variant av catch: den ersätter alla fel med ett enda reservvärde och slutför sedan utan fel.

apiClient.fetchCount()
    .replaceError(with: 0)
    .sink { count in
        self.badge.text = "\(count)"
    }
    .store(in: &cancellables)

retry

retry(n) prenumererar på publishern uppströms på nytt upp till n gånger när den misslyckas. Den passar perfekt för tillfälliga nätverksfel.

apiClient.fetchData()
    .retry(3)
    .sink(receiveCompletion: { print($0) },
          receiveValue: { print($0) })
    .store(in: &cancellables)

Kombinera retry och catch

Ett vanligt robust mönster: försök med retry några gånger och använd sedan catch som reservlösning om alla försök misslyckas.

apiClient.fetchData()
    .retry(2)
    .catch { _ in
        Just(Data())
    }
    .sink { data in
        self.process(data)
    }
    .store(in: &cancellables)

mapError

mapError omvandlar en feltyp till en annan. Det är avgörande för att förena olika fel uppströms till en enda feltyp på appnivå.

enum AppError: Error { case network }

apiClient.request()
    .mapError { _ in AppError.network }
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

Varför mapError är viktigt

När publishers kombineras måste deras Failure-typer matcha. mapError normaliserar fel som inte matchar, så att operatorer som merge och zip kan kompileras och så att sink hanterar en enda feltyp.

setFailureType

Vissa publishers, som Just, har en Never-feltyp. setFailureType(to:) gör det möjligt att kombinera dem med publishers som kan misslyckas.

Just(42)
    .setFailureType(to: AppError.self)
    .merge(with: failablePublisher)
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

Hantera slutförande

I sink anger completion-closuren om strömmen slutfördes eller misslyckades. Inspektera den för att reagera på fel som inte återställdes uppströms.

publisher.sink(
    receiveCompletion: { completion in
        if case .failure(let error) = completion {
            self.showAlert(error)
        }
    },
    receiveValue: { value in
        self.update(value)
    }
).store(in: &cancellables)

Utforma robusta pipelines

Bästa praxis för felhantering:

Använd retry vid tillfälliga fel
Använd catch eller replaceError som reservlösningar
Använd mapError för att förena feltyper
Hantera alltid fallet med fel i sink

Snabbtest

Testa era kunskaper om felhantering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er Combine-operatorer för felhantering:

catch / replaceError — tillhandahåller reservlösningar
retry — försöker igen vid fel
mapError / setFailureType — förenar feltyper

Tillsammans gör de det möjligt att bygga pipelines som hanterar fel på ett kontrollerat sätt i stället för att stanna vid det första felet.

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 ”Operatorer för felhantering” gratis?

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

Återhämta er med catch, retry och replaceError. 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 3 av 4.

Hur lång tid tar lektionen ”Operatorer för felhantering”?

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