scala स्कैला में अपवाद फेंकना, "आधिकारिक नियम" क्या है




exception try-catch (2)

तो यह उन स्थानों में से एक है जहां स्काला विशेष रूप से जावा की विरासत भाषाओं और वातावरण के साथ-आसानी से संक्रमण के लिए / इंटरऑपरेबिलिटी के लिए कार्यात्मक शुद्धता को दूर करता है। कार्यात्मक शुद्धता अपवादों द्वारा तोड़ दी जाती है, क्योंकि वे संदर्भित अखंडता को तोड़ते हैं और समानता के कारण असंभव बनाते हैं। (बेशक, गैर-समाप्ति रिकर्सन वही करते हैं, लेकिन कुछ भाषाएं उन प्रतिबंधों को लागू करने के इच्छुक हैं जो उन्हें असंभव बनाती हैं।) कार्यात्मक शुद्धता रखने के लिए, आप विकल्प / शायद / या तो / कोशिश / सत्यापन का उपयोग करते हैं, जिनमें से सभी सफलतापूर्वक एन्कोड करते हैं या एक संदर्भित पारदर्शी प्रकार के रूप में विफलता, और चीजों को स्पष्ट करने के लिए उनके द्वारा प्रदान किए जाने वाले विभिन्न उच्च-आदेश कार्यों या अंतर्निहित भाषाओं विशेष मोनैड वाक्यविन्यास का उपयोग करें। या, स्कैला में, आप केवल कार्यात्मक शुद्धता को खत्म करने का निर्णय ले सकते हैं, यह जानकर कि यह छोटी अवधि में चीजों को आसान बना सकता है लेकिन लंबे समय तक अधिक कठिन हो सकता है। यह स्कैला, या परिवर्तनीय संग्रह, या स्थानीय "var" एस में "शून्य" का उपयोग करने के समान है। हल्के से शर्मनाक, और इसमें से अधिकतर नहीं करते हैं, लेकिन सभी समय सीमा के तहत हैं।

मैं Coursera पर स्कैला कोर्स का पालन कर रहा हूँ। मैंने ओडर्स्की की स्कैला पुस्तक भी पढ़ना शुरू कर दिया है।

जो मैं अक्सर सुनता हूं वह यह है कि कार्यात्मक भाषाओं में अपवाद फेंकना अच्छा नहीं है, क्योंकि यह नियंत्रण प्रवाह को तोड़ता है और हम आमतौर पर असफलता या सफलता के साथ या तो वापस आते हैं। ऐसा लगता है कि स्कैला 2.10 उस दिशा में जो प्रयास करता है उसे प्रदान करेगा।

लेकिन पुस्तक और पाठ्यक्रम में, मार्टिन ओडर्स्की ऐसा नहीं लगता है (कम से कम अभी के लिए) कि अपवाद खराब हैं, और वह उन्हें बहुत उपयोग करता है। मैंने यह भी देखा कि तरीकों का दावा / आवश्यकता है ...

अंततः मैं थोड़ा उलझन में हूं क्योंकि मैं सर्वोत्तम प्रथाओं का पालन करना चाहता हूं लेकिन वे स्पष्ट नहीं हैं और भाषा दोनों दिशाओं में जाना प्रतीत होता है ...

क्या कोई मुझे समझा सकता है कि मुझे किस मामले में उपयोग करना चाहिए?


मूल दिशानिर्देश कुछ असाधारण ** के लिए अपवादों का उपयोग करना है। "सामान्य" विफलता के लिए, Option या या Either उपयोग करना कहीं बेहतर है। यदि आप जावा के साथ इंटरफेसिंग कर रहे हैं, जहां कोई गलत तरीके से छींकता है तो अपवाद फेंक दिया जाता है, तो आप स्वयं को सुरक्षित रखने की Try कर सकते हैं।

आइए कुछ उदाहरण लें।

मान लें कि आपके पास एक तरीका है जो मानचित्र से कुछ प्राप्त करता है। क्या गलत हो सकता था? खैर, कुछ नाटकीय और खतरनाक जैसे segfault * ढेर अतिप्रवाह, या तत्व की तरह कुछ उम्मीद नहीं मिली है। आप segfault स्टैक ओवरफ़्लो को अपवाद फेंकने देंगे, लेकिन अगर आपको केवल तत्व नहीं मिलता है, तो मान या अपवाद (या null ) के बजाय Option[V] क्यों न लौटाएं?

अब मान लीजिए कि आप एक प्रोग्राम लिख रहे हैं जहां उपयोगकर्ता को फ़ाइल नाम दर्ज करना है। अब, अगर आप कुछ गलत होने पर प्रोग्राम पर तत्काल जमानत नहीं जा रहे हैं, Either कोई Either रास्ता तय करने का तरीका है:

def main(args: Array[String]) {
  val f = {
    if (args.length < 1) Left("No filename given")
    else {
      val file = new File(args(0))
      if (!file.exists) Left("File does not exist: "+args(0))
      else Right(file)
    }
  }
  // ...
}

अब मान लीजिए कि आप स्पेस-सीमांकित संख्याओं के साथ एक स्ट्रिंग को पार्स करना चाहते हैं।

val numbers = "1 2 3 fish 5 6"      // Uh-oh
// numbers.split(" ").map(_.toInt)  <- will throw exception!
val tried = numbers.split(" ").map(s => Try(s.toInt))  // Caught it!
val good = tried.collect{ case Success(n) => n }

तो आपके पास विभिन्न प्रकार की विफलता से निपटने के लिए तीन तरीकों (कम से कम) हैं: इसके लिए Option काम किया / नहीं किया, ऐसे मामलों में जहां काम नहीं कर रहा है, व्यवहार की उम्मीद है, चौंकाने वाली और खतरनाक विफलता नहीं; Either जब चीजें काम कर सकती हैं या नहीं (या, वास्तव में, कोई भी मामला जहां आपके पास दो परस्पर अनन्य विकल्प हैं) और आप कुछ गलत जानकारी के बारे में कुछ जानकारी सहेजना चाहते हैं; और Try जब आप अपवाद के पूरे सिरदर्द को स्वयं को संभालना नहीं चाहते हैं, लेकिन फिर भी अपवाद-खुश कोड के साथ इंटरफेस करने की आवश्यकता है।

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

* संपादित करें: Segfaults JVM को क्रैश करें और बाइटकोड पर ध्यान दिए बिना कभी नहीं होना चाहिए; यहां तक ​​कि एक अपवाद भी आपकी मदद नहीं करेगा। मेरा मतलब ढेर अतिप्रवाह था।

** संपादित करें: स्काला में नियंत्रण प्रवाह के लिए अपवाद (बिना स्टैक ट्रेस के) का भी उपयोग किया जाता है - वे वास्तव में काफी कुशल तंत्र हैं, और वे लाइब्रेरी-परिभाषित break स्टेटमेंट जैसी चीजें सक्षम करते हैं और एक return जो आपकी विधि से लौटती है नियंत्रण वास्तव में एक या एक से अधिक बंद हो गया है। अधिकतर, आपको इस बारे में चिंता नहीं करनी चाहिए, यह समझने के अलावा कि सभी Throwable एस को Throwable इतना अच्छा विचार नहीं है क्योंकि आप गलती से इन नियंत्रण प्रवाह अपवादों में से एक को पकड़ सकते हैं।





either