Do-Catch: vad är det, konstruktion och felhantering i Swift

Vad är Do-Catch?

Do-Catch — är en konstruktion i Swift som består av ett do-block, inom vilket kod som kan kasta ett fel körs, och ett eller flera catch-block som hanterar detta fel. Do-blocket innehåller anrop till throwing-funktioner markerade med try, och catch-blocken matchar felet efter typ.

Swift implementerar modellen strukturerad felhantering, som skiljer sig från undantag i Objective-C. Här är ett fel inte ett exception med stackavveckling, utan ett värde som motsvarar protokollet Error. Att kasta ett fel via throw överför kontrollen till närmaste catch-block utan kostnad för stackavveckling.

En nyckelfunktion i Swift — explicit hantering. Kompilatorn tillåter inte anrop av en throwing-funktion utan try, do-catch eller alternativ mekanism (try?, try!). Detta eliminerar situationer där ett fel förblir oupptäckt.

Felmodell i Swift: Error-protokollet och throwing-funktioner

Grunden för felhantering i Swift är protokollet Error. Alla typer som motsvarar detta protokoll kan kastas via throw. Vanligtvis definieras fel som en enum med Error-bekräftelse.

Error-protokollet

Error — ett tomt protokoll (markör). Det kräver inte implementering av metoder, endast bekräftelse av överensstämmelse. Swift-kompilatorn använder Error för statisk kontroll: en funktion med throws kan bara kasta ett värde som motsvarar Error.

Throwing-funktioner

En funktion markerad med throws måste anropas med try. Om en throw inträffar inuti en sådan funktion överförs kontrollen till den anropande do-catch. Om felet inte hanteras någonstans i anropskedjan propageras det till en högre nivå.

enum FileError: Error {
    case notFound
    case permissionDenied
    case corrupted(String)
}

func readFile(path: String) throws -> String {
    guard FileManager.default.fileExists(atPath: path) else {
        throw FileError.notFound
    }
    return try String(contentsOfFile: path)
}

Felpropagering med rethrows

rethrows — en modifierare för funktioner som tar en throwing-closure som parameter. Om den skickade closure inte kastar ett fel kan rethrows-funktionen anropas utan try. Detta gör det möjligt att skriva generiska högre ordningens funktioner som är kompatibla med throwing och non-throwing closures.

Do-Catch-syntax: flera catch-block

Swift stöder flera catch-block med matchning efter feltyp. Detta liknar when i Kotlin eller switch efter typ: den första matchande catch körs, resten hoppas över.

Matchning efter typ

Varje catch-block kan innehålla ett matchmönster för en specifik feltyp. Swift kontrollerar blocken i ordning, så mer specifika typer bör placeras före allmänna. Om inget mönster matchar körs catch-blocket utan mönster.

Hantera flera typer

Typsäkerhet Do-Catch gör det möjligt att hantera varje fel separat eller kombinera flera typer i ett block via kommatecken i pattern-matching. Detta eliminerar omfattande if-else-kedjor som är karakteristiska för Objective-C, där felanalys gjordes via returkod eller NSError med kontroll av domain och code.

Swift stöder också catch where — matchning med ett extra villkor. Man kan till exempel filtrera fel efter specifik kod eller text: catch URLError where error.code == .notConnectedToInternet. Detta minskar antalet catch-block samtidigt som precisionen i hanteringen bibehålls.

För felsökning av throwing-funktioner tillhandahåller Swift skillnaden mellan fel och undantag. Ett Swift-fel är ett returnerat värde som inte kräver stackavveckling. Objective-C-undantag (@try/@catch) fungerar på runtime-nivå och används endast för allvarliga fel. Do-Catch hanterar just fel, inte undantag, vilket gör det förutsägbart och prestandaeffektivt.

