Throw/Throws — bu nima, istisno chiqarish operatorlari va mobil ishlanmada qanday ishlaydi

Throw va Throws nima?

Throw — bu dasturning bajarilish nuqtasida istisno yaratuvchi operator. Throw uchraganida, joriy bajarish oqimi darhol to'xtatiladi va boshqaruv chaqiruv stekidagi eng yaqin catch ishlovchisiga uzatiladi. Agar ishlovchi topilmasa, ilova xato bilan tugaydi. Mobil ishlanmada throw, joriy abstraksiya darajasida ishlov berib bo'lmaydigan xatolarni bildirish uchun ishlatiladi — masalan, noto'g'ri server javobi, tarmoq yo'qligi yoki noto'g'ri argumentlar.

Throws — funksiya imzosidagi modifikator (asosan Swiftda), funksiya xato chiqarishi mumkinligini e'lon qiladi. Bu Swiftdagi checked errors mexanizmining bir qismidir: chaqiruvchi tomon xatoni do-catch, try?, try! orqali ishlov berishi yoki o'z funksiyasini throws bilan belgilab keyingi uzatish (propagation) uchun belgilashi shart. Kotlin va Javada throws ham mavjud, ammo Kotlin uni ortiqcha deb hisoblaydi — Kotlindagi barcha istisnolar unchecked, ya'ni sintaktik majburlovsiz ishlov berilmasligi mumkin. Apple Swift Documentation (2026) ma'lumotlariga ko'ra, Swiftda throws — funksiya turida xato ehtimolini aniq e'lon qilishning yagona usuli bo'lib, bu API kontraktlarini dasturchi uchun shaffof qiladi.

Throw va throws o'rtasidagi farq asosiy: throw — bu harakat (runtime-da istisno chiqarish), throws — bu e'lon (compile-time kontrakt). Throws bo'lmagan funksiya throw ishlata olmaydi — Swift kompilyatori xato beradi. Throws bo'lgan funksiya throw ishlatmasligi mumkin — bu ruxsat etilgan, ammo ma'nosiz. Bunday ajratish throw/throws-ni API dizaynida kuchli vositaga aylantiradi, bunda xato kontrakti funksiya imzosida uni chaqirishdan oldin ko'rinadi.

Swiftda Throw

Swiftda throw operatori Error protokolini amalga oshiruvchi istalgan turni qabul qiladi. Ko'pincha bu turli xil xato turlari uchun case-lar bilan enum hisoblanadi. Swift Java uslubidagi checked exceptions-ni qo'llab-quvvatlamaydi — buning o'rniga funksiya turi throws bilan belgilanadi, ishlov berish esa chaqiruvchi tomonga yuklanadi. Bu Swiftda throw-ni yanada moslashuvchan, ammo dasturchi uchun mas'uliyatliroq qiladi.

Error protokoli va xato turlari

Error protokoliga mos keladigan istalgan tur throw orqali chiqarilishi mumkin. Ko'pincha dasturchilar oddiy xatolar uchun bog'langan qiymatlarga ega bo'lmagan case-lar yoki kontekst uzatish uchun associated values bilan enum ishlatadilar. Swift xato enum bo'lishini talab qilmaydi — Error-ni amalga oshiruvchi struct yoki class ishlatilishi mumkin, ammo enum ishlovchilar tomonida exhaustive switch tufayli afzalroqdir. Kompilyator barcha case-lar do-catchda ishlov berilganligini tekshiradi.

enum AuthError: Error {
    case invalidCredentials
    case tokenExpired
    case accountLocked(remainingMinutes: Int)
}

func login(username: String, password: String) throws -> Session {
    guard isValid(username) else {
        throw AuthError.invalidCredentials
    }
    let response = try api.authenticate(username, password)
    if response.isLocked {
        throw AuthError.accountLocked(
            remainingMinutes: response.lockDuration
        )
    }
    return Session(token: response.token)
}

AuthError uchta stsenariyni belgilaydi: noto'g'ri hisob ma'lumotlari, muddati o'tgan token va remainingMinutes bog'langan qiymati bilan bloklangan hisob. login funksiyasi throws sifatida e'lon qilingan — kompilyator uni try orqali chaqirishni talab qiladi. Funksiya ichida throw ikki joyda ishlatiladi: noto'g'ri username va bloklangan hisobda. Bog'langan qiymat accountLocked foydalanuvchiga aniq ma'lumotlarni uzatish imkonini beradi — blok ochilishiga necha daqiqa kutish kerak. Bu yondashuv bloklash holatini tekshirish uchun alohida API endpointlariga ehtiyojni yo'q qiladi.

Kotlinda Throw

