Scala Language
गलती संभालना

प्रयत्न

map साथ आज़माएं, getOrElse और flatMap :

import scala.util.Try

val i = Try("123".toInt)     // Success(123)
i.map(_ + 1).getOrElse(321)  // 124

val j = Try("abc".toInt)     // Failure(java.lang.NumberFormatException)
j.map(_ + 1).getOrElse(321)  // 321

Try("123".toInt) flatMap { i =>
  Try("234".toInt)
    .map(_ + i)
}                            // Success(357)

का उपयोग करते हुए Try पैटर्न मिलान के साथ:

Try(parsePerson("John Doe")) match {
    case Success(person) => println(person.surname)
    case Failure(ex) => // Handle error ...
}

भी

त्रुटि / सफलता के लिए विभिन्न डेटा प्रकार

def getPersonFromWebService(url: String): Either[String, Person] = {
    
    val response = webServiceClient.get(url)

    response.webService.status match {
        case 200 => {
            val person = parsePerson(response)
            if(!isValid(person)) Left("Validation failed")
            else Right(person)
        }

        case _ => Left(s"Request failed with error code $response.status")
    }
}

पैटर्न या तो मूल्य पर मेल खाते हैं

getPersonFromWebService("http://some-webservice.com/person") match {
    case Left(errorMessage) => println(errorMessage)
    case Right(person) => println(person.surname)
}

किसी भी मान को विकल्प में बदलें

val maybePerson: Option[Person] = getPersonFromWebService("http://some-webservice.com/person").right.toOption

विकल्प

null मानों का उपयोग दृढ़ता से हतोत्साहित किया जाता है, जब तक कि विरासत जावा कोड के साथ बातचीत नहीं करती है जो null होने की उम्मीद करता है। इसके बजाय, Option का उपयोग किया जाना चाहिए जब किसी फ़ंक्शन का परिणाम या तो कुछ ( Some ) या कुछ नहीं (कुछ भी None ) हो सकता है।

त्रुटि से निपटने के लिए एक ट्राइ-कैच ब्लॉक अधिक उपयुक्त है, लेकिन यदि फ़ंक्शन वैध रूप से कुछ भी नहीं लौटा सकता है, तो Option उपयोग करने के लिए उपयुक्त है, और सरल है।

एक Option[T] या तो Some(value) हो सकता है Some(value) (प्रकार T का मान होता है) या None :

def findPerson(name: String): Option[Person]

यदि कोई व्यक्ति None मिला, तो None भी वापस None जा सकता है। अन्यथा, का एक उद्देश्य टाइप Some एक से युक्त Person वस्तु दिया जाता है। निम्न प्रकार के Option ऑब्जेक्ट को संभालने के तरीके हैं।

पैटर्न मिलान

findPerson(personName) match {
    case Some(person) => println(person.surname)
    case None => println(s"No person found with name $personName")
}

मानचित्र और getOrElse का उपयोग करना

val name = findPerson(personName).map(_.firstName).getOrElse("Unknown")
println(name) // Prints either the name of the found person or "Unknown"

तह का उपयोग करना

val name = findPerson(personName).fold("Unknown")(_.firstName)
// equivalent to the map getOrElse example above.

जावा में परिवर्तित

यदि आपको इंटरऑपरेबिलिटी के लिए एक Option प्रकार को अशक्त-सक्षम जावा प्रकार में बदलने की आवश्यकता है:

val s: Option[String] = Option("hello")
s.orNull           // "hello": String
s.getOrElse(null)  // "hello": String

val n: Option[Int] = Option(42)
n.orNull           // compilation failure (Cannot prove that Null <:< Int.)
n.getOrElse(null)  // 42

वायदा में उत्पन्न त्रुटियों को संभालना

जब एक exception को Future भीतर से फेंक दिया जाता है, तो आप इसे संभालने के लिए recover का उपयोग कर सकते हैं।

उदाहरण के लिए,

def runFuture: Future = Future { throw new FairlyStupidException }

val itWillBeAwesome: Future = runFuture

... Future भीतर से एक Exception फेंक देंगे। लेकिन जैसा कि हम अनुमान लगा सकते हैं कि उच्च संभावना के साथ FairlyStupidException का एक Exception , हम विशेष रूप से इस मामले को सुरुचिपूर्ण तरीके से संभाल सकते हैं:

val itWillBeAwesomeOrIllRecover = runFuture recover { 
    case stupid: FairlyStupidException => 
         BadRequest("Another stupid exception!") 
}

जैसा कि आप देख सकते हैं कि recover करने के recover दी गई विधि सभी Throwable के डोमेन पर एक PartialFunction Throwable , इसलिए आप बस कुछ निश्चित प्रकारों को संभाल सकते हैं और फिर बाकी को Future स्टैक में उच्च स्तर पर अपवाद हैंडलिंग के ईथर में जाने दें।

ध्यान दें कि यह गैर- Future संदर्भ में निम्नलिखित कोड को चलाने के समान है:

def runNotFuture: Unit = throw new FairlyStupidException

try {
    runNotFuture
} catch {
    case e: FairlyStupidException => BadRequest("Another stupid exception!")
}

Future s के भीतर उत्पन्न अपवादों को संभालना वास्तव में महत्वपूर्ण है क्योंकि अधिक समय वे अधिक कपटी होते हैं। वे आम तौर पर आपके चेहरे पर नहीं मिलते हैं, क्योंकि वे एक अलग निष्पादन संदर्भ और थ्रेड में चलते हैं, और इस प्रकार आपको उन्हें ठीक करने के लिए संकेत नहीं देते हैं जब वे होते हैं, खासकर यदि आप लॉग या कुछ के व्यवहार में कुछ भी नोटिस नहीं करते हैं आवेदन।

ट्राई-कैच क्लॉस का उपयोग करना

कार्यात्मक निर्माण जैसे कि Try , Option और Either फॉर एरर हैंडलिंग के अलावा, स्काला जावा के समान सिंटैक्स का भी समर्थन करता है, ट्राइ-कैच क्लॉज (संभावित अंततः ब्लॉक के साथ) का उपयोग करके। पकड़ क्लॉज एक पैटर्न मैच है:

try { 
  // ... might throw exception
} catch {
  case ioe: IOException => ... // more specific cases first
  case e: Exception => ...
  // uncaught types will be thrown
} finally {
  // ...
}

अपवादों को या तो या विकल्प प्रकारों में परिवर्तित करें

अपवादों को Either या Option प्रकारों में परिवर्तित करने के लिए, आप scala.util.control.Exception में scala.util.control.Exception गए तरीकों का उपयोग कर सकते हैं

import scala.util.control.Exception._

val plain = "71a"
val optionInt: Option[Int] = catching(classOf[java.lang.NumberFormatException]) opt { plain.toInt }
val eitherInt = Either[Throwable, Int] = catching(classOf[java.lang.NumberFormatException]) either { plain.toInt }