Try-Catch: mohiyati, istisnolarni tutib olish konstruksiyasi va mobil ishlanmada qanday ishlaydi

Try-Catch nima?

Try-Catch — zamonaviy dasturlash tillarining ko'pchiligida mavjud bo'lgan tuzilgan istisno boshqaruvining asosiy konstruksiyasi. U uchta blokdan iborat: try (xavfli kodni bajarishga urinish), catch (istisnoni tutish va qayta ishlash) va ixtiyoriy finally (yakunlash). Konstruksiyaning g'oyasi biznes operatsiyalari mantiqini xatolarni boshqarish mantiqidan ajratish, kodni o'qish oson va bashorat qilinadigan qilishdir.

Kontseptsiya birinchi marta C++ tilida try/catch sifatida amalga oshirilgan, keyin Java, C#, Swift, Kotlin, Dart, Python, JavaScript va boshqa tillar tomonidan o'zlashtirilgan. Har bir til o'ziga xos xususiyatlarni qo'shadi: Swift-da catch bloki to'liq qamrab oluvchi bo'lishi kerak, Kotlin-da try-catch ifoda (expression) bo'lishi mumkin, Dart-da oqim resurslari uchun finally majburiy. Farqlarga qaramay, asosiy prinsip bir xil: xato paydo bo'lgan joyga imkon qadar yaqin boshqariladi, global emas.

Try-Catch dan foydalanish, ayniqsa, mobil ishlanmada dolzarbdir, bu erda tashqi omillar — tarmoq yo'qolishi, serverdan noto'g'ri javob, xotira yetishmasligi — doimiy ravishda sodir bo'ladi. To'g'ri istisno boshqaruvi dastur qulashining oldini oladi va to'g'ri UXni ta'minlaydi: foydalanuvchi dasturning to'satdan yopilishi o'rniga xato xabarini oladi. Google Android Kotlin Style Guide (2026) ga ko'ra, istisno tashlashi mumkin bo'lgan har bir funksiya uni try-catch orqali boshqarishi yoki imzoda throws e'lon qilishi kerak.

Try-Catch qanday ishlaydi

Try-catchning bajarilish mexanizmi stekni ochishga (stack unwinding) asoslangan. Try bloki ichida throw operatori (yoki tizim xatosi natijasida) istisno tashlanganda, normal bajarish oqimi darhol to'xtatiladi. Bajarish mos catch blokini qidirishda qo'ng'iroqlar stekida bir daraja yuqoriga harakatlanadi. Zamonaviy tillar tashlangan istisno turiga mos keladigan turdagi catchni qidiradi, turni moslashtirish mexanizmidan (type matching) foydalanib.

Agar mos catch topilsa, uning tanasi bajariladi, shundan so'ng bajarish butun try-catch-finally konstruksiyasidan keyin davom etadi. Catch topilmasa, istisno stekda yuqoriga ko'tariladi va yuqori darajada boshqarilishi mumkin — mobil ilovada foydalanuvchiga xato dialogini ko'rsatadigan global handlergacha. Istisno hech qayerda boshqarilmasa, dastur qulab tushadi. Aynan shuning uchun barcha mumkin bo'lgan istisno turlarini to'g'ri boshqarish dastur barqarorligi uchun juda muhimdir.

Asosiy konstruksiyaning sintaksisi

fun readUserData(): User {
    return try {
        val response = api.fetchUser()
        parseUser(response)
    } catch (e: IOException) {
        logError("Tarmoq xatosi", e)
        throw AppException("Ma'lumotlarni yuklab bo'lmadi")
    } catch (e: JsonParseException) {
        logError("Parsing xatosi", e)
        return User.default()
    } finally {
        closeLoadingIndicator()
    }
}

Kod avval API so'rovini bajarishga va javobni pars qilishga harakat qiladi. Agar IOException (tarmoq muammosi) yuz bersa, istisno loglanadi va AppException sifatida uzatiladi. Agar JsonParseException bo'lsa — standart foydalanuvchi qaytariladi. Finally bloki yuklash ko'rsatkichini yashirishni kafolatlaydi, ekranda UI komponentlarining oqib ketishining oldini oladi.

Swift-da Try-Catch

Swift-da xatolarni boshqarish Error protokoli (ilgari ErrorType) orqali amalga oshiriladi. Error ga mos keladigan har qanday tur throw operatori bilan tashlanishi mumkin. Xato tashlashi mumkin bo'lgan funksiya imzoda throws kalit so'zi bilan belgilanadi. Bunday funksiyani chaqirish try (aniq try-catch uchun), try? (ixtiyoriy natija) yoki try! (xatolarni boshqarmasdan majburiy bajarish) prefiksini talab qiladi.

enum NetworkError: Error {
    case noConnection
    case serverError(code: Int)
    case timeout
}

func fetchUser(id: Int) throws -> User {
    guard isConnected() else {
        throw NetworkError.noConnection
    }
    let data = try performRequest(path: "/users/\(id)")
    return try decodeUser(from: data)
}

do {
    let user = try fetchUser(id: 42)
    updateUI(user)
} catch NetworkError.noConnection {
    showOfflineAlert()
} catch let error as NetworkError {
    showError("Tarmoq " + error.localizedDescription)
} catch {
    showGenericError()
}

Enum NetworkError Error protokolini amalga oshiradi, uchta holatni belgilaydi: noConnection, kod bilan serverError va timeout. fetchUser funksiyasi throws bilan belgilangan: avval ulanishni tekshiradi, keyin so'rov va pars qilishni bajaradi. Do-catch blokida uchta catch turli stsenariylarni boshqaradi: spesifik noConnection holati, umumiy NetworkError turi va barcha boshqa xatolar. Bu muammo turiga qarab foydalanuvchiga turli xabarlarni ko'rsatish imkonini beradi.

Kotlin-da Try-Catch

Kotlin try-catch-finally-ni Java-dan meros qilib oldi, lekin muhim farq qo'shdi: Kotlin-da try-catch ifodadir (expression), ko'rsatma (statement) emas. Bu try bloki yoki catch blokining natijasini o'zgaruvchiga belgilash mumkin degani. Try blokidagi oxirgi ifoda muvaffaqiyat holatida natija bo'ladi, catch-dagi oxirgi ifoda — xato holatida. Agar xato hech bir catch tomonidan boshqarilmasa, istisno stekda yuqoriga uzatiladi.

sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Throwable) : Result<Nothing>()
}

fun loadData(): Result<List<Item>> {
    return try {
        val response = api.getItems()
        Result.Success(response.toList())
    } catch (e: HttpException) {
        Log.e("HTTP ", e)
        Result.Error(e)
    } catch (e: IOException) {
        Log.e("Tarmoq ", e)
        Result.Error(e)
    }
}

Misolda, sealed class Result muvaffaqiyatli javobni yoki xatoni o'rab oladi. loadData funksiyasi try-catch-ni ifoda sifatida ishlatadi: muvaffaqiyatda Result.Success qaytaradi, HttpException yoki IOException istisnosida — loglash bilan Result.Error. Bu yondashuv chaqiruvchi tomonga istisnosiz xatolarni boshqarish imkonini beradi — Result turi bo'yicha when-ifodasi orqali. Bu ayniqsa Jetpack Compose-da StateFlow va collectAsState orqali turli UI holatlarini (Loading, Success, Error) ko'rsatish uchun qulaydir.

Dart va Flutter-da Try-Catch

Dart try-catch-finally-ni Java-ga o'xshash sintaksis bilan qo'llab-quvvatlaydi, lekin o'zgaruvchi ko'rsatmasdan istisno turi bo'yicha filtrlash uchun on bandi qo'shilgan. Bu istisnoning o'zi kerak bo'lmaganda qulay — faqat uning turi muhim. Dart shuningdek ikki parametrli catch blokini qo'llab-quvvatlaydi: istisno obyekti va StackTrace, bu to'liq chaqiruv zanjirini loglash uchun foydali.

import 'dart:io';
import 'dart:convert';

class UserRepository {
    Future<User> fetchUser(String id) async {
        try {
            final client = HttpClient();
            final request = await client.getUrl(
                Uri.parse('https://api.example.com/users/$id')
            );
            final response = await request.close();
            final body = await response.transform(utf8.decoder).join();
            return User.fromJson(json.decode(body));
        } on SocketException catch (e, stackTrace) {
            log("No internet", e, stackTrace);
            throw AppException("Connection failed");
        } on FormatException {
            throw AppException("Invalid response format");
        } finally {
            client.close();
        }
    }
}

SocketException batafsil loglash uchun obyekt va StackTrace bilan tutib olinadi, so'ngra AppException sifatida uzatiladi. FormatException o'zgaruvchisiz tutib olinadi — javob formati noto'g'ri ekanligini bilish kifoya. Finally bloki HttpClient-ni yopishni kafolatlaydi, soket oqib ketishining oldini oladi. Flutter-da bu yondashuv, ayniqsa, Widget testi uchun muhim, bu erda State.initState-da boshqarilmagan istisnolar butun test sessiyasining qulashiga olib keladi.

Try-Catch ishlatishda odatiy xatolar

Hatto tajribali dasturchilar try-catch bilan ishlashda xotira oqib ketishiga, yashirin bug-larga yoki dasturning noto'g'ri xatti-harakatiga olib keladigan xatolarga yo'l qo'yadilar. Mobil ishlanmada eng keng tarqalgan beshta muammoni ko'rib chiqaylik.

Bo'sh catch bloki

Bo'sh catch — eng yomon amaliyotlardan biri. Istisno yutiladi, dastur noto'g'ri holatda ishlashda davom etadi va dasturchi muammodan xabarsiz qoladi. Har doim hech bo'lmaganda istisnoni loglang. Kotlin-da catch(e: Exception) { Log.e(...) }, Swift-da — catch { print($0) } dan foydalaning. Dart-da minimal qabul qilinadigan catch debugPrint chaqirishi yoki Crashlytics-ga yozishi kerak.

Juda keng catch

Barcha istisnolarni turlarga ajratmasdan catch (Exception e) bilan tutish kutilmagan xatolarni — NullPointerException, OutOfMemoryError, StackOverflowError — yashiradi. Faqat kutayotgan va boshqarishingiz mumkin bo'lgan turlarni tuting. Qolganlari uchun yuqoriga tarqalishiga ruxsat bering. Mobil ishlanmada IOException, TimeoutException, AuthException uchun spesifik catch foydalanuvchiga yanada mazmunli xabarlar beradi.

Finally-ni e'tiborsiz qoldirish

Resurslar — fayllar, soketlar, DB kursorlari, animatsiyalar — finally-da yoki use blokida (AutoCloseable) bo'shatilishi kerak. Dasturchilar ko'pincha istisno vaqtida resurslarni yopishni unutadilar, bu oqib ketishga olib keladi. Kotlin-da Closeable resurslari uchun .use { }, Swift-da — defer { }, Dart-da — async paketidan await using dan foydalaning. Finally bloki hatto catch ichida istisno tashlangan taqdirda ham bo'shatishni kafolatlaydi.

Iplar va korutinalardagi istisnolar

Asinxron kodda try-catch boshqa iplardan kelgan istisnolarni tutmaydi. Kotlin Coroutines-da CoroutineExceptionHandler yoki SupervisorJob dan foydalaning. Swift async/await-da — Task ichida do-catch. Flutter-da — global tutish uchun runZonedGuarded. Bu qoidaga e'tibor bermaslik production-da qiyin takrorlanadigan qulashlarning sababidir.

Istisno vaqtida UI-ni bloklash

Istisnoni boshqarish foydalanuvchi interfeysini noma'lum muddatga bloklamasligi kerak. Foydalanuvchiga aniq xabar ko'rsating va operatsiyani takrorlash imkoniyatini bering. Kotlin/Compose-da Retry tugmasi bilan Snackbar, Swift-da action bilan UIAlertController, Flutter-da action bilan SnackBar — tarmoq yoki server xatolari uchun minimal yetarli UX. Tuzatish imkoniyatisiz umumiy „Xato yuz berdi" dialoglaridan saqlaning.