Do-Catch: bu nima, konstruksiya va Swift-da xatolarni boshqarish

Do-Catch nima?

Do-Catch — Swift-da do blokidan iborat konstruksiya bo'lib, uning ichida xato chiqarishi mumkin bo'lgan kod bajariladi va bir yoki bir nechta catch bloklari bu xatoni boshqaradi. Do bloki try bilan belgilangan throwing funksiyalarining chaqiruvlarini o'z ichiga oladi, catch bloklari esa xatoni turi bo'yicha moslashtiradi.

Swift Objective-C-dagi istisnolardan farq qiluvchi strukturali xatolarni boshqarish modelini qo'llaydi. Bu yerda xato stackni ochish bilan exception emas, balki Error protokoliga mos keladigan qiymatdir. Throw orqali xatoni chiqarish boshqaruvni stackni ochish xarajatisiz eng yaqin catch blokiga uzatadi.

Swift-ning asosiy xususiyati — boshqarishning aniqligi. Kompilyator throwing funksiyasini try, do-catch yoki muqobil mexanizmsiz (try?, try!) chaqirishga ruxsat bermaydi. Bu xato e'tibordan chetda qoladigan holatlarni istisno qiladi.

Swift-da xato modeli: Error protokoli va throwing funksiyalari

Swift-da xatolarni boshqarish asosida Error protokoli yotadi. Ushbu protokolga mos keladigan har qanday tip throw orqali chiqarilishi mumkin. Odatda xatolar Error tasdig'i bilan enum sifatida aniqlanadi.

Error protokoli

Error — bo'sh protokol (marker). Metodlarni amalga oshirishni talab qilmaydi, faqat muvofiqlikni tasdiqlashni talab qiladi. Swift kompilyatori statik tekshirish uchun Error-dan foydalanadi: throws bo'lgan funksiya faqat Error-ga mos keladigan qiymatni chiqarishi mumkin.

Throwing funksiyalari

throws bilan belgilangan funksiya try bilan chaqirilishi kerak. Agar bunday funksiya ichida throw sodir bo'lsa, boshqaruv chaqiruvchi do-catch-ga o'tadi. Agar xato chaqiruv zanjirining hech bir joyida boshqarilmasa, u yuqori darajaga uzatiladi.

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

Xatoni rethrows bilan uzatish

rethrows — parametr sifatida throwing-yopilishini qabul qiluvchi funksiyalar uchun modifikator. Agar uzatilgan yopilish xato chiqarmasa, rethrows funksiyasini trysiz chaqirish mumkin. Bu throwing va non-throwing yopilishlari bilan mos keladigan umumiy yuqori darajali funksiyalarni yozishga imkon beradi.

Do-Catch sintaksisi: bir nechta catch bloklari

Swift xato turi bo'yicha moslashtirish bilan bir nechta catch bloklarini qo'llab-quvvatlaydi. Bu Kotlin-dagi when yoki tur bo'yicha switch-ga o'xshaydi: birinchi mos keladigan catch bajariladi, qolganlari o'tkazib yuboriladi.

Tur bo'yicha moslashtirish

Har bir catch bloki ma'lum bir xato turi bilan moslashtirish namunasini o'z ichiga olishi mumkin. Swift bloklarni tartib bilan tekshiradi, shuning uchun aniqroq turlar umumiylardan oldin joylashishi kerak. Agar hech qanday namuna mos kelmasa, namunasiz catch bloki bajariladi.

Bir nechta turlarni boshqarish

Tip xavfsizligi Do-Catch har bir xatoni alohida boshqarish yoki pattern-matching-da vergul orqali bir blokda bir nechta turni birlashtirishga imkon beradi. Bu Objective-C ga xos bo'lgan, xato tahlili qaytarish kodi yoki domain va code tekshiruvi bilan NSError orqali amalga oshiriladigan hajmli if-else zanjirlarini yo'q qiladi.

Swift shuningdek catch where — qo'shimcha shart bilan moslashtirishni qo'llab-quvvatlaydi. Masalan, xatolarni ma'lum kod yoki matn bo'yicha filtrlash mumkin: catch URLError where error.code == .notConnectedToInternet. Bu boshqarish aniqligini saqlab, catch bloklari sonini kamaytiradi.

Throwing funksiyalarini tuzatish uchun Swift xatolar va istisnolar o'rtasidagi farqni ta'minlaydi. Swift xatosi — stackni ochishni talab qilmaydigan qaytariladigan qiymat. Objective-C istisnolari (@try/@catch) runtime darajasida ishlaydi va faqat jiddiy nosozliklar uchun ishlatiladi. Do-Catch aynan xatolarni boshqaradi, istisnolarni emas, bu uni bashorat qilinadigan va samarali qiladi.