Vid utveckling av bibliotek och SDK är det viktigt att komma ihåg att throwing-funktioner är en del av det offentliga kontraktet. Feltypen specificeras inte i signaturen, så dokumentera vilka fel funktionen kan kasta i en kommentar eller via en Result-liknande enum. Detta hjälper API-användare att skriva korrekta catch-block utan att behöva titta på implementeringen.

I sammanhanget av asynkron programmering löser Do-Catch med async/await callback hell-problemet. Tidigare i Swift krävde felhantering i asynkron kod kapslade closures med Error?-kontroll i completion handler. Med async/await och Do-Catch ser asynkron throwing-kod ut som synkron kod, vilket förenklar läsning och underhåll av komplexa kedjor med felhantering vid varje steg.

do {
    let content = try readFile(path: "/data/config.json")
    process(content)
} catch FileError.notFound {
    createDefaultConfig()
} catch FileError.permissionDenied {
    requestAccess()
} catch FileError.corrupted(let detail) {
    logCorruption(detail)
} catch {
    print("Okänt fel: \(error)")
}

Try-varianter: try, try?, try! och när de ska användas

Swift erbjuder tre varianter för att anropa throwing-funktioner: try, try? och try!. Varje variant löser en specifik uppgift och har sina begränsningar.

try — standardanrop

try används inuti ett do-block och felet hanteras i catch. Detta är det primära sättet att anropa throwing-funktioner. Kompilatorn kräver att try befinner sig i en kontext där felet kan fångas.

try? — konvertering till Optional

try? konverterar resultatet av en throwing-funktion till Optional. Om funktionen kastar ett fel returnerar try? nil, annars — Optional med ett lyckat värde. Användbart för anrop där felet kan ignoreras men en indikator på framgång behövs.

try! — tvångsutförande

try! undertrycker felhantering. Om throwing-funktionen kastar ett fel avslutas applikationen med ett runtime-fel. Använd try! endast när du är absolut säker på att felet är omöjligt — till exempel vid inläsning av en inbäddad resurs.

// try? — ignorerar felet, får nil vid fel
if let data = try? Data(contentsOf: url) {
    processData(data)
}

// try! — endast om felet är garanterat omöjligt
let bundled = try! String(contentsOfFile: "Assets/default.txt")

// try — standardalternativ i do-catch
do {
    let result = try performNetworkRequest()
    updateUI(result)
} catch {
    showError(error)
}

Do-Catch i iOS-utveckling: praktiska exempel

Do-Catch används aktivt i iOS-utveckling för arbete med system-API:er. Låt oss titta på typiska scenarier: arbete med filsystemet, Core Data och nätverksförfrågningar.

Filsystem

Många metoder i FileManager är throwing. Do-Catch gör det möjligt att korrekt hantera saknade filer, upptagna resurser eller otillräckliga behörigheter.

Nätverksförfrågningar med Codable

JSON-tolkning via JSONDecoder — en throwing-operation. Do-Catch fångar avkodningsfel och nätverksfel separat och ger användaren exakt feltext.

struct User: Codable {
    let id: Int
    let name: String
}

func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// Anrop med hantering
do {
    let user = try await fetchUser(id: 42)
    showUser(user)
} catch let error as URLError {
    showNetworkAlert(error)
} catch let error as DecodingError {
    showParseError(error)
} catch {
    showGenericError(error)
}

Vanliga misstag vid arbete med Do-Catch

Utvecklare, särskilt de som kommer från andra språk, gör ofta karakteristiska misstag när de använder Do-Catch. Låt oss titta på de vanligaste.

• Glömd try — anrop av en throwing-funktion utan try leder till kompileringsfel. Swift tillåter inte implicit ignorering av fel.
• Tom catch — ett catch-block utan hantering döljer felet. Logga eller hantera alltid felet, även om det verkar omöjligt.
• Catch utan matchning — en enda generell catch för alla fel berövar fördelarna med typsäkerhet. Separera hanteringen efter typ genom flera block.
• Överdriven användning av try! — try! i produktionskod är en källa till oväntade krascher. Använd endast för inbäddade resurser eller tester.