दिलचस्प पोस्ट
सी ++ में "लम्बी", "लंबे समय तक", "लंबे समय तक पूर्णांक", और "लंबे समय तक अंतराल" के बीच अंतर क्या है? उद्देश्य-सी घोषित @ प्रॉपर्टी गुण (गैर-रचनात्मक, कॉपी, मजबूत, कमजोर) क्यों strdup बुराई माना जाता है एकल पंक्ति में एकाधिक पंक्तियों को डालने के लिए डुप्लिकेट कुंजी अद्यतन पर MySQL वास्तव में एक प्रयास में क्या होता है {वापसी x; } अंत में {x = शून्य; } बयान? MongoDB डेटा स्टोर निर्देशिका बदलना सीरियललाइजेशन और डिसेरायलाइजेशन के दौरान कंट्रोलर्स को कैसे बुलाया जाता है? क्या कोई इस 'डबल नकारात्मक' चाल को समझा सकता है? Parallelogram आकार पृष्ठभूमि कैसे बनाएँ? jQuery – कई तत्वों लपेट करने के लिए लपेटें () का उपयोग करें? अनसाइन्ड इन्टर का बह निकला जावा के तहत विंडोज में, मैं एक रीडायरेक्ट डेस्कटॉप फ़ोल्डर कैसे प्राप्त करूं? क्या फ़ंक्शन तर्क प्रकारों को जांचने के लिए पायथनिक है? अप्रत्यक्ष का उपयोग कर गतिशील चार्ट श्रेणी: वह कार्य मान्य नहीं है (सीमा के बावजूद हाइलाइट किया गया) एंड्रॉइड में मेमोरी लीक क्लास / गतिविधि को कैसे खोजें

सशर्त-और और सशर्त-या ऑपरेटरों के जावा आवधिक असाइन संस्करण क्यों नहीं हैं? (&& =, || =)

इसलिए बूलियन पर बाइनरी ऑपरेटरों के लिए, जावा है & , | , ^ , && और ||

चलो संक्षेप में बताओ कि वे संक्षेप में यहाँ क्या करते हैं:

  • जेएलएस 15.22.2 बूलियन लॉजिकल ऑपरेटर्स एंड, ^, और |
  • जेएलएस 15.23 कंडीशनल-एंड ऑपरेटर एंड ए
  • जेएलएस 15.24 सशर्त-या ऑपरेटर ||

& इसके लिए, परिणाम मान true अगर दोनों ऑपरेंड मूल्य true ; अन्यथा, परिणाम false

के लिए | , परिणाम मान false यदि दोनों ऑपरेंड मूल्य false ; अन्यथा, परिणाम true

^ , परिणाम मान true यदि ऑपरेंड मूल्य अलग हैं; अन्यथा, परिणाम false

&& ऑपरेटर समान है & इसके दाहिने हाथों के संचालन का मूल्यांकन करता है, यदि उसके बाएं हाथ के संचालन का मूल्य true

|| ऑपरेटर की तरह है | , लेकिन इसके दाहिने हाथ के संचालन का मूल्यांकन करता है, अगर उसके बाएं हाथ के ऑपरेंड का मूल्य false

अब, सभी 5 में से, उनमें से 3 में यौगिक असाइनमेंट संस्करण हैं, अर्थात् |= , &= और ^= । तो मेरा सवाल स्पष्ट है: क्यों जावा प्रदान नहीं &&= और ||= भी है? मुझे लगता है कि मुझे उन की तुलना में अधिक की जरूरत है &= और |=

और मुझे नहीं लगता कि "क्योंकि यह बहुत लंबा है" एक अच्छा जवाब है, क्योंकि जावा है >>>= इस चूक के लिए एक बेहतर कारण होना चाहिए


15.26 असाइनमेंट ऑपरेटर से :

12 असाइनमेंट ऑपरेटर हैं; […] = *= /= %= += -= <<= >>= >>>= &= ^= |=


एक टिप्पणी की गई थी कि अगर &&= और ||= लागू किया गया था, तो यह केवल एक ही ऑपरेटर होगा जो पहले दाहिने हाथ का मूल्यांकन नहीं करते हैं। मेरा मानना ​​है कि यह धारणा है कि एक मिश्रित असाइनमेंट ऑपरेटर दाहिने हाथ की ओर मूल्यांकन करता है पहले एक गलती है।

15.26.2 कम्पाउंड असाइनमेंट ऑपरेटर से :

फॉर्म E1 op= E2 का एक सामूहिक असाइनमेंट अभिव्यक्ति E1 op= E2 E1 = (T)((E1) op (E2)) बराबर है, जहां T E1 का प्रकार है, सिवाय इसके कि E1 केवल एक बार मूल्यांकन किया गया है।

सबूत के रूप में, निम्न स्निपेट एक NullPointerException फेंकता है, एक ArrayIndexOutOfBoundsException नहीं।

  int[] a = null; int[] b = {}; a[0] += b[-1]; 

Solutions Collecting From Web of "सशर्त-और और सशर्त-या ऑपरेटरों के जावा आवधिक असाइन संस्करण क्यों नहीं हैं? (&& =, || =)"

संभवतः ऐसा कुछ क्योंकि

 x = false; x &&= someComplexExpression(); 

ऐसा लगता है कि यह x को निर्दिष्ट करना चाहिए और कुछ का मूल्यांकन करना someComplexExpression() , लेकिन तथ्य यह है कि x के मूल्य पर मूल्यांकन का someComplexExpression() वाक्य रचना से स्पष्ट नहीं है।

इसके अलावा, जावा की सिंटेक्स सी पर आधारित है, और कोई भी उन ऑपरेटर को जोड़ने के लिए एक दबाव की आवश्यकता नहीं है। आप शायद एक बयान के साथ बेहतर होगा, वैसे भी।

कारण

ऑपरेटर &&= और ||= जावा पर उपलब्ध नहीं हैं क्योंकि ज्यादातर डेवलपर्स इन ऑपरेटर हैं:

  • प्रवण त्रुटि
  • निकम्मा

&&= लिए उदाहरण

यदि जावा की अनुमति &&= ऑपरेटर, तो उस कोड:

 bool isOk = true; //becomes false when at least a function returns false isOK &&= f1(); isOK &&= f2(); //we may expect f2() is called whatever the f1() returned value 

के बराबर होगा:

 bool isOk = true; if (isOK) isOk = f1(); if (isOK) isOk = f2(); //f2() is called only when f1() returns true 

यह पहला कोड त्रुटि प्रवण है क्योंकि कई डेवलपर्स को लगता है कि f2() को हमेशा वही कहा जाता है जो कि F1 () वापस लौटाए गए मूल्य। यह bool isOk = f1() && f2(); की तरह है bool isOk = f1() && f2(); जहां f2() को केवल तभी बुलाया जाता है जब f1() true देता true

अगर डेवलपर चाहता है कि f2() को केवल तभी बुलाया जाए जब f1() रिटर्न true , इसलिए उपरोक्त दूसरा कोड कम त्रुटि प्रवण है।

अन्य &= पर्याप्त है क्योंकि डेवलपर हमेशा चाहता है f2()

वही उदाहरण है, लेकिन &=

 bool isOk = true; isOK &= f1(); isOK &= f2(); //f2() always called whatever the f1() returned value 

इसके अलावा, जेवीएम को इस कोड को निम्न के रूप में चलाने चाहिए:

 bool isOk = true; if (!f1()) isOk = false; if (!f2()) isOk = false; //f2() always called 

तुलना करें && और & परिणाम

बूलियन मानों पर लागू होने पर क्या ऑपरेटरों के && और वही परिणाम हैं?

चलो निम्नलिखित जावा कोड का उपयोग कर जांचें:

 public class qalcdo { public static void main (String[] args) { test (true, true); test (true, false); test (false, false); test (false, true); } private static void test (boolean a, boolean b) { System.out.println (counter++ + ") a=" + a + " and b=" + b); System.out.println ("a && b = " + (a && b)); System.out.println ("a & b = " + (a & b)); System.out.println ("======================"); } private static int counter = 1; } 

आउटपुट:

 1) a=true and b=true a && b = true a & b = true ====================== 2) a=true and b=false a && b = false a & b = false ====================== 3) a=false and b=false a && b = false a & b = false ====================== 4) a=false and b=true a && b = false a & b = false ====================== 

इसलिए हां, हम && द्वारा & बूलियन मानों 😉 को बदल सकते हैं

तो बेहतर उपयोग करें &= इसके बजाय &&=

||= लिए समान

&&= समान कारण:
ऑपरेटर |= कम त्रुटि प्रवण ||=

अगर कोई डेवलपर चाहता है कि f2() को जब f1() रिटर्न true नहीं कहा जाए, तो मैं निम्नलिखित विकल्पों की सलाह देता हूं:

 // here a comment is required to explain that // f2() is not called when f1() returns false, and so on... bool isOk = f1() || f2() || f3() || f4(); 

या:

 // here the following comments are not required // (the code is enough understandable) bool isOk = false; if (!isOK) isOk = f1(); if (!isOK) isOk = f2(); //f2() is not called when f1() returns false if (!isOK) isOk = f3(); //f3() is not called when f1() or f2() return false if (!isOK) isOk = f4(); //f4() is not called when ... 

यह जावा में इस तरह है, क्योंकि यह सी में इस तरह है

अब सवाल यह है कि सी में ऐसा क्यों होता है क्योंकि जब और & और अलग-अलग ऑपरेटर बन गए (बी से पहले सी के वंश के पहले), तो ऑपरेटर की & = विविधता अनदेखी की गई थी।

लेकिन मेरे उत्तर के दूसरे हिस्से में इसके पीछे कोई स्रोत नहीं है।

जावा के मूल उद्देश्यों में से एक "सरल, वस्तु उन्मुख, और परिचित" होना था। जैसा कि इस मामले पर लागू होता है, & = परिचित है (सी, सी ++ है और इस संदर्भ में परिचित में उन दोनों को जानता है जो किसी से परिचित है)।

&& = परिचित नहीं होगा, और यह इस बात से सरल नहीं होगा कि भाषा डिजाइनर प्रत्येक ऑपरेटर के बारे में सोचने के लिए नहीं लग रहे थे, वे भाषा में जोड़ सकते थे, इसलिए कम अतिरिक्त ऑपरेटर्स सरल होते हैं।

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

दिलचस्प है, रूबी की तरह भाषाएं हैं = = और && =।

संपादित करें: जावा और सी के बीच शब्दावली अलग है

बूलियन वार्स के लिए, && और || शॉर्ट सर्किट मूल्यांकन का उपयोग करते समय और | ऐसा मत करो, तो आप अपेक्षा करेंगे && = और = = शॉर्ट सर्किट मूल्यांकन का भी उपयोग करें। इस के लिए एक अच्छा उपयोग मामला है खासकर यदि आप किसी लूप पर चल रहे हैं, तो आप तेज़, कुशल और संक्षिप्त होना चाहते हैं।

लेखन के बजाय

 foreach(item in coll) { bVal = bVal || fn(item); // not so elegant } 

मैं लिखना चाहता हूँ

 foreach(item in coll) { bVal ||= fn(item); // elegant } 

और पता है कि एक बार बीवीएल सच है, fn () पुनरावृत्त शेष के लिए नहीं बुलाया जाएगा।

' & ' और ' & ' समान नहीं हैं क्योंकि ' & ' एक छोटी कटौती आपरेशन है जो पहले ऑपरैंड गलत नहीं है, जबकि ' & ' यह वैसे भी करेगा (दोनों नंबर और बुलियन के साथ काम करता है)।

मैं मानता हूं कि यह अस्तित्व को अधिक समझ में आता है, लेकिन यह बुरा नहीं है यदि यह नहीं है। मुझे लगता है कि यह वहां नहीं था क्योंकि सी में यह नहीं है

वास्तव में क्यों नहीं सोच सकते

रूबी में इसकी अनुमति है

यदि मुझे अनुमान लगाया गया था, तो मैं कहूंगा कि यह अक्सर उपयोग नहीं किया जाता है, इसलिए इसे लागू नहीं किया गया। एक और स्पष्टीकरण हो सकता है कि पारसर केवल = से पहले चरित्र को देखता है

ए और बी और ए एंड ए बी ही बात नहीं है

ए और ए बी एक बूलीयन अभिव्यक्ति है जो एक बूलीयन देता है, और ए और बी बिटवर्ड अभिव्यक्ति है जो एक इंट (अगर ए और बी हैं) को रिटर्न देता है

क्या आपको लगता है कि वे वही हैं?

मैं किसी भी बेहतर कारण के बारे में सोच भी नहीं सकता, 'यह अविश्वसनीय बदसूरत लग रहा है!'

और

दोनों ऑपरेटर्स की पुष्टि करता है, यह एक बिटवायर ऑपरेटर है जावा कई बिटवायर ऑपरेटर को परिभाषित करता है, जिसे पूर्णांक प्रकार, लंबी, पूर्णांक, लघु, चार और बाइट पर लागू किया जा सकता है।

&&

इसका मूल्यांकन करना बंद हो जाता है कि यदि पहला ऑपरैम गलत मानता है, क्योंकि परिणाम गलत होगा, यह एक तार्किक ऑपरेटर है। यह बूलियन पर लागू किया जा सकता है

एंड ऑपरेटर ऑपरेटर के समान है, लेकिन आपके कोड को थोड़ा अधिक कुशल बना सकते हैं। चूंकि संपूर्ण अभिव्यक्ति के सत्य होने के लिए ऑपरेटर की तुलना में दोनों भाव सच हो सकते हैं, दूसरी अभिव्यक्ति का मूल्यांकन करने का कोई कारण नहीं है, अगर पहले एक गलत संदेश देता है। और ऑपरेटर हमेशा दोनों भावों का मूल्यांकन करता है && ऑपरेटर केवल दूसरी अभिव्यक्ति का मूल्यांकन करता है यदि पहली अभिव्यक्ति सही है।

एक && = असाइनमेंट ऑपरेटर होने से भाषा में वास्तव में नई कार्यक्षमता नहीं जुड़ती। Bitwise ऑपरेटर का अंकगणितीय अधिक अभिव्यंजक है, आप पूर्णांक बिटवर्ड अंकगणित कर सकते हैं, जिसमें बूलियन अंकगणित शामिल हैं। तार्किक ऑपरेटर्स केवल बूलियन अंकगणित कर सकते हैं