दिलचस्प पोस्ट
एंड्रॉइड एप्लिकेशन को अग्रभूमि में चेक करना है या नहीं? जावा अनाम वर्ग से "यह" एक्सेस करें कैसे regex के साथ "उलटा मैच" करने के लिए? कस्टम मार्करों के साथ एंड्रॉइड मैप्स एपीआई v2 दो स्थानों के अक्षांश और देशांतर से दूरी कैसे प्राप्त करें? json_encode फ़ंक्शन: विशेष वर्ण '$ (दस्तावेज़) के non-jQuery समतुल्य क्या है .ready ()'? सर्वलेट से एक छवि फ़ाइल का उत्पादन करें RStudio में आर के स्थान को कैसे बदल सकता है? पायथन क्रमांकन – क्यों अचार? .htaccess के साथ साइट को पुनर्निर्देशित करें, लेकिन एक फ़ोल्डर को छोड़ दें जेपीए कैस्केड टाइप।। अनाथों को नहीं हटाता है क्यों एक Foreach- वस्तु में तोड़ने की तरह व्यवहार जारी है? सीएसएस फ्लोट में निम्न डिवी की चौड़ाई क्यों नहीं बदलती है? तत्वों के साथ उपनिषदों में विभाजन सूची

ब्रेका और कोष्ठक के बीच स्काला में औपचारिक अंतर क्या है, और उनका उपयोग कब किया जाना चाहिए?

कोष्ठक () और ब्रेसिज़ {} में कार्य करने के लिए तर्कों को पारित करने के बीच औपचारिक अंतर क्या है?

मुझे स्काला पुस्तकों में प्रोग्रामिंग से मिली भावना यह है कि स्काला बहुत लचीला है और मुझे उसका उपयोग करना चाहिए जो मुझे सर्वोत्तम पसंद है, लेकिन मुझे लगता है कि कुछ मामलों का संकलन करते हैं जबकि अन्य नहीं करते।

उदाहरण के लिए (सिर्फ एक उदाहरण के रूप में, मैं किसी भी प्रतिक्रिया की सराहना करता हूं जो सामान्य मामले पर चर्चा करता है, केवल यह विशेष उदाहरण नहीं):

 val tupleList = List[(String, String)]() val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 ) 

=> त्रुटि: सरल अभिव्यक्ति की अवैध शुरुआत

 val filtered = tupleList.takeWhile{ case (s1, s2) => s1 == s2 } 

=> ठीक है

वेब के समाधान से एकत्रित समाधान "ब्रेका और कोष्ठक के बीच स्काला में औपचारिक अंतर क्या है, और उनका उपयोग कब किया जाना चाहिए?"

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

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

 List(1, 2, 3).reduceLeft{_ + _} // valid, single Function2[Int,Int] parameter List{1, 2, 3}.reduceLeft(_ + _) // invalid, A* vararg parameter 

हालांकि, इन नियमों को बेहतर समझने के लिए आपको और अधिक जानने की ज़रूरत है

पैमानों के साथ जांच संकलन में वृद्धि

स्प्रे के लेखक दौर पैरों की सलाह देते हैं क्योंकि वे संकलित जांच को बढ़ा देते हैं। यह विशेष रूप से डीएसएल जैसे स्प्रे के लिए महत्वपूर्ण है पैरों का उपयोग करके आप संकलक को कह रहे हैं कि उसे केवल एक पंक्ति दी जानी चाहिए; इसलिए यदि आप गलती से इसे दो या अधिक दे देते हैं, तो यह शिकायत करेगा। अब यह कुरकुरा ब्रेसिज़ के मामले में नहीं है – उदाहरण के लिए यदि आप एक ऑपरेटर को कहीं भूल जाते हैं, तो आपका कोड संकलित होगा, और आपको अनपेक्षित परिणाम मिलेंगे और संभावित रूप से खोजने के लिए बहुत मुश्किल बग होगा। नीचे कॉलेट किया गया है (चूंकि अभिव्यक्ति शुद्ध हैं और कम से कम एक चेतावनी देगी), लेकिन बिंदु बनाता है:

 method { 1 + 2 3 } method( 1 + 2 3 ) 

पहली संकलन, दूसरा error: ')' expected but integer literal found देता error: ')' expected but integer literal found । लेखक 1 + 2 + 3 लिखना चाहता था

कोई बहस कर सकता है कि यह डिफ़ॉल्ट तर्कों के साथ बहु-पैरामीटर विधियों के समान है; पैरों का उपयोग करते समय गलती से पैरामीटर अलग करने के लिए अल्पविराम को भूलना असंभव है

शब्दाडंबर

वर्बोसिटी के बारे में एक महत्वपूर्ण अक्सर अनदेखी नोट कुरकुरा ब्रेसिज़ का प्रयोग अनिवार्य रूप से वर्बोस कोड की ओर जाता है क्योंकि स्काला शैली गाइड स्पष्ट रूप से कहता है कि कुरकुरा ब्रेसिज को बंद करना अपनी लाइन पर होना चाहिए:

… समापन ब्रेस समारोह की अंतिम पंक्ति के तुरंत बाद अपनी लाइन पर है।

कई ऑटो-सुधारक, जैसे इंटेलीज में, स्वचालित रूप से आपके लिए इस रीफैंटेटिंग को प्रदर्शन करेंगे। तो जब आप कर सकते हैं गोल पैरों का उपयोग करने के लिए छड़ी की कोशिश करो।

इंफिक्स नोटेशन

सूचकांक का उपयोग करते समय, जैसा कि List(1,2,3) indexOf (2) आप केवल एक पैरामीटर है और List(1, 2, 3) indexOf 2 रूप में इसे लिखने के लिए कोष्ठक छोड़ सकते हैं। यह डॉट-नोटेशन का मामला नहीं है

यह भी ध्यान रखें कि जब आपके पास एकल पैरामीटर है जो एक बहु-टोकन अभिव्यक्ति है, जैसे कि x + 2 या a => a % 2 == 0 , तो अभिव्यक्ति की सीमाओं को इंगित करने के लिए आपको कोष्ठक का उपयोग करना होगा।

tuples

क्योंकि आप कभी-कभी कोष्ठक छोड़ सकते हैं, कभी-कभी एक ट्यूपल को अतिरिक्त कोष्ठकों की तरह ((1, 2)) , और कभी-कभी बाहरी कोष्ठक को छोड़ा जा सकता है, जैसे (1, 2) । इससे भ्रम हो सकता है

case साथ फ़ंक्शन / आंशिक फ़ंक्शन शाब्दिक

स्काला में फ़ंक्शन और आंशिक फ़ंक्शन के लिए एक वाक्य रचना है। यह इस तरह दिख रहा है:

 { case pattern if guard => statements case pattern => statements } 

केवल अन्य स्थानों पर जहां आप case स्टेटमेंट का उपयोग कर सकते हैं, match और catch कीवर्ड के साथ हैं:

 object match { case pattern if guard => statements case pattern => statements } 
 try { block } catch { case pattern if guard => statements case pattern => statements } finally { block } 

आप किसी अन्य संदर्भ में case स्टेटमेंट का उपयोग नहीं कर सकते । इसलिए, यदि आप case का उपयोग करना चाहते हैं, तो आपको घुंघराले ब्रेसिज़ चाहिए यदि आप सोच रहे हैं कि फ़ंक्शन और आंशिक फ़ंक्शंस के बीच अंतर क्या है, तो इसका जवाब है: संदर्भ यदि स्काले को एक फ़ंक्शन की उम्मीद है, तो आपको एक फ़ंक्शन मिलता है। यदि उसे आंशिक फ़ंक्शन की उम्मीद है, तो आपको आंशिक फ़ंक्शन मिलता है। अगर दोनों की अपेक्षा होती है, तो यह अस्पष्टता के बारे में एक त्रुटि देता है

अभिव्यक्ति और ब्लॉक

पेटेन्सीसिस का उपयोग उप-प्रैक्सिस बनाने के लिए किया जा सकता है घुंघराले ब्रेसिज़ का उपयोग ब्लॉक के कोड बनाने के लिए किया जा सकता है (यह फ़ंक्शन शाब्दिक नहीं है, इसलिए इसे एक जैसा उपयोग करने का प्रयास करने से सावधान रहें) कोड के एक खंड में कई बयान शामिल हैं, जिनमें से प्रत्येक एक आयात विवरण, एक घोषणा या अभिव्यक्ति हो सकता है। यह इस प्रकार चलता है:

 { import stuff._ statement ; // ; optional at the end of the line statement ; statement // not optional here var x = 0 // declaration while (x < 10) { x += 1 } // stuff (x % 5) + 1 // expression } ( expression ) 

इसलिए, अगर आपको घोषणाएं, कई बयानों, एक import या उस जैसी कुछ भी आवश्यकता है, तो आपको घुंघराले ब्रेसिज़ की आवश्यकता है। और क्योंकि एक अभिव्यक्ति एक बयान है, कोष्ठक को घुंघराले ब्रेसिज़ के अंदर दिखाई दे सकता है। लेकिन दिलचस्प बात यह है कि कोड के ब्लॉक भी अभिव्यक्ति होते हैं , इसलिए आप किसी अभिव्यक्ति के अंदर कहीं भी उनका उपयोग कर सकते हैं:

 ( { var x = 0; while (x < 10) { x += 1}; x } % 5) + 1 

इसलिए, चूंकि अभिव्यक्ति बयान हैं, और कोड के ब्लॉक अभिव्यक्ति हैं, नीचे दी गई सभी चीजें मान्य हैं:

 1 // literal (1) // expression {1} // block of code ({1}) // expression with a block of code {(1)} // block of code with an expression ({(1)}) // you get the drift... 

जहां वे विनिमेय नहीं हैं

असल में, आप {} को () साथ या किसी अन्य स्थान के विपरीत नहीं बदल सकते। उदाहरण के लिए:

 while (x < 10) { x += 1 } 

यह विधि कॉल नहीं है, इसलिए आप इसे किसी अन्य तरीके से नहीं लिख सकते। ठीक है, आप condition लिए कोष्ठक के अंदर घुंघराले ब्रेसिज़ डाल सकते condition , साथ ही कोड के ब्लॉक के लिए कर्ली ब्रेसिज़ के अंदर कोष्ठक का उपयोग कर सकते हैं:

 while ({x < 10}) { (x += 1) } 

तो, मुझे उम्मीद है कि यह मदद करता है

यहां पर कई अलग-अलग नियम और संदर्भ दिए गए हैं: सबसे पहले, list.map(_ * 2) ने ब्रेसिज़ का अनुमान लगाया है, जब कोई पैरामीटर फ़ंक्शन होता है, जैसे कि list.map(_ * 2) में ब्रेसिज़ का अनुमान लगाया जाता है, यह केवल list.map({_ * 2}) का एक छोटा रूप है list.map({_ * 2}) । दूसरे, स्काला आपको आखिरी पैरामीटर सूची पर कोष्ठकों को छोड़ने की अनुमति देता है, यदि वह पैरामीटर सूची में एक पैरामीटर है और यह फ़ंक्शन है, तो list.foldLeft(0)(_ + _) को list.foldLeft(0) { _ + _ } रूप में लिखा जा सकता है। list.foldLeft(0) { _ + _ } (या list.foldLeft(0)({_ + _}) यदि आप अतिरिक्त स्पष्ट होना चाहते हैं)।

हालांकि, यदि आप case जोड़ते हैं, जैसा कि दूसरों ने उल्लेख किया है, फ़ंक्शन के बजाय एक आंशिक फ़ंक्शन, और स्काला आंशिक फ़ंक्शन के लिए ब्रेसिज़ का अनुमान नहीं list.map(case x => x * 2) , इसलिए list.map(case x => x * 2) काम नहीं करेगा , लेकिन दोनों list.map({case x => 2 * 2}) और list.map { case x => x * 2 } होगा।

ब्रेस और कोष्ठक के उपयोग को मानकीकृत करने के लिए समुदाय से एक प्रयास है, Scala शैली गाइड देखें (पृष्ठ 21): http://www.codecommit.com/scala-style-guide.pdf

उच्च आदेश विधियों कॉल के लिए अनुशंसित सिंटैक्स हमेशा ब्रेसिज़ का उपयोग करना है, और डॉट को छोड़ना है:

 val filtered = tupleList takeWhile { case (s1, s2) => s1 == s2 } 

"सामान्य" मेटोड कॉल के लिए आपको डॉट और कोष्ठक का उपयोग करना चाहिए

 val result = myInstance.foo(5, "Hello") 

मुझे लगता है कि यह फ़ंक्शन कॉल्स में उनके उपयोग को समझा देने योग्य है और क्यों विभिन्न चीजें होती हैं। जैसा कि पहले से ही किसी ने पहले ही कहा है कि घुंघराले ब्रेसिज़ कोड के एक ब्लॉक को परिभाषित करता है, जो कि एक अभिव्यक्ति भी है, जहां अभिव्यक्ति की उम्मीद की जा सकती है और इसका मूल्यांकन किया जाएगा। मूल्यांकन किए जाने पर, उसके बयान निष्पादित होते हैं और अंतिम बयान मूल्य पूरे ब्लॉक मूल्यांकन का परिणाम होता है (कुछ हद तक रूबी में)।

ऐसा करने से हम ऐसा काम कर सकते हैं:

 2 + { 3 } // res: Int = 5 val x = { 4 } // res: x: Int = 4 List({1},{2},{3}) // res: List[Int] = List(1,2,3) 

अंतिम उदाहरण केवल तीन मानकों के साथ एक फ़ंक्शन कॉल है, जिनमें से प्रत्येक का मूल्यांकन पहला है।

अब यह देखने के लिए कि यह फ़ंक्शन कॉल के साथ कैसे काम करता है, चलिए सरल फ़ंक्शन परिभाषित करते हैं जो पैरामीटर के रूप में अन्य फ़ंक्शन लेते हैं।

 def foo(f: Int => Unit) = { println("Entering foo"); f(4) } 

इसे कॉल करने के लिए, हमें फ़ंक्शन पास करने की आवश्यकता होती है, जो कि एक परम प्रकार आईएनटी लेता है, इसलिए हम फ़ंक्शन को शाब्दिक रूप से इस्तेमाल कर सकते हैं और इसे foo पर भेज सकते हैं:

 foo( x => println(x) ) 

जैसा कि पहले कहा गया है कि हम अभिव्यक्ति के स्थान पर कोड के ब्लॉक का उपयोग कर सकते हैं, तो इसका इस्तेमाल करते हैं

 foo({ x => println(x) }) 

यहाँ क्या होता है कि {} के अंदर कोड का मूल्यांकन किया जाता है, और फ़ंक्शन मान को ब्लॉक मूल्यांकन के मान के रूप में वापस किया जाता है, तो यह मान foo को पारित कर दिया जाता है यह अर्थिक रूप से पिछले कॉल के समान है।

लेकिन हम कुछ और जोड़ सकते हैं:

 foo({ println("Hey"); x => println(x) }) 

अब हमारे कोड ब्लॉक में दो स्टेटमेंट होते हैं, और क्योंकि फू निष्पादित होने से पहले इसका मूल्यांकन किया जाता है, क्या होता है कि पहले "हे" मुद्रित किया जाता है, फिर हमारे फ़ंक्शन को फ़ू के पास किया जाता है, "फ्यू प्रविष्टिंग" छपा हुआ है और अंत में "4" छपा हुआ है ।

यह थोड़ा बदसूरत दिखता है, हालांकि Scala हमें इस मामले में कोष्ठक को छोड़ने देता है, इसलिए हम लिख सकते हैं:

 foo { println("Hey"); x => println(x) } 

या

 foo { x => println(x) } 

यह बहुत अच्छा लग रहा है और पूर्व वालों के बराबर है यहां भी कोड का ब्लॉक पहले मूल्यांकन किया जाता है और मूल्यांकन का परिणाम (जो कि x => println (x) है) को फू के तर्क के रूप में पारित किया जाता है।

मुझे नहीं लगता कि Scala में घुंघराले ब्रेसिज़ के बारे में कुछ विशेष या जटिल है। स्कला में उनको प्रतीत होता है-जटिल उपयोग करने के लिए, बस कुछ सरल चीजों को ध्यान में रखें:

  1. घुंघराले ब्रेसिज़ कोड का एक ब्लॉक बनाते हैं, जो अंतिम पंक्ति कोड का मूल्यांकन करता है (लगभग सभी भाषाओं ऐसा करते हैं)
  2. एक समारोह अगर इच्छित कोड के ब्लॉक से उत्पन्न हो सकता है (नियम 1 के बाद)
  3. कुरकुरा ब्रेसिज़ को एक-लाइन कोड के लिए छोड़ा जा सकता है सिवाय इसके कि एक केस क्लॉज (स्कला पसंद)
  4. कोष्ठकों को फ़ंक्शन कॉल में कोड ब्लॉक के साथ एक पैरामीटर (स्कला पसंद) के रूप में छोड़ा जा सकता है

चलो, ऊपर दिए गए तीन नियमों के अनुसार कुछ उदाहरणों को समझें:

 val tupleList = List[(String, String)]() // doesn't compile, violates case clause requirement val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 ) // block of code as a partial function and parentheses omission, // ie tupleList.takeWhile({ case (s1, s2) => s1 == s2 }) val filtered = tupleList.takeWhile{ case (s1, s2) => s1 == s2 } // curly braces omission, ie List(1, 2, 3).reduceLeft({_+_}) List(1, 2, 3).reduceLeft(_+_) // parentheses omission, ie List(1, 2, 3).reduceLeft({_+_}) List(1, 2, 3).reduceLeft{_+_} // not both though it compiles, because meaning totally changes due to precedence List(1, 2, 3).reduceLeft _+_ // res1: String => String = <function1> // curly braces omission, ie List(1, 2, 3).foldLeft(0)({_ + _}) List(1, 2, 3).foldLeft(0)(_ + _) // parentheses omission, ie List(1, 2, 3).foldLeft(0)({_ + _}) List(1, 2, 3).foldLeft(0){_ + _} // block of code and parentheses omission List(1, 2, 3).foldLeft {0} {_ + _} // not both though it compiles, because meaning totally changes due to precedence List(1, 2, 3).foldLeft(0) _ + _ // error: ';' expected but integer literal found. List(1, 2, 3).foldLeft 0 (_ + _) def foo(f: Int => Unit) = { println("Entering foo"); f(4) } // block of code that just evaluates to a value of a function, and parentheses omission // ie foo({ println("Hey"); x => println(x) }) foo { println("Hey"); x => println(x) } // parentheses omission, ie f({x}) def f(x: Int): Int = f {x} // error: missing arguments for method f def f(x: Int): Int = fx 

क्योंकि आप case का उपयोग कर रहे हैं, आप आंशिक फ़ंक्शन को परिभाषित कर रहे हैं और आंशिक फ़ंक्शंस की आवश्यकता है कुरकुरा ब्रेसिज़।

पैमानों के साथ जांच संकलन में वृद्धि

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

 method { 1 + 2 3 } method( 1 + 2 3 ) 

पहली संकलन, दूसरा error: ')' expected but integer literal found. देता error: ')' expected but integer literal found. लेखक 1 + 2 + 3 लिखना चाहता था

कोई बहस कर सकता है कि यह डिफ़ॉल्ट तर्कों के साथ बहु-पैरामीटर विधियों के समान है; पैरों का उपयोग करते समय गलती से पैरामीटर अलग करने के लिए अल्पविराम को भूलना असंभव है

शब्दाडंबर

वर्बोसिटी के बारे में एक महत्वपूर्ण अक्सर अनदेखी नोट घुंघराले ब्रेसिज़ का उपयोग अनिवार्य रूप से वर्बोस कोड की ओर जाता है क्योंकि स्काला शैली गाइड स्पष्ट रूप से कहता है कि बंद कर्ल ब्रेसिज़ अपनी लाइन पर होना चाहिए: http://docs.scala-lang.org/style/declarations.html "… समापन ब्रेस फंक्शन की अंतिम पंक्ति के तुरंत बाद अपनी लाइन पर है। " कई ऑटो-सुधारक, जैसे इंटेलिज में, स्वचालित रूप से आपके लिए इस रीफैंटेटिंग को प्रदर्शन करेंगे। तो जब आप कर सकते हैं गोल पैरों का उपयोग करने के लिए छड़ी की कोशिश करो। जैसे की List(1, 2, 3).reduceLeft{_ + _} बन जाता है:

 List(1, 2, 3).reduceLeft { _ + _ } 

ब्रेसिज़ के साथ, आपको अर्धविराम के लिए प्रेरित किया गया और न ही कोष्ठक। विचार takeWhile फ़ंक्शन, क्योंकि यह आंशिक फ़ंक्शन की अपेक्षा करता है, केवल {case xxx => ??? } {case xxx => ??? } केस अभिव्यक्ति के आसपास कोष्ठक के बजाय मान्य परिभाषा है