जावा 12 में स्विच एक्सप्रेशंस के लिए पूरी गाइड

अच्छा पुराना switch जावा में पहले दिन से है। हम सभी इसका उपयोग करते हैं और इसके लिए उपयोग किए जाते हैं - विशेष रूप से इसकी क्विरक्स। (क्या किसी और को break गुस्सा आता है?) लेकिन अब सब कुछ बदलना शुरू हो जाता है: जावा 12 में, ऑपरेटर के बजाय स्विच का एक उदाहरण है:

 boolean result = switch(ternaryBool) { case TRUE -> true; case FALSE -> false; case FILE_NOT_FOUND -> throw new UncheckedIOException( "This is ridiculous!", new FileNotFoundException()); // as we'll see in "Exhaustiveness", `default` is not necessary default -> throw new IllegalArgumentException("Seriously?!"); }; 

स्विच में अब अपने काम के परिणाम को वापस करने की क्षमता है, जिसे एक चर को सौंपा जा सकता है; आप लैम्ब्डा-शैली के सिंटैक्स का भी उपयोग कर सकते हैं, जो आपको उन सभी case से गुजरने से छुटकारा case है जिनमें कोई break स्टेटमेंट नहीं है।

इस गाइड में, मैं आपको जावा 12 में स्विच भावों के बारे में जानने के लिए आवश्यक सभी चीजों के बारे में बताऊंगा।

एक प्रारंभिक समीक्षा

भाषा के प्रारंभिक विनिर्देश के अनुसार, स्विच भाव केवल जावा 12 में लागू होने शुरू हो रहे हैं ।

इसका मतलब है कि यह नियंत्रण निर्माण भाषा विनिर्देश के भविष्य के संस्करणों में बदला जा सकता है।

switch के नए संस्करण का उपयोग शुरू करने के switch आपको संकलन के दौरान और प्रोग्राम स्टार्टअप के दौरान --release 12 --enable-preview कमांड लाइन विकल्प का उपयोग करने की आवश्यकता है (आपको अनुवादक द्वारा नोट करते समय --release 12 उपयोग करना होगा)।

तो ध्यान रखें कि एक अभिव्यक्ति के रूप में स्विच , वर्तमान में जावा 12 में अंतिम सिंटैक्स नहीं है।

यदि आपको यह सब अपने आप से खेलने की इच्छा है, तो आप मेरे जावा एक्स डेमो प्रोजेक्ट को जीथब पर देख सकते हैं।

स्विच में बयान के साथ समस्या

इससे पहले कि हम स्विच में नवाचारों का अवलोकन करने के लिए आगे बढ़ते हैं, चलो एक स्थिति का मूल्यांकन करते हैं। मान लीजिए कि हम एक "भयानक" टर्नरी बूलियन से सामना कर रहे हैं और इसे एक नियमित बूलियन में बदलना चाहते हैं। यहाँ ऐसा करने का एक तरीका है:

 boolean result; switch(ternaryBool) { case TRUE: result = true; // don't forget to `break` or you're screwed! break; case FALSE: result = false; break; case FILE_NOT_FOUND: // intermediate variable for demo purposes; // wait for it... var ex = new UncheckedIOException("This is ridiculous!", new FileNotFoundException()); throw ex; default: // ... here we go: // can't declare another variable with the same name var ex2 = new IllegalArgumentException("Seriously?!"); throw ex2; } 

सहमत हूं कि यह बहुत असुविधाजनक है। "प्रकृति" में पाए गए कई अन्य स्विच विकल्पों की तरह, उपरोक्त उदाहरण केवल एक चर के मूल्य की गणना करता है और इसे असाइन करता है, लेकिन कार्यान्वयन को बायपास किया जाता है (पहचानकर्ता result घोषित करें और बाद में इसका उपयोग करें), दोहराया (मेरा break 'और हमेशा कॉपी-पास्ता का परिणाम) और त्रुटि प्रवण (दूसरी शाखा को भूल गए? ओह!)। सुधार करने के लिए स्पष्ट रूप से कुछ है।

आइए स्विच को एक अलग विधि में रखकर इन समस्याओं को हल करने का प्रयास करें:

 private static boolean toBoolean(Bool ternaryBool) { switch(ternaryBool) { case TRUE: return true; case FALSE: return false; case FILE_NOT_FOUND: throw new UncheckedIOException("This is ridiculous!", new FileNotFoundException()); // without default branch, the method wouldn't compile default: throw new IllegalArgumentException("Seriously?!"); } } 

यह बहुत बेहतर है: कोई डमी चर नहीं है, default की अनुपस्थिति के बारे में कोड और कंपाइलर संदेशों को अव्यवस्थित करने के लिए कोई break नहीं हैं (भले ही यह आवश्यक नहीं है, जैसा कि इस मामले में है)।

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

प्रस्तुत है स्विच भाव!

जैसा कि मैंने लेख की शुरुआत में दिखाया, जावा 12 और इसके बाद के संस्करण की शुरुआत, आप उपरोक्त समस्या को निम्नानुसार हल कर सकते हैं:

 boolean result = switch(ternaryBool) { case TRUE -> true; case FALSE -> false; case FILE_NOT_FOUND -> throw new UncheckedIOException( "This is ridiculous!", new FileNotFoundException()); // as we'll see in "Exhaustiveness", `default` is not necessary default -> throw new IllegalArgumentException("Seriously?!"); }; 

मुझे लगता है कि यह बहुत स्पष्ट है: यदि ternartBool है, तो result ' true सेट होगा (दूसरे शब्दों में, TRUE बदल जाता true )। FALSE हो जाता false ।

दो विचार तुरंत उठते हैं:

• switch परिणाम हो सकता है;
• तीरों के साथ क्या है?

नए स्विच फीचर्स के विवरण में देरी करने से पहले, शुरुआत में मैं इन दो मुख्य पहलुओं के बारे में बात करूंगा।

अभिव्यक्ति या कथन

आपको आश्चर्य हो सकता है कि स्विच अब एक अभिव्यक्ति है। लेकिन वह पहले क्या था?

जावा 12 से पहले, एक स्विच एक ऑपरेटर था - एक अनिवार्य निर्माण जो नियंत्रण के प्रवाह को नियंत्रित करता है।

if और टर्नरी ऑपरेटर के बीच अंतर के पुराने और नए संस्करणों के बीच अंतर के बारे में सोचें। वे दोनों तार्किक स्थिति की जांच करते हैं और इसके परिणाम के आधार पर ब्रांचिंग करते हैं।

अंतर यह है कि if बस इसी ब्लॉक को निष्पादित करता है, जबकि टर्नरी ऑपरेटर कुछ परिणाम देता है:

 if(condition) { result = doThis(); } else { result = doThat(); } result = condition ? doThis() : doThat(); 

वही स्विच के लिए है : जावा 12 से पहले, यदि आप मूल्य की गणना करना चाहते थे और परिणाम को बचाना चाहते थे, तो आप इसे या तो एक चर (और फिर break ) पर असाइन करेंगे, या इसे switch लिए विशेष रूप से बनाई गई विधि से वापस कर देंगे।

अब, स्विच स्टेटमेंट की संपूर्ण अभिव्यक्ति का मूल्यांकन किया जाता है (निष्पादन के लिए संबंधित शाखा का चयन किया जाता है), और गणना का परिणाम एक चर को सौंपा जा सकता है।

अभिव्यक्ति और कथन के बीच एक और अंतर यह है कि स्विच स्टेटमेंट , क्योंकि यह स्टेटमेंट का हिस्सा है, क्लासिक स्विच स्टेटमेंट के विपरीत, अर्धविराम के साथ समाप्त होना चाहिए।

तीर या उपनिवेश

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

 boolean result = switch(ternaryBool) { case TRUE: break true; case FALSE: break false; case FILE_NOT_FOUND: throw new UncheckedIOException( "This is ridiculous!", new FileNotFoundException()); default: throw new IllegalArgumentException("Seriously?!!?"); }; 

ध्यान दें कि अब आप एक मूल्य के साथ break उपयोग कर सकते हैं! यह पूरी तरह से पुरानी शैली के switch साथ फिट बैठता है जो बिना किसी अर्थ के break उपयोग करते हैं। तो जिस स्थिति में एक ऑपरेटर के बजाय एक तीर का मतलब अभिव्यक्ति है, वह यहां क्यों है? बस हिप्स्टर सिंटेक्स?

ऐतिहासिक रूप से, बृहदान्त्र के निशान केवल स्टेटमेंट ब्लॉक में प्रवेश बिंदु को चिह्नित करते हैं। इस बिंदु से, नीचे दिए गए सभी कोड का निष्पादन तब भी शुरू होता है, जब कोई अन्य लेबल सामने आता है। switch हम इसे अगले case (फ़ॉल-थ्रू) से गुजरने के रूप में जानते हैं: case लेबल परिभाषित करता है कि नियंत्रण प्रवाह कहां तक ​​जाता है। इसे पूरा करने के लिए, आपको break या return आवश्यकता है।

बदले में, तीर का उपयोग करने का अर्थ है कि इसके दाईं ओर केवल ब्लॉक निष्पादित किया जाएगा। और नहीं "विफल"।

स्विच के विकास पर अधिक

मामले पर कई टैग

अब तक, प्रत्येक case केवल एक लेबल होता है। लेकिन अब सब कुछ बदल गया है - एक case कई लेबल के अनुरूप हो सकता है:

 String result = switch(ternaryBool) { case TRUE, FALSE -> "sane"; // `default, case FILE_NOT_FOUND -> ...` does not work // (neither does other way around), but that makes // sense because using only `default` suffices default -> "insane"; }; 

व्यवहार स्पष्ट होना चाहिए: TRUE और FALSE एक ही परिणाम उत्पन्न करते हैं - अभिव्यक्ति "समझ" का मूल्यांकन किया जाता है।

यह एक अच्छा नवाचार है जिसने case के कई उपयोग को बदल दिया है जब अगले case एक पास-थ्रू संक्रमण को लागू करना आवश्यक था।

Enum के बाहर के प्रकार

इस आलेख में सभी switch उदाहरण enum उपयोग करते हैं। अन्य प्रकारों के बारे में क्या? अभिव्यक्तियाँ और switch String , int , ( डॉक्यूमेंट की जाँच करें) short , byte , char और उनके रैपर के साथ भी काम कर सकते हैं। यहां अब तक कुछ भी नहीं बदला है, हालांकि float और long जैसे डेटा प्रकारों का उपयोग करने का विचार अभी भी वैध है (दूसरे से अंतिम पैराग्राफ तक)।

तीर पर अधिक

आइए एक विभाजक रिकॉर्ड के तीर के रूप में विशिष्ट दो गुणों को देखें:

• अगले case संक्रमण के माध्यम से कमी;
• ऑपरेटरों के ब्लॉक।

अगले मामले के लिए कोई पास से नहीं

इस बारे में जेईपी 325 क्या कहता है:

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

मैं पूरी तरह से सहमत हूं और डिफ़ॉल्ट व्यवहार के बिना स्विच का उपयोग करने का अवसर का स्वागत करता हूं:

 switch(ternaryBool) { case TRUE, FALSE -> System.out.println("Bool was sane"); // in colon-form, if `ternaryBool` is `TRUE` or `FALSE`, // we would see both messages; in arrow-form, only one // branch is executed default -> System.out.println("Bool was insane"); } 

यह सीखना महत्वपूर्ण है कि इससे कोई लेना-देना नहीं है कि आप अभिव्यक्ति या कथन के रूप में स्विच का उपयोग करते हैं या नहीं। यहां निर्णायक कारक बृहदान्त्र के खिलाफ तीर है।

ऑपरेटर ब्लॉक

लंबोदर के मामले में, तीर एक ऑपरेटर (जैसा कि ऊपर) को इंगित कर सकता है या घुमावदार लटों के साथ हाइलाइट किया गया है:

 boolean result = switch(Bool.random()) { case TRUE -> { System.out.println("Bool true"); // return with `break`, not `return` break true; } case FALSE -> { System.out.println("Bool false"); break false; } case FILE_NOT_FOUND -> { var ex = new UncheckedIOException("This is ridiculous!", new FileNotFoundException()); throw ex; } default -> { var ex = new IllegalArgumentException("Seriously?!"); throw ex; } }; 

मल्टी-लाइन ऑपरेटरों के लिए बनाए जाने वाले ब्लॉक का एक अतिरिक्त लाभ होता है (जो कि बृहदान्त्र का उपयोग करते समय आवश्यक नहीं होता है), जिसका अर्थ है कि विभिन्न शाखाओं में समान चर नामों का उपयोग करने के लिए, switch को विशेष प्रसंस्करण की आवश्यकता नहीं होती है।

यदि आपको return बजाय break का उपयोग करके ब्लॉक से बाहर निकलना असामान्य लगा, तो चिंता न करें - इससे मुझे भी आश्चर्य हुआ और यह अजीब लग रहा था। लेकिन फिर मैंने इसके बारे में सोचा और इस निष्कर्ष पर पहुंचा कि यह समझ में आता है, क्योंकि यह switch निर्माण की पुरानी शैली को संरक्षित करता है, जो मूल्यों के साथ break का उपयोग करता है।

स्विच स्टेटमेंट के बारे में अधिक जानें

और अंतिम लेकिन कम से कम, अभिव्यक्ति के रूप में switch का उपयोग switch बारीकियां:

• कई भाव;
• जल्दी वापसी (जल्दी return );
• सभी मूल्यों का कवरेज।

कृपया ध्यान दें कि इससे कोई फर्क नहीं पड़ता है कि किस फॉर्म का उपयोग किया जाता है!

एकाधिक भाव

स्विच भाव कई भाव हैं। इसका मतलब है कि उनके पास अपना प्रकार नहीं है, लेकिन कई प्रकारों में से एक हो सकता है। सबसे अधिक बार, लैम्ब्डा अभिव्यक्तियों को ऐसे भावों के रूप में उपयोग किया जाता है: s -> s + " " , Function<String, String> हो सकता है, लेकिन यह Function<Serializable, Object> या UnaryOperator<String> भी हो सकता है।

स्विच के भावों का उपयोग करते हुए, एक प्रकार का निर्धारण बातचीत के माध्यम से किया जाता है जहां स्विच का उपयोग किया जाता है और इसकी शाखाओं के प्रकार। यदि एक स्विच अभिव्यक्ति को टाइप किए गए चर को सौंपा गया है, एक तर्क के रूप में पारित किया गया है, या अन्यथा एक संदर्भ में उपयोग किया जाता है जहां सटीक प्रकार ज्ञात होता है (इसे लक्ष्य प्रकार कहा जाता है), तो इसकी सभी शाखाओं को उस प्रकार से मेल खाना चाहिए। यहाँ हमने अभी तक क्या किया है:

 String result = switch (ternaryBool) { case TRUE, FALSE -> "sane"; default -> "insane"; }; 

नतीजतन, switch String के प्रकार के result चर को सौंपा गया है। इसलिए, String लक्ष्य प्रकार है, और सभी शाखाओं को String के प्रकार के परिणामस्वरूप वापस करना होगा।

यहाँ भी वही होता है:

 Serializable serializableMessage = switch (bool) { case TRUE, FALSE -> "sane"; // note that we don't throw the exception! // but it's `Serializable`, so it matches the target type default -> new IllegalArgumentException("insane"); }; 

अब क्या होगा?

 // compiler infers super type of `String` and // `IllegalArgumentException` ~> `Serializable` var serializableMessage = switch (bool) { case TRUE, FALSE -> "sane"; // note that we don't throw the exception! default -> new IllegalArgumentException("insane"); }; 

(संस्करण प्रकार के उपयोग के लिए, जावा में var प्रकार का उपयोग करने के लिए हमारे अंतिम लेख 26 सिफारिशों में पढ़ें - अनुवादक द्वारा नोट करें)

यदि लक्ष्य प्रकार अज्ञात है, तो इस तथ्य के कारण कि हम var का उपयोग करते हैं, प्रकार की गणना शाखाओं द्वारा बनाए गए प्रकारों के सबसे विशिष्ट सुपरस्क्रिप्ट को खोजने के द्वारा की जाती है।

जल्दी लौटना

अभिव्यक्ति और switch बीच अंतर का परिणाम यह है कि आप switch से बाहर return लिए उपयोग कर सकते हैं:

 public String sanity(Bool ternaryBool) { switch (ternaryBool) { // `return` is only possible from block case TRUE, FALSE -> { return "sane"; } default -> { return "This is ridiculous!"; } }; } 

... आप एक अभिव्यक्ति के अंदर return उपयोग नहीं कर सकते ...

 public String sanity(Bool ternaryBool) { String result = switch (ternaryBool) { // this does not compile - error: // "return outside of enclosing switch expression" case TRUE, FALSE -> { return "sane"; } default -> { return "This is ridiculous!"; } }; } 

इससे समझ में आता है कि क्या आप एक तीर या एक कोलन का उपयोग करते हैं।

सभी विकल्पों को कवर करना

यदि आप एक ऑपरेटर के रूप में switch उपयोग करते हैं, तो इससे कोई फर्क नहीं पड़ता कि सभी विकल्प कवर हैं या नहीं। बेशक, आप गलती से इस case छोड़ सकते हैं, और कोड सही तरीके से काम नहीं करेगा, लेकिन संकलक ध्यान नहीं देता है - आप, आपके आईडीई और आपके कोड विश्लेषण उपकरण इसे अकेले छोड़ देंगे।

स्विच के भाव इस समस्या को बढ़ा देते हैं। यदि वांछित लेबल गायब है, तो स्विच कहां जाना चाहिए? एकमात्र उत्तर जो जावा दे सकता है वह है संदर्भ प्रकारों के लिए अशक्तता और प्राथमिकताओं के लिए एक डिफ़ॉल्ट मान। यह मुख्य कोड में बहुत सारी त्रुटियों का कारण होगा।

इस तरह के परिणाम को रोकने के लिए, कंपाइलर आपकी मदद कर सकता है। स्विच स्टेटमेंट के लिए, कंपाइलर जोर देगा कि सभी संभावित विकल्प कवर किए गए हैं। आइए एक उदाहरण देखें, जिससे संकलन त्रुटि हो सकती है:

 // compile error: // "the switch expression does not cover all possible input values" boolean result = switch (ternaryBool) { case TRUE -> true; // no case for `FALSE` case FILE_NOT_FOUND -> throw new UncheckedIOException( "This is ridiculous!", new FileNotFoundException()); }; 

निम्नलिखित समाधान दिलचस्प है: default शाखा को जोड़ना निश्चित रूप से त्रुटि को ठीक करेगा, लेकिन यह एकमात्र समाधान नहीं है - आप अभी भी FALSE लिए case जोड़ सकते हैं।

 // compiles without `default` branch because // all cases for `ternaryBool` are covered boolean result = switch (ternaryBool) { case TRUE -> true; case FALSE -> false; case FILE_NOT_FOUND -> throw new UncheckedIOException( "This is ridiculous!", new FileNotFoundException()); }; 

हां, कंपाइलर अंत में यह निर्धारित करने में सक्षम होगा कि क्या सभी एनम वैल्यू कवर किए गए हैं (चाहे सभी विकल्प समाप्त हो जाएं), और बेकार डिफ़ॉल्ट मान सेट न करें! एक क्षण मौन कृतज्ञता में बैठ जाते हैं।

हालांकि, यह अभी भी एक सवाल उठाता है। क्या होगा अगर कोई एक पागल बूल को चतुर्थ मान जोड़कर एक चतुर्भुज बूलियन में बदल देता है? यदि आप विस्तारित बूल के लिए स्विच अभिव्यक्ति को फिर से जोड़ते हैं , तो आपको एक संकलन त्रुटि मिलेगी (अभिव्यक्ति अब संपूर्ण नहीं है)। पुनर्संयोजन के बिना, यह एक रन-टाइम समस्या में बदल जाएगा। इस समस्या को पकड़ने के लिए, कंपाइलर default ब्रांच में जाता है, जो उसी का व्यवहार करता है, जिसका हमने अभी तक इस्तेमाल किया था, अपवाद को फेंकते हुए।

जावा 12 में, default शाखा के बिना सभी मानों का विस्तार केवल enum लिए काम करता है, लेकिन जब जावा के भविष्य के संस्करणों में switch अधिक शक्तिशाली हो जाता है, तो यह मनमाने प्रकारों के साथ भी काम कर सकता है। यदि case लेबल न केवल समानता को सत्यापित कर सकते हैं, बल्कि तुलना भी कर सकते हैं (उदाहरण के लिए, _ <5 -> ...) - यह संख्यात्मक प्रकारों के लिए सभी विकल्पों को कवर करेगा।

सोच

हमने लेख से सीखा कि जावा 12 एक switch को एक अभिव्यक्ति में बदल देता है, जिससे इसे नई सुविधाएँ मिलती हैं:

• अब एक case कई लेबल के अनुरूप हो सकता है;
• नया तीर फ़ॉर्म case … -> … लंबोदर भावों के वाक्य विन्यास का अनुसरण करता है:
  
  • सिंगल-लाइन ऑपरेटर या ब्लॉक की अनुमति है;
  • अगले case से गुजरना रोका जाता है;
• अब पूरी अभिव्यक्ति का मूल्यांकन एक मूल्य के रूप में किया जाता है, जिसे फिर एक चर को सौंपा जा सकता है या एक बड़े बयान के हिस्से के रूप में पारित किया जा सकता है;
• एकाधिक अभिव्यक्ति: यदि लक्ष्य प्रकार ज्ञात है, तो सभी शाखाओं को इसके अनुरूप होना चाहिए। अन्यथा, एक विशिष्ट प्रकार परिभाषित किया गया है जो सभी शाखाओं से मेल खाता है;
• break एक मूल्य को एक ब्लॉक से वापस कर सकता है;
• enum का उपयोग करके एक switch अभिव्यक्ति के लिए, कंपाइलर अपने सभी मूल्यों के दायरे की जांच करता है। यदि default अनुपस्थित है, तो एक शाखा को जोड़ा जाता है जो एक अपवाद फेंकता है।

यह हमें कहां ले जाएगा? पहला, चूंकि यह switch का अंतिम संस्करण नहीं है, अगर आपके पास किसी चीज से असहमत हैं तो आपके पास एम्बर मेलिंग सूची पर प्रतिक्रिया छोड़ने का समय है।

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

आपको क्या लगता है? चीजों से संतुष्ट कैसे निकला?