Do-Catch: ano ito, konstruksyon at paghawak ng error sa Swift

Ano ang Do-Catch?

Do-Catch — ay isang konstruksyon sa Swift na binubuo ng isang bloke na do, kung saan isinasagawa ang code na maaaring magtapon ng error, at isa o higit pang mga bloke na catch na humahawak sa error na ito. Ang bloke na do ay naglalaman ng mga tawag sa throwing-function na minarkahan ng try, at ang mga bloke na catch ay tumutugma sa error ayon sa tipo.

Ang Swift ay nagpapatupad ng modelo ng nakabalangkas na paghawak ng error, na naiiba sa mga exception sa Objective-C. Dito ang error ay hindi isang exception na may pag-unal ng stack, kundi isang halaga na tumutugma sa protocol na Error. Ang pagtapon ng error sa pamamagitan ng throw ay naglilipat ng kontrol sa pinakamalapit na bloke na catch nang walang overhead ng pag-unal ng stack.

Ang pangunahing tampok ng Swift — pagiging malinaw ng paghawak. Hindi pinapayagan ng compiler na tawagin ang throwing-function nang walang try, do-catch o alternatibong mekanismo (try?, try!). Tinatanggal nito ang mga sitwasyon kung saan ang isang error ay nananatiling hindi napapansin.

Modelo ng error sa Swift: protocol na Error at throwing function

Ang pundasyon ng paghawak ng error sa Swift ay ang protocol na Error. Anumang tipo na tumutugma sa protocol na ito ay maaaring itapon sa pamamagitan ng throw. Karaniwan ang mga error ay tinutukoy bilang enum na may kumpirmasyon ng Error.

Protocol na Error

Error — isang walang laman na protocol (marker). Hindi ito nangangailangan ng pagpapatupad ng mga pamamaraan, kundi kumpirmasyon lamang ng pagsunod. Ginagamit ng Swift compiler ang Error para sa static na pagsusuri: isang function na may throws ay maaari lamang magtapon ng halaga na tumutugma sa Error.

Throwing function

Ang isang function na minarkahan ng throws ay dapat tawagin gamit ang try. Kung sa loob ng naturang function ay maganap ang throw, ang kontrol ay ililipat sa tumatawag na do-catch. Kung ang error ay hindi hinawakan kahit saan sa chain ng tawag, ito ay ipapasa sa mas mataas na antas.

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

Pagpapalaganap ng error na rethrows

rethrows — isang modifier para sa mga function na tumatanggap ng throwing-closure bilang parameter. Kung ang ipinadalang closure ay hindi nagtatapon ng error, ang rethrows function ay maaaring tawagin nang walang try. Ito ay nagpapahintulot sa pagsulat ng mga generic na higher-order function na katugma sa throwing at non-throwing closures.

Sintaks ng Do-Catch: maramihang bloke ng catch

Sinusuportahan ng Swift ang maramihang bloke ng catch na may pagtutugma ayon sa tipo ng error. Ito ay kahawig ng when sa Kotlin o switch ayon sa tipo: ang unang tugmang catch ay isinasagawa, ang iba ay nilalaktawan.

Pagtutugma ayon sa tipo

Ang bawat bloke ng catch ay maaaring maglaman ng pattern ng pagtutugma sa isang partikular na tipo ng error. Sinusuri ng Swift ang mga bloke nang sunud-sunod, kaya ang mas tiyak na mga tipo ay dapat na nasa unahan ng mga pangkalahatan. Kung walang pattern na tugma, ang bloke ng catch na walang pattern ay isasagawa.

Paghawak ng maramihang tipo

Kaligtasan ng tipo ng Do-Catch ay nagpapahintulot sa paghawak ng bawat error nang hiwalay o pagsasama-sama ng maramihang tipo sa isang bloke sa pamamagitan ng kuwit sa pattern-matching. Tinatanggal nito ang mga masalimuot na chain ng if-else na katangian ng Objective-C, kung saan ang pagsusuri ng error ay ginagawa sa pamamagitan ng return code o NSError na may pagsusuri ng domain at code.

Sinusuportahan din ng Swift ang catch where — pagtutugma na may karagdagang kondisyon. Halimbawa, maaaring i-filter ang mga error ayon sa partikular na code o teksto: catch URLError where error.code == .notConnectedToInternet. Ito ay nagbabawas ng bilang ng mga bloke ng catch habang pinapanatili ang katumpakan ng paghawak.

Para sa pag-debug ng throwing function, ang Swift ay nagbibigay ng pagkakaiba sa pagitan ng error at exception. Ang error ng Swift — ay isang ibinalik na halaga na hindi nangangailangan ng pag-unal ng stack. Ang mga exception ng Objective-C (@try/@catch) ay gumagana sa antas ng runtime at ginagamit lamang para sa nakamamatay na pagkabigo. Ang Do-Catch ay humahawak nang eksakto ng mga error, hindi ng mga exception, na ginagawang mahuhulaan at mahusay ito.

