Kotlin में एक साथ कई अपवादों को कैसे पकड़ें: कोड के साथ पूरी गाइड

परिचय: यह विषय Stack Overflow पर क्यों धमाल मचाता है?

यदि आपने कभी Kotlin में लिखा है और कई अलग-अलग अपवादों को पकड़ने की आवश्यकता का सामना किया है, तो आप जानते हैं कि यह दर्दनाक हो सकता है। खासकर यदि आप Java से आए हैं, जहाँ मल्टी-कैच (catch (IOException | SQLException e)) Java 7 से एक मानक है। Kotlin में सब कुछ अलग है, और कई डेवलपर भ्रमित हो जाते हैं।

प्रश्न "How to catch many exceptions at the same time in Kotlin?" ने Stack Overflow पर हज़ारों व्यूज़ जुटाए हैं। और यह कोई संयोग नहीं है: त्रुटि प्रबंधन एक ऐसी चीज़ है जिसका सामना बिल्कुल हर कोई करता है। आज हम इस समस्या को हमेशा के लिए हल करेंगे।

इस लेख में आप जानेंगे:

\n
• Kotlin में मल्टी-कैच Java की तरह क्यों काम नहीं करता
\n
• कई अपवादों को खूबसूरती और संक्षिप्त रूप से कैसे पकड़ें
\n
• catch में when का उपयोग कब करें, और पुराने अच्छे if का कब
\n
• प्रोडक्शन कोड से वास्तविक उदाहरण
\n

चलिए शुरू करते हैं!

समस्या: मेरा मल्टी-कैच कहाँ है?

Java में आप बस लिखते हैं:

try {\n    riskyOperation()\n} catch (IOException | SQLException e) {\n    // समान रूप से प्रबंधित करें\n}\n

सुंदर, संक्षिप्त, स्पष्ट। लेकिन Kotlin में ऐसा सिंटैक्स नहीं है। यदि आप catch (IOException | SQLException e) लिखने का प्रयास करते हैं, तो कंपाइलर आपको 'नहीं' कहेगा।

क्यों? क्योंकि Kotlin ने स्पष्टता और शुद्धता के पक्ष में चुनाव किया। भाषा के डेवलपर्स ने निर्णय लिया कि वर्टिकल बार वाला मल्टी-कैच पूरी तरह से Kotlin की शैली नहीं है। लेकिन इसका मतलब यह नहीं है कि आप कई अपवादों को नहीं पकड़ सकते। बस यह अलग तरीके से किया जाता है।

आइए तीन मुख्य तरीकों पर नज़र डालें।

तरीका 1: एकाधिक catch ब्लॉक (सबसे स्पष्ट)

सबसे आसान तरीका है बस एक के बाद एक कई catch ब्लॉक जोड़ना। Kotlin इसे पूरी तरह से सपोर्ट करता है।

try {\n    val data = loadData()\n    processData(data)\n} catch (e: IOException) {\n    println("इनपुट-आउटपुट त्रुटि: ${e.message}")\n} catch (e: SQLException) {\n    println("डेटाबेस त्रुटि: ${e.message}")\n} catch (e: Exception) {\n    println("अज्ञात त्रुटि: ${e.message}")\n}\n

लाभ:

\n
• अत्यंत स्पष्ट - प्रत्येक अपवाद प्रकार को अलग से प्रबंधित किया जाता है
\n
• विभिन्न त्रुटियों के लिए अलग-अलग लॉजिक दी जा सकती है
\n
• शुरुआती लोगों द्वारा आसानी से पढ़ा जाता है
\n

नुकसान:

\n
• यदि प्रबंधन लॉजिक समान है तो बहुत अधिक कोड डुप्लिकेशन
\n
• 5+ अपवादों पर ब्लॉक भारी हो जाता है
\n

तरीका 2: when के साथ catch (सुरुचिपूर्ण और लचीला)

यहाँ Kotlin अपनी पूरी महिमा में प्रकट होता है। मल्टी-कैच के बजाय आप एक ही catch ब्लॉक के अंदर when का उपयोग कर सकते हैं।

try {\n    val result = fetchFromNetwork()\n    saveToDatabase(result)\n} catch (e: Exception) {\n    when (e) {\n        is IOException -> handleNetworkError(e)\n        is SQLException -> handleDatabaseError(e)\n        is SecurityException -> logAndNotify(e)\n        else -> throw e // यदि प्रबंधित करना नहीं जानते तो फेंक दें\n    }\n}\n

यह दृष्टिकोण एक वास्तविक खोज है। यह अनुमति देता है:

\n
• विभिन्न अपवादों को एक ही स्थान पर प्रबंधित करना
\n
• शर्तों की जाँच सहित when की सभी क्षमताओं का उपयोग करना
\n
• आसानी से नए अपवाद प्रकार जोड़ना
\n

यहाँ शर्तों के साथ एक अधिक उन्नत उदाहरण है:

try {\n    connectToService()\n} catch (e: Exception) {\n    when {\n        e is IOException && e.message?.contains("timeout") == true -> \n            println("कनेक्शन टाइमआउट, पुनः प्रयास कर रहे हैं")\n        e is IOException -> \n            println("नेटवर्क त्रुटि: ${e.message}")\n        e is SQLException && e.errorCode == 1045 -> \n            println("डेटाबेस प्रमाणीकरण त्रुटि")\n        else ->