Kotlinda throw — bu ko'rsatma emas, balki Nothing tipidagi ifoda (expression). Bu throw tayinlashning o'ng tomonida, when ifodalari ichida va elvis operatori ?: ichida ishlatilishi mumkinligini anglatadi. Nothing tipi — Kotlindagi barcha turlarning maxsus pastki turi bo'lib, throw-ni istalgan turdagi qiymat talab qilinadigan joylarda ishlatishga imkon beradi. Kompilyator throw-dan keyin bajarilish davom etmasligini tushunadi va bu holat uchun shax talab qilmaydi.

Nothing tipi va uning kompozitsiyadagi roli

Nothing — Kotlindagi barcha mumkin bo'lgan turlarning pastki turi bo'lgan noyob tip. Nothing qaytaruvchi funksiya (masalan, TODO()) hech qachon normal tarzda tugamaydi — yoki doim istisno chiqaradi yoki cheksiz siklga kiradi. Bu throw-ni qiymat talab qilinadigan joylarda ishlatish uchun tabiiy nomzod qiladi: elvis operatori, else-siz when, o'zgaruvchini ishga tushirish. Agar throw when shaxida bo'lsa, kompilyator shax Nothing-ga olib borishini tushunadi va bu shax uchun return yoki else talab qilmaydi.

data class Config(val apiUrl: String, val timeoutSec: Int)

class ConfigParser {
    fun parse(json: String): Config {
        val obj = JSONObject(json)
        val url = obj.optString("apiUrl")
            ?: throw IllegalArgumentException("apiUrl is required")
        val timeout = obj.optInt("timeoutSec", 30)
        return Config(url, timeout)
    }

    fun getErrorMessage(code: Int): String {
        return when (code) {
            404 -> "Not found"
            500 -> "Server error"
            else -> throw IllegalArgumentException("Unknown code: $code")
        }
    }
}

Birinchi misolda throw elvis operatori ?: ichida ishlatilgan: agar apiUrl maydoni JSONda bo'lmasa, throw ifodasi darhol bajarilishni to'xtatadi va IllegalArgumentException chiqaradi. Nothing tipi kompilyatorga o'ng tomon turini String sifatida chiqarishga imkon beradi (elvis String kutadi, throw Nothing tipiga ega, Nothing String ning pastki turi). Ikkinchi misolda throw when ifodasi ichida: agar kod ma'lum bo'lgan hech biriga mos kelmasa, istisno chiqariladi. Kompilyator throw-dan keyin kod erishib bo'lmasligini tushunadi, shuning uchun funksiyaning qaytaruvchi String turi buzilmaydi.

Funksiya imzosida Throws va rethrows

Swiftda throws parametrlar ro'yxatidan keyin va qaytariladigan tur o'qidan oldin ko'rsatiladi. Throws bo'lgan funksiya faqat boshqa throws funksiyalarini do-catch ichida yoki try? bilan chaqirishi mumkin. Agar throws funksiyasi xatoni ishlov bermasa, uni chaqiruvchi tomonga uzatadi. Swift shuningdek rethrows-ni qo'llab-quvvatlaydi — throws yopilishini (closure) qabul qiluvchi va uning xatosini o'tkazuvchi yuqori darajali funksiyalar uchun modifikator. Rethrows funksiya xatoni faqat uzatilgan yopilish chiqargan taqdirda chiqarishini anglatadi — funksiyaning o'zi xato yaratmaydi.

func mapValues<T>(
    _ array: [T],
    transform: (T) throws -> U
) rethrows -> [U] {
    var result = [U]()
    for element in array {
        result.append(try transform(element))
    }
    return result
}

// Throws-yopilishi bilan foydalanish
let parsed = try mapValues(jsonStrings) { str in
    let data = Data(str.utf8)
    return try JSONDecoder().decode(Item.self, from: data)
}

Rethrows mapValues funksiyasining moslashuvchan bo'lishiga imkon beradi: ham throws yopilishlarini, ham oddiy yopilishlarni qabul qiladi. Agar throws yopilishi uzatilsa, mapValues chaqiruvi try talab qiladi; agar oddiy bo'lsa — try kerak emas. Bu rethrows-ni Swift standart kutubxonasidagi map, filter, reduce kabi yuqori darajali funksiyalar uchun ideal qiladi. Apple tavsiyasi: throws yopilishlarini qabul qiluvchi va yagona xato manbai shu yopilish bo'lgan API-lar uchun rethrows dan foydalaning. Agar funksiya o'z xatosini chiqarishi mumkin bo'lsa, throws dan foydalaning.

Checked vs unchecked istisnolar