Kutubxona va SDK-larni ishlab chiqishda throwing funksiyalari ommaviy shartnomaning bir qismi ekanligini yodda tutish muhim. Xato turi imzoda ko'rsatilmagan, shuning uchun funksiya qanday xatolarni chiqarishi mumkinligini sharhda yoki Result-ga o'xshash enum orqali hujjatlashtiring. Bu API foydalanuvchilariga amalga oshirishga qaramasdan to'g'ri catch bloklarini yozishga yordam beradi.

Asinxron dasturlash kontekstida async/await bilan Do-Catch callback hell muammosini hal qiladi. Ilgari Swift-da asinxron koddagi xatolarni boshqarish completion handler-da Error? tekshiruvi bilan ichma-ich yopilishlarni talab qilardi. async/await va Do-Catch bilan asinxron throwing kodi sinxron kabi ko'rinadi, bu har bir qadamda xatolarni boshqarish bilan murakkab so'rov zanjirlarini o'qish va saqlashni osonlashtiradi.

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("Noma'lum xato: \(error)")
}

Try variantlari: try, try?, try! va ulardan qachon foydalanish

Swift throwing funksiyalarini chaqirish uchun uchta variantni taklif qiladi: try, try? va try!. Har bir variant muayyan vazifani hal qiladi va o'z cheklovlariga ega.

try — standart chaqiruv

try do bloki ichida ishlatiladi va xato catch-da boshqariladi. Bu throwing funksiyalarini chaqirishning asosiy usulidir. Kompilyator try xato tutilishi mumkin bo'lgan kontekstda bo'lishini talab qiladi.

try? — Optional-ga aylantirish

try? throwing funksiyasining natijasini Optional-ga aylantiradi. Agar funksiya xato chiqarsa, try? nil qaytaradi, aks holda — muvaffaqiyatli qiymat bilan Optional. Xatoni e'tiborsiz qoldirish mumkin bo'lgan, ammo muvaffaqiyat ko'rsatkichi kerak bo'lgan chaqiruvlar uchun qulay.

try! — majburiy bajarish

try! xatolarni boshqarishni bostiradi. Agar throwing funksiyasi xato chiqarsa, ilova runtime xatosi bilan tugaydi. try! dan faqat xato mutlaqo mumkin emasligiga ishonchingiz komil bo'lganda foydalaning — masalan, o'rnatilgan resursni yuklashda.

// try? — xatoni e'tiborsiz qoldiramiz, nosozlikda nil olamiz
if let data = try? Data(contentsOf: url) {
    processData(data)
}

// try! — faqat xato mutlaqo mumkin bo'lmasa
let bundled = try! String(contentsOfFile: "Assets/default.txt")

// try — do-catch-da standart variant
do {
    let result = try performNetworkRequest()
    updateUI(result)
} catch {
    showError(error)
}

iOS dasturlashda Do-Catch: amaliy misollar

Do-Catch iOS dasturlashda tizim API-lari bilan ishlash uchun faol qo'llaniladi. Oddiy stsenariylarni ko'rib chiqaylik: fayl tizimi bilan ishlash, Core Data va tarmoq so'rovlari.

Fayl tizimi

FileManager-ning ko'plab metodlari throwing hisoblanadi. Do-Catch faylning yo'qligi, resursning bandligi yoki ruxsatlarning etishmasligini to'g'ri boshqarishga imkon beradi.

Codable bilan tarmoq so'rovlari

JSONDecoder orqali JSON-ni tahlil qilish — throwing operatsiyasi. Do-Catch dekodlash xatolari va tarmoq nosozliklarini alohida tutib, foydalanuvchiga aniq xato matnini taqdim etadi.

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

// Boshqarish bilan chaqiruv
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)
}

Do-Catch bilan ishlashda odatiy xatolar

Dasturchilar, ayniqsa boshqa tillardan kelganlar, Do-Catch dan foydalanishda xarakterli xatolarga yo'l qo'yadilar. Eng keng tarqalganlarini ko'rib chiqaylik.

• Unutilgan try — throwing funksiyasini trysiz chaqirish kompilyatsiya xatosiga olib keladi. Swift xatolarni yashirincha e'tiborsiz qoldirishga ruxsat bermaydi.
• Bo'sh catch — boshqaruvsiz catch bloki xatoni yashiradi. Har doim xatoni logga yozing yoki boshqaring, hatto imkonsiz bo'lsa ham.
• Moslashtirishsiz catch — barcha xatolar uchun bitta umumiy catch tip xavfsizligining afzalliklarini yo'qotadi. Boshqarishni bir nechta bloklar orqali turlarga bo'ling.
• try! dan haddan tashqari foydalanish — ishlab chiqarish kodida try! kutilmagan crash manbai. Faqat o'rnatilgan resurslar yoki testlar uchun foydalaning.