Kotlin में त्रुटि प्रबंधन: try/catch और उन्नत तकनीकें

Kotlin में त्रुटि प्रबंधन: try/catch और इससे आगे

त्रुटि प्रबंधन विश्वसनीय और मजबूत कोड लिखने का एक अनिवार्य हिस्सा है। Kotlin में, Java की तरह, try/catch/finally का क्लासिक तंत्र मौजूद है, लेकिन भाषा अधिक आधुनिक, कार्यात्मक दृष्टिकोण भी प्रदान करती है। इस लेख में, हम Kotlin में अपवादों को संभालने के सभी तरीकों पर विस्तार से चर्चा करेंगे: बुनियादी try/catch से लेकर सुरुचिपूर्ण runCatching और शक्तिशाली Result और sealed class तक।

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

Kotlin में अपवाद प्रबंधन का मूल सिंटैक्स लगभग Java के समान है, लेकिन एक महत्वपूर्ण अंतर के साथ: try एक एक्सप्रेशन हो सकता है, यानी यह एक मान लौटा सकता है।

उदाहरण 1: एक एक्सप्रेशन के रूप में try

fun parseIntOrNull(input: String): Int? {    return try {        input.toInt()    } catch (e: NumberFormatException) {        null    }}

fun main() {    val result = parseIntOrNull("123")    println(result) // 123

    val badResult = parseIntOrNull("abc")    println(badResult) // null}

उदाहरण 2: एकाधिक catch ब्लॉक

fun processInput(input: String) {    try {        val number = input.toInt()        val result = 100 / number        println("परिणाम: $result")    } catch (e: NumberFormatException) {        println("त्रुटि: संख्या का गलत प्रारूप")    } catch (e: ArithmeticException) {        println("त्रुटि: शून्य से भाग")    } finally {        println("finally ब्लॉक हमेशा निष्पादित होता है")    }}

finally ब्लॉक हमेशा निष्पादित होता है - सफल निष्पादन और अपवाद होने दोनों पर। यह संसाधनों को मुक्त करने (फ़ाइलें बंद करना, कनेक्शन) के लिए सुविधाजनक है।

2. एल्विस ऑपरेटर (?:) और सुरक्षित कॉल

Kotlin null मानों को संभालने का एक सुरुचिपूर्ण तरीका प्रदान करता है, जो अक्सर भारी-भरकम try/catch संरचनाओं से बचने में मदद करता है।

उदाहरण: एल्विस ऑपरेटर के साथ सुरक्षित रूपांतरण

fun safeStringToInt(input: String): Int {    return input.toIntOrNull() ?: 0 // यदि null है, तो 0 लौटाएं}

fun main() {    println(safeStringToInt("42"))   // 42    println(safeStringToInt("abc"))  // 0}

toIntOrNull() फ़ंक्शन try/catch का Kotlin में निर्मित विकल्प है। यह अपवाद नहीं फेंकता, बल्कि त्रुटि होने पर null लौटाता है। एल्विस ऑपरेटर ?: डिफ़ॉल्ट मान प्रदान करता है।

3. कार्यात्मक दृष्टिकोण: runCatching और Result

आधुनिक Kotlin त्रुटि प्रबंधन के लिए कार्यात्मक शैली का उपयोग करने की सलाह देता है। मुख्य उपकरण runCatching और Result क्लास हैं।

उदाहरण: runCatching

import kotlin.Result

fun divide(a: Int, b: Int): Result<Int> {    return runCatching {        a / b    }}

fun main() {    val successResult = divide(10, 2)    val failureResult = divide(10, 0)

    // परिणाम को संभालना    successResult        .onSuccess { println("सफलता: $it") } // सफलता: 5        .onFailure { println("त्रुटि: ${it.message}") }

    failureResult        .onSuccess { println("सफलता: $it") }        .onFailure { println("त्रुटि: ${it.message}") } // त्रुटि: / by zero

    // डिफ़ॉल्ट के साथ मान प्राप्त करना    val value1 = successResult.getOrDefault(-1) // 5    val value2 = failureResult.getOrDefault(-1) // -1

    // परिणाम को रूपांतरित करना    val mappedResult = successResult.map { it * 2 } // Result(10)}

runCatching के लाभ:

• कोड घोषणात्मक और पढ़ने योग्य हो जाता है।
• मैन्युअल रूप से try/catch लिखने की आवश्यकता नहीं है।
• परिणाम को आसानी से जोड़ा, रूपांतरित और कॉल की श्रृंखला (.map) के साथ संभाला जा सकता है।