Swift throws checked exceptions-ga (Javadagi kabi) yaqinroq — chiqarilgan xatolar imzoda e'lon qilinadi. Kotlin va Dart unchecked istisnolardan foydalanadi — throws imzoda talab qilinmaydi. Farq asosiy: checked dasturchini ishlov berishga majbur qiladi (xavfsizroq, ammo uzunroq), unchecked erkinlik beradi, lekin xatoni ishlov berishni unutish xavfini oshiradi. Swift throws uchun checked, Kotlin esa barcha istisnolar uchun unchecked ni tanlagan. Ikkala yondashuvning afzalliklari bor: Swift til darajasida ishonchliroq, Kotlin esa yanada ixcham va funksional o'zgartirish zanjirlarida qulayroq.

Maxsus xato turlari

Mobil ilovalarda strukturaviy xato ishlov berish uchun asosiy Exception yoki Error o'rniga o'z xato turlarini yaratish tavsiya etiladi. Swiftda buning uchun Error protokoli bilan enum, Kotlinda — Throwable-dan (yoki Exception-dan) meros oluvchi sealed class, Dartda — Exception-dan meros oluvchi class ishlatiladi. Maxsus turlar xatolarni kategoriyalar bo'yicha guruhlash va bog'langan ma'lumotlarni uzatish imkonini beradi.

Maxsus xatolarni loyihalashda qoidaga rioya qiling: bitta xato — bitta stsenariy. Turli sabablarni String message bayrog'i bilan bitta turda birlashtirmang — har bir stsenariy uchun alohida case/lar/ost sinflar yarating. Bu chaqiruvchi tomonga har bir holatni satr taqqoslash orqali emas, balki pattern matching (when/switch) orqali ishlov berish imkonini beradi. Swiftda bu exhaustive checking beradi — kompilyator NetworkError enumining ba'zi case-i ishlov berilmagan bo'lsa ogohlantiradi.

Kotlinda maxsus xato namunasi

sealed class NetworkError(val message: String) : Throwable(message) {
    data class Timeout(val durationMs: Long) :
        NetworkError("Request timed out after ${durationMs}ms")
    data class HttpError(val code: Int, val body: String?) :
        NetworkError("HTTP $code")
    data class NoConnection(val cause: IOException) :
        NetworkError("No internet connection")
}

Sealed class NetworkError Throwable-dan (Kotlindagi standart istisno turi) meros oladi. Har bir ost sinf o'z maydonlariga ega data class: Timeout millisekundlarda vaqt tugash muddatini o'z ichiga oladi, HttpError — javob kodi va mazmuni, NoConnection — original IOException. Bunday dizayn har bir xatoni when orqali to'liq qamrab oluvchi tarzda ishlov berish imkonini beradi (yangi ost sinf qo'shganda, kompilyator barcha when ifodalarini yangilashga majbur qiladi).

Swiftda Try, try? va try!

Swift throws funksiyalarini chaqirish uchun uchta variantni taklif qiladi, har biri o'z xavfsizlik kontraktiga ega. try — standart usul: do-catch talab qiladi yoki throws funksiyasi ichida bo'lishni talab qiladi. try? xatoni nil-ga aylantiradi — natija ixtiyoriy bo'ladi, xato bo'lganda nil qaytariladi, tur T dan T? ga o'zgaradi. try! — ishlov bermasdan majburiy bajarish: agar xato chiqarilsa, ilova ishdan chiqadi. try! dan faqat xato mumkin emasligiga to'liq ishonchingiz komil bo'lganda foydalaning (masalan, aniq to'g'ri ma'lumotlar).

let configPath = Bundle.main.path(forResource: "config", ofType: "json")!

// try? — ixtiyoriy natija
let data = try? Data(contentsOf: URL(fileURLWithPath: configPath))
let json = try? JSONSerialization.jsonObject(with: data ?? Data())

// try! — kafolatlangan muvaffaqiyat (faqat ishonchingiz komil bo'lganda)
let decoder = JSONDecoder()
let defaultConfig = try! decoder.decode(
    Config.self,
    from: Config.defaultJSON
)

// try — standart ishlov berish
do {
    let user = try fetchUser()
    showUser(user)
} catch let error as NetworkError {
    showRetryAlert(error.message)
}

Misolda try! ilova bundle-iga o'rnatilgan aniq to'g'ri JSON uchun ishlatilgan — to'g'ri relizda dekodlash xatosi mumkin emas. try? konfiguratsiya faylini o'qish uchun qo'llaniladi — agar fayl yo'q bo'lsa yoki buzilgan bo'lsa, ilova ishdan chiqish o'rniga standart qiymatlardan foydalanadi. try do-catch ichida tarmoq so'rovlari uchun ishlatiladi, bu erda xato kutilgan va foydalanuvchi reaktsiyasini talab qiladi. Tavsiya: production kodida try! dan saqlaning — faqat qurilish bosqichida tekshirilgan doimiy ma'lumotlar uchun istisno qiling.