Sa pag-develop ng mga library at SDK, mahalagang tandaan na ang throwing function ay bahagi ng pampublikong kontrata. Ang tipo ng error ay hindi tinutukoy sa lagda, kaya idokumento kung anong mga error ang maaaring itapon ng function sa isang komento o sa pamamagitan ng enum na kahawig ng Result. Ito ay tumutulong sa mga gumagamit ng API na magsulat ng tamang mga bloke ng catch nang hindi kinakailangang tumingin sa implementasyon.

Sa konteksto ng asynchronous na programming, ang Do-Catch na may async/await ay lumulutas sa problema ng callback hell. Dati sa Swift, ang paghawak ng error sa asynchronous na code ay nangangailangan ng nested closures na may pagsusuri ng Error? sa completion handler. Sa async/await at Do-Catch, ang asynchronous na throwing code ay parang synchronous, na nagpapasimple sa pagbasa at pagpapanatili ng mga kumplikadong chain ng request na may paghawak ng error sa bawat hakbang.

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("Hindi kilalang error: \(error)")
}

Mga variant ng try: try, try?, try! at kailan gagamitin ang mga ito

Ang Swift ay nag-aalok ng tatlong variant ng pagtawag sa throwing-function: try, try? at try!. Ang bawat variant ay lumulutas ng isang tiyak na gawain at may sariling mga limitasyon.

try — karaniwang tawag

try ay ginagamit sa loob ng do-bloke, at ang error ay hinahawakan sa catch. Ito ang pangunahing paraan ng pagtawag sa throwing-function. Ang compiler ay nangangailangan na ang try ay nasa konteksto kung saan ang error ay maaaring masalo.

try? — conversion sa Optional

try? ay nagko-convert ng resulta ng throwing-function sa Optional. Kung ang function ay nagtapon ng error, ang try? ay nagbabalik ng nil, kung hindi — Optional na may matagumpay na halaga. Kapaki-pakinabang para sa mga tawag kung saan ang error ay maaaring balewalain, ngunit kailangan ang indicator ng tagumpay.

try! — sapilitang pagpapatupad

try! ay pinipigilan ang paghawak ng error. Kung ang throwing-function ay nagtapon ng error, ang aplikasyon ay magtatapos na may error sa runtime. Gamitin ang try! lamang kapag ikaw ay lubos na sigurado na ang error ay imposible — halimbawa, kapag naglo-load ng naka-embed na resource.

// try? — binabalewala ang error, nakakakuha ng nil sa pagkabigo
if let data = try? Data(contentsOf: url) {
    processData(data)
}

// try! — lamang kung ang error ay garantisadong imposible
let bundled = try! String(contentsOfFile: "Assets/default.txt")

// try — karaniwang opsyon sa do-catch
do {
    let result = try performNetworkRequest()
    updateUI(result)
} catch {
    showError(error)
}

Do-Catch sa pag-develop ng iOS: praktikal na mga halimbawa

Ang Do-Catch ay aktibong ginagamit sa pag-develop ng iOS para sa pagtatrabaho sa mga system API. Isaalang-alang natin ang mga tipikal na senaryo: pagtatrabaho sa file system, Core Data at mga network request.

File system

Maraming pamamaraan ng FileManager ay throwing. Ang Do-Catch ay nagpapahintulot ng tamang paghawak ng kawalan ng file, pagkaabala ng resource o kakulangan ng pahintulot.

Mga network request na may Codable

Ang pag-parse ng JSON sa pamamagitan ng JSONDecoder — isang throwing operation. Ang Do-Catch ay sumasalo ng mga error sa pag-decode at mga pagkabigo sa network nang hiwalay, na nagbibigay sa gumagamit ng tiyak na teksto ng error.

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

// Tawag na may paghawak
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)
}

Mga karaniwang pagkakamali sa pagtatrabaho sa Do-Catch

Ang mga developer, lalo na ang mga lumilipat mula sa ibang mga wika, ay madalas na nagkakamali sa paggamit ng Do-Catch. Isaalang-alang natin ang pinakakaraniwan.

• Nakalimutang try — ang pagtawag sa throwing-function nang walang try ay nagdudulot ng error sa compilation. Hindi pinapayagan ng Swift ang implicit na pagbalewala ng mga error.
• Walang laman na catch — isang bloke ng catch na walang paghawak ay nagtatago ng error. Palaging i-log o hawakan ang error, kahit na tila imposible ito.
• Catch na walang pagtutugma — isang pangkalahatang catch para sa lahat ng error ay nag-aalis ng mga pakinabang ng kaligtasan ng tipo. Paghiwalayin ang paghawak ayon sa tipo sa pamamagitan ng maramihang bloke.
• Labis na paggamit ng try! — ang try! sa production code ay pinagmumulan ng hindi inaasahang crash. Gamitin lamang para sa naka-embed na resources o pagsubok.