बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala · पाठ

Future में त्रुटि प्रबंधन

अतुल्यकालिक `Future` गणनाओं के भीतर अपवादों और विफलताओं को सहजता से संभालने की रणनीतियाँ लागू करें।

पाठ 3, कुल 3 में से11 चरण

Future में त्रुटि प्रबंधन, CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का एक निःशुल्क पाठ है। यह 3 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

Future की विफलताओं को संभालना

अतुल्यकालिक कार्रवाइयाँ विफल हो सकती हैं! जिस तरह समकालिक कोड अपवाद उत्पन्न कर सकता है, उसी तरह कोई Future सफल मान के बजाय किसी त्रुटि के साथ पूरा हो सकता है।

इन विफलताओं को सही ढंग से संभालने का तरीका समझना मजबूत समवर्ती अनुप्रयोग बनाने के लिए अत्यंत महत्वपूर्ण है। उचित त्रुटि-प्रबंधन के बिना आपका प्रोग्राम क्रैश हो सकता है या अनपेक्षित व्यवहार कर सकता है।

Future का परिणाम: Try

जब कोई Future पूरा होता है, तो उसका परिणाम scala.util.Try में लिपटा होता है। यह Try या तो Success(value) या Failure(exception) हो सकता है।

Success: परिकलित मान रखता है।
Failure: उत्पन्न हुए अपवाद को रखता है।

onComplete कॉलबैक को यह Try ऑब्जेक्ट प्राप्त होता है, जिससे आप दोनों परिणामों को संभाल सकते हैं।

त्रुटियों के लिए onComplete का उपयोग

onComplete विधि किसी Future के पूरा होने पर काम करने वाली सार्वत्रिक श्रोता है। यह ऐसा फ़ंक्शन लेती है, जो Try[T] स्वीकार करता है।

सफलता और विफलता के बीच अंतर करने के लिए आप Try पर पैटर्न मिलान कर सकते हैं।

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Failure}

object Main {
  def main(args: Array[String]): Unit = {
    val failingFuture = Future { 
      if (true) throw new RuntimeException("Oops!")
      10
    }

    failingFuture.onComplete {
      case Success(value) => println(s"Success: $value")
      case Failure(exception) => println(s"Failure: ${exception.getMessage}")
    }

    Thread.sleep(100) // Keep JVM alive for Future to complete
  }
}

recover विधि

recover आपको किसी अपवाद को संभालने और Future के विफल होने पर एक वैकल्पिक मान देने की अनुमति देता है। यह Future[T] को किसी अन्य Future[T] में रूपांतरित करता है।

यदि मूल Future विफल होता है, तो दिए गए आंशिक फ़ंक्शन को अपवाद पर लागू किया जाता है। यदि उसका मिलान हो जाता है, तो वैकल्पिक मान वाला एक नया सफल Future लौटाया जाता है।

recover का उदाहरण

यहाँ, यदि शून्य से भाग देने की स्थिति उत्पन्न होती है, तो recover ArithmeticException को पकड़कर 0 मान वाला Future लौटाता है।

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val resultFuture = Future { 10 / 0 } // This will fail

    val recoveredFuture = resultFuture.recover {
      case e: ArithmeticException =>
        println("Caught ArithmeticException, recovering...")
        0 // Fallback value
    }

    recoveredFuture.foreach(value => println(s"Result: $value"))

    Thread.sleep(100) // Keep JVM alive
  }
}

recoverWith विधि

recoverWith, recover के समान है, लेकिन यह वैकल्पिक मान लौटाने के बजाय एक वैकल्पिक Future लौटाता है।

यह तब उपयोगी होता है, जब स्वयं पुनर्प्राप्ति कार्रवाई में कोई अन्य अतुल्यकालिक कार्रवाई शामिल हो या आप मूल कार्रवाई को फिर से आज़माना चाहते हों।

recoverWith का उदाहरण

यदि प्रारंभिक Future विफल होता है, तो recoverWith एक नया Future देता है, जो कोई अलग कार्रवाई या डिफ़ॉल्ट अतुल्यकालिक मान आज़माता है।

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val primaryOperation = Future { 
      if (true) throw new Exception("Primary failed!")
      100
    }

    val fallbackOperation = Future { 
      println("Running fallback operation...")
      50 
    }

    val finalFuture = primaryOperation.recoverWith {
      case e: Exception =>
        println(s"Primary failed: ${e.getMessage}. Using fallback.")
        fallbackOperation
    }

    finalFuture.foreach(value => println(s"Final result: $value"))

    Thread.sleep(200) // Keep JVM alive
  }
}

fallbackTo विधि

fallbackTo आपको दो Future को शृंखला में जोड़ने की अनुमति देता है। यदि पहला Future विफल होता है, तो उसके परिणाम को अनदेखा कर दिया जाता है और इसके बजाय दूसरे Future का परिणाम उपयोग किया जाता है।

recoverWith के विपरीत, fallbackTo अपवाद की जाँच नहीं करता। यह केवल इतना कहता है: "यदि यह विफल हो, तो उसे आज़माएँ।"

fallbackTo का उदाहरण

यहाँ, यदि failingFuture विफल होता है, तो fallbackTo backupFuture के परिणाम का उपयोग करेगा।

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val failingFuture = Future { 
      if (true) throw new RuntimeException("Network error!")
      "Data from primary"
    }

    val backupFuture = Future { 
      println("Using backup source...")
      "Data from cache"
    }

    val finalResult = failingFuture.fallbackTo(backupFuture)

    finalResult.foreach(value => println(s"Retrieved: $value"))

    Thread.sleep(100) // Keep JVM alive
  }
}

त्रुटि-प्रबंधन प्रश्नोत्तरी

यदि कोई Future विफल हो जाए और आप उसके स्थान पर कोई वैकल्पिक अतुल्यकालिक कार्रवाई देना चाहें, तो आप किस विधि का उपयोग करेंगे?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: Future त्रुटि-प्रबंधन

हमने Scala के Future में त्रुटियों को संभालने की प्रमुख रणनीतियों का अध्ययन किया है:

onComplete: Try के माध्यम से सफलता और विफलता, दोनों पर प्रतिक्रिया देता है।
recover: अपवाद उत्पन्न होने पर एक वैकल्पिक मान प्रदान करता है।
recoverWith: अपवाद उत्पन्न होने पर एक वैकल्पिक Future प्रदान करता है।
fallbackTo: प्राथमिक Future के विफल होने पर त्रुटि की जाँच किए बिना बैकअप Future का उपयोग करता है।

लचीली अतुल्यकालिक प्रणालियाँ बनाने के लिए ये विधियाँ आवश्यक हैं!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Scala सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 143

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Future में त्रुटि प्रबंधन” पाठ निःशुल्क है?

हाँ—“Future में त्रुटि प्रबंधन” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

“Future में त्रुटि प्रबंधन” में मैं क्या सीखूँगा?

अतुल्यकालिक `Future` गणनाओं के भीतर अपवादों और विफलताओं को सहजता से संभालने की रणनीतियाँ लागू करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 3वाँ पाठ है।

“Future में त्रुटि प्रबंधन” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← बैकएंड इंजीनियरिंग और कार्यात्मक प्रोग्रामिंग के लिए Scala पर वापस जाएँ