Kotlin में त्रुटि प्रबंधन: try/catch और उससे आगे — A से Z तक

Kotlin में त्रुटि प्रबंधन: try/catch और उससे आगे — A से Z तक

त्रुटि प्रबंधन किसी भी डेवलपर के प्रमुख कार्यों में से एक है। Kotlin में, अन्य आधुनिक भाषाओं की तरह, अपवाद स्थितियों को प्रबंधित करने के कई दृष्टिकोण हैं। इस लेख में, हम सभी मुख्य विधियों को समझेंगे: क्लासिक try/catch से लेकर Result, sealed class और Nothing के उपयोग वाली उन्नत तकनीकों तक। आप सीखेंगे कि विश्वसनीय और पठनीय कोड कैसे लिखें जो त्रुटियों को सही ढंग से संभालता है।

1. क्लासिक try/catch/finally ब्लॉक

Kotlin में अपवाद प्रबंधन का मूल तंत्र try/catch ब्लॉक है। यह Java की तरह ही काम करता है, लेकिन कुछ सुधारों के साथ। Kotlin में try एक एक्सप्रेशन है जो मान लौटा सकता है।

fun parseNumber(input: String): Int? {\n    return try {\n        input.toInt()\n    } catch (e: NumberFormatException) {\n        println("पार्सिंग त्रुटि: ${e.message}")\n        null // त्रुटि पर null लौटाएं\n    } finally {\n        println("finally ब्लॉक हमेशा निष्पादित होता है")\n    }\n}\n\nfun main() {\n    val result = parseNumber("123abc")\n    println(result) // null\n}

मुख्य विशेषताएं:

\n
• try को एक एक्सप्रेशन के रूप में उपयोग किया जा सकता है — try या catch ब्लॉक में अंतिम एक्सप्रेशन का परिणाम पूरे ब्लॉक का परिणाम बन जाता है।
\n
• finally ब्लॉक हमेशा निष्पादित होता है (भले ही कोई अपवाद हो या return हो)।
\n
• Kotlin में Java की तरह चेक किए गए अपवाद (checked exceptions) नहीं हैं — इससे कोड सरल हो जाता है।
\n

यह याद रखना महत्वपूर्ण है कि try/catch का अत्यधिक उपयोग कोड को कम पठनीय बनाता है। इसका उपयोग केवल वास्तव में अपवाद स्थितियों के लिए करें, प्रवाह नियंत्रण के लिए नहीं।

2. Result प्रकार और कार्यात्मक दृष्टिकोण

अधिक सुंदर त्रुटि प्रबंधन के लिए, Kotlin Result<T> प्रकार प्रदान करता है। यह एक sealed class है, जो या तो Success (परिणाम के साथ) या Failure (अपवाद के साथ) हो सकता है। यह कार्यात्मक शैली के लिए आदर्श है।

import kotlin.Result\n\nfun divide(a: Int, b: Int): Result<Int> {\n    return try {\n        Result.success(a / b)\n    } catch (e: ArithmeticException) {\n        Result.failure(e)\n    }\n}\n\nfun main() {\n    val result = divide(10, 0)\n    \n    // when के माध्यम से प्रबंधन\n    when (result) {\n        is Result.Success -> println("परिणाम: ${result.value}")\n        is Result.Failure -> println("त्रुटि: ${result.exception.message}")\n    }\n    \n    // या विधियों के माध्यम से\n    result.onSuccess { value -> println("सफलता: $value") }\n          .onFailure { e -> println("विफलता: ${e.message}") }\n    \n    // रूपांतरण\n    val mapped = result.map { it * 2 } // यदि failure है, तो failure ही रहेगा\n    println(mapped)\n}

Result के लाभ:

\n
• स्पष्ट रूप से दिखाता है कि फ़ंक्शन त्रुटि में समाप्त हो सकता है।
\n
• कॉल की श्रृंखला (map, flatMap, recover) की अनुमति देता है।
\n
• कॉल करने वाले कोड में try/catch की आवश्यकता नहीं है।
\n

हालांकि, Result संग्रह में संग्रहीत करने या कोरूटीन सीमाओं के पार स्थानांतरित करने के लिए अभिप्रेत नहीं है — इसके लिए sealed class का उपयोग करना बेहतर है।

3. विस्तृत त्रुटि प्रबंधन के लिए Sealed क्लासेज

जब विभिन्न प्रकार की त्रुटियों को अलग-अलग तरीके से संभालने की आवश्यकता होती है, तो sealed class एक आदर्श विकल्प है। आप त्रुटियों का एक पदानुक्रम बना सकते हैं और उन्हें व्यापक कवरेज के साथ when में संभाल सकते हैं।

sealed class NetworkResult<out T> {\n    data class Success<T>(val data: T) : NetworkResult<T>()\n    data class NetworkError(val code: Int, val message: String) : NetworkResult<Nothing>()\n    data class Timeout(val timeout