Do-Catch: mi ez, konstrukció és hibakezelés Swiftben

Mi az a Do-Catch?

Do-Catch — egy konstrukció Swiftben, amely egy do blokkból áll, amelyben hibát dobó kód fut, és egy vagy több catch blokkból, amelyek ezt a hibát kezelik. A do blokk try-val jelölt throwing-függvényhívásokat tartalmaz, a catch blokkok pedig típus szerint illesztik a hibát.

A Swift a strukturált hibakezelés modelljét valósítja meg, amely eltér az Objective-C kivételeitől. Itt a hiba nem exception a verem felgöngyölítésével, hanem az Error protokollnak megfelelő érték. A throw segítségével történő hibadobás a vezérlést a legközelebbi catch blokkba irányítja a verem felgöngyölítésének többletköltsége nélkül.

A Swift kulcsjellemzője — a kezelés egyértelműsége. A fordító nem engedi throwing-függvény hívását try, do-catch vagy alternatív mechanizmus (try?, try!) nélkül. Ez kiküszöböli azokat a helyzeteket, amikor a hiba észrevétlen marad.

Hibamodell Swiftben: Error protokoll és throwing függvények

A hibakezelés alapja Swiftben az Error protokoll. Bármely típus, amely megfelel ennek a protokollnak, dobható throw segítségével. A hibákat általában enum-ként definiálják Error megerősítéssel.

Error protokoll

Error — üres protokoll (marker). Nem igényli metódusok implementálását, csak a megfelelés megerősítését. A Swift fordító az Error-t statikus ellenőrzésre használja: egy throws függvény csak az Error-nak megfelelő értéket dobhat.

Throwing függvények

Egy throws-szal jelölt függvényt try-val kell meghívni. Ha egy ilyen függvényen belül throw történik, a vezérlés a hívó do-catch-be kerül. Ha a hiba sehol a hívási láncban nincs kezelve, továbbítódik a magasabb szintre.

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)
}

Hiba továbbítása rethrows-szal

rethrows — módosító azon függvények számára, amelyek throwing-closure-t fogadnak paraméterként. Ha az átadott closure nem dob hibát, a rethrows függvény try nélkül is meghívható. Ez lehetővé teszi generikus magasabb rendű függvények írását, amelyek kompatibilisek throwing és non-throwing closure-ökkel.

Do-Catch szintaxis: több catch blokk

A Swift több catch blokkot támogat a hiba típusa szerinti illesztéssel. Ez hasonlít a Kotlin when-jére vagy a típus szerinti switch-re: az első egyező catch végrehajtódik, a többi kimarad.

Illesztés típus szerint

Minden catch blokk tartalmazhat egy illesztési mintát egy adott hibatípushoz. A Swift sorrendben ellenőrzi a blokkokat, ezért a specifikusabb típusoknak az általánosabbak előtt kell lenniük. Ha egy minta sem egyezik, a minta nélküli catch blokk hajtódik végre.

Több típus kezelése

Típusbiztonság A Do-Catch lehetővé teszi minden hiba külön kezelését vagy több típus egy blokkban történő kombinálását vesszővel a pattern-matching-ben. Ez kiküszöböli az Objective-C-re jellemző terjedelmes if-else láncokat, ahol a hibaelemzés visszatérési kóddal vagy NSError domain és code ellenőrzésével történt.

A Swift támogatja továbbá a catch where — illesztést kiegészítő feltétellel. Például szűrhetők a hibák konkrét kód vagy szöveg alapján: catch URLError where error.code == .notConnectedToInternet. Ez csökkenti a catch blokkok számát a kezelési pontosság megtartása mellett.

A throwing függvények hibakereséséhez a Swift különbséget tesz a hibák és kivételek között. A Swift hiba — visszaadott érték, amely nem igényli a verem felgöngyölítését. Az Objective-C kivételek (@try/@catch) futásidejű szinten működnek, és csak végzetes hibákhoz használatosak. A Do-Catch pontosan a hibákat kezeli, nem a kivételeket, ami kiszámíthatóvá és hatékonnyá teszi.

Könyvtárak és SDK-k fejlesztésekor fontos emlékezni, hogy a throwing függvények a nyilvános szerződés részét képezik. A hiba típusa nincs meghatározva az aláírásban, ezért dokumentálni kell, hogy a függvény milyen hibákat dobhat egy megjegyzésben vagy egy Result-szerű enum segítségével. Ez segíti az API felhasználóit a helyes catch blokkok megírásában anélkül, hogy a megvalósításba kellene nézniük.

Az aszinkron programozás kontextusában a Do-Catch async/await-tel megoldja a callback hell problémát. Korábban Swiftben az aszinkron kód hibakezelése beágyazott closure-öket igényelt Error? ellenőrzéssel a completion handler-ben. Az async/await és Do-Catch segítségével az aszinkron throwing kód szinkron kódnak tűnik, ami leegyszerűsíti a komplex kérésláncok olvasását és karbantartását hibakezeléssel minden lépésben.

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("Ismeretlen hiba: \(error)")
}

Try variációk: try, try?, try! és mikor használjuk őket

A Swift három variációt kínál a throwing függvények meghívására: try, try? és try!. Mindegyik variáció egy adott feladatot old meg és saját korlátokkal rendelkezik.

try — standard hívás

try a do blokkon belül használatos, és a hiba catch-ben kerül kezelésre. Ez a throwing függvények meghívásának elsődleges módja. A fordító megköveteli, hogy a try olyan kontextusban legyen, ahol a hiba elkapható.

try? — konvertálás Optional-lé

try? a throwing függvény eredményét Optional-lé alakítja. Ha a függvény hibát dob, a try? nil-t ad vissza, egyébként — Optional-t a sikeres értékkel. Hasznos olyan hívásoknál, ahol a hiba figyelmen kívül hagyható, de szükség van a siker jelzésére.

try! — kényszerített végrehajtás

try! elnyomja a hibakezelést. Ha a throwing függvény hibát dob, az alkalmazás futásidejű hibával fejeződik be. Használja a try!-t csak akkor, ha teljesen biztos abban, hogy a hiba lehetetlen — például beágyazott erőforrás betöltésekor.

// try? — figyelmen kívül hagyjuk a hibát, nil-t kapunk meghibásodáskor
if let data = try? Data(contentsOf: url) {
    processData(data)
}

// try! — csak ha a hiba garantáltan lehetetlen
let bundled = try! String(contentsOfFile: "Assets/default.txt")

// try — standard opció a do-catch-ben
do {
    let result = try performNetworkRequest()
    updateUI(result)
} catch {
    showError(error)
}

Do-Catch iOS fejlesztésben: gyakorlati példák

A Do-Catch aktívan használatos iOS fejlesztésben a rendszer API-kkal való munkához. Tekintsük át a tipikus forgatókönyveket: munkavégzés a fájlrendszerrel, Core Data és hálózati kérések.

Fájlrendszer

A FileManager számos metódusa throwing. A Do-Catch lehetővé teszi a fájl hiányának, az erőforrás foglaltságának vagy az engedélyek hiányának megfelelő kezelését.

Hálózati kérések Codable-lel

A JSON elemzése a JSONDecoder segítségével — throwing művelet. A Do-Catch külön kapja el a dekódolási hibákat és a hálózati meghibásodásokat, pontos hibaüzenetet adva a felhasználónak.

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)
}

// Hívás kezeléssel
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)
}

Gyakori hibák a Do-Catch használatakor

A fejlesztők, különösen a más nyelvekről érkezők, gyakran elkövetnek jellemző hibákat a Do-Catch használatakor. Tekintsük át a leggyakoribbakat.

• Elfelejtett try — throwing függvény hívása try nélkül fordítási hibát okoz. A Swift nem engedi a hibák implicit figyelmen kívül hagyását.
• Üres catch — kezelés nélküli catch blokk elrejti a hibát. Mindig naplózza vagy kezelje a hibát, még ha lehetetlennek is tűnik.
• Illesztés nélküli catch — egy általános catch minden hibához elveszi a típusbiztonság előnyeit. Válassza szét a kezelést típusok szerint több blokkon keresztül.
• A try! túlzott használata — a try! production kódban váratlan crash-ek forrása. Csak beágyazott erőforrásokhoz vagy tesztekhez használja.