दिलचस्प पोस्ट
सूचकांक की परवाह किए बिना हमेशा पिछली पंक्ति डिफ़ॉल्ट टेलिबल मॉडेल से हटा दी गई थी Angular2 के साथ फ़ाइल अपलोड करने के लिए बाकी एपीआई टेक्स्ट पुनर्प्राप्ति पर सही शैली रखते हुए चार * और const चार * के बीच का अंतर? अपलोड छवि आकार को कम करने के लिए मैं UIImage का आकार कैसे बदलूं? एंड्रॉइड गैलरी से एकाधिक चित्र चुनें निर्भरता इंजेक्शन बनाम फैक्टरी पैटर्न कैसे iPhone एसडीके का उपयोग कर एक GUID / यूआईआईडी बनाने के लिए स्विफ्ट 4 के डिकोडेबल प्रोटोकॉल के साथ मैं कस्टम कुंजी का उपयोग कैसे करूं? चयन तत्व का डिफ़ॉल्ट मान सेट करने के लिए एनजी-विकल्प का उपयोग कैसे करें कितने बाइट लंबे समय तक हस्ताक्षरित हैं? किसी दिए गए एक्सटेंशन के लिए आइकन प्राप्त करें गतिशील रूप से निर्मित तत्वों पर घटना बाध्यकारी है? JAVA या JSP का उपयोग करके विंडोज़ उपयोगकर्ता प्राप्त करें पायथन में रिवर्स ऑर्डर में एक सूची को पार करते हैं

सशर्त का उपयोग करने के लाभ:? (टर्नर) ऑपरेटर

स्टैंडर्ड-एंड स्टेटमेंट के विरोध में ऑपरेटर के लाभ और कमियां क्या हैं I स्पष्ट होने के नाते:

सशर्त ?: ऑपरेटर

  • प्रत्यक्ष मूल्य तुलना और असाइनमेंट के साथ काम करते समय कम और अधिक संक्षिप्त
  • ऐसा लग रहा है कि अगर / अन्य निर्माण के रूप में लचीला नहीं है

मानक अगर / अन्य

  • अधिक परिस्थितियों में लागू किया जा सकता है (जैसे फ़ंक्शन कॉल)
  • अक्सर अनावश्यक रूप से लंबे समय तक होते हैं

बयान के आधार पर प्रत्येक के लिए पठनीयता भिन्न होती है। पहले कुछ समय के लिए: ऑपरेटर के संपर्क में आने के बाद, मुझे कुछ समय लगेगा कि वह वास्तव में कैसे काम करता है। क्या आप इसे जहां भी संभव हो, इसका उपयोग करने की सलाह देते हैं, या यदि अन्य / गैर-प्रोग्रामर के साथ काम करने के लिए दिए गए हैं?

वेब के समाधान से एकत्रित समाधान "सशर्त का उपयोग करने के लाभ:? (टर्नर) ऑपरेटर"

मैं मूल रूप से इसे प्रयोग करने की सलाह देता हूं जब परिणामस्वरूप बयान बहुत ही कम होता है और पठनीयता के बलिदान के बिना अगर / दूसरे समकक्ष के ऊपर संक्षेपण में महत्वपूर्ण वृद्धि का प्रतिनिधित्व करता है।

अच्छा उदाहरण:

 int result = Check() ? 1 : 0; 

खराब उदाहरण:

 int result = FirstCheck() ? 1 : SecondCheck() ? 1 : ThirdCheck() ? 1 : 0; 

यह अन्य उत्तरों से काफी अधिक है, लेकिन "यह एक अभिव्यक्ति है" वाकई समझा नहीं है कि यह इतना उपयोगी क्यों है …

सी ++ और सी # जैसी भाषाओं में, आप उन्हें इस्तेमाल करके स्थानीय स्थिरांक (एक विधि शरीर के भीतर) को परिभाषित कर सकते हैं यह एक पारंपरिक / अगर कथन के साथ संभव नहीं है क्योंकि एक const के मान को उस एकल कथन में सौंपा जाना है:

 const int speed = (shiftKeyDown) ? 10 : 1; 

ऐसा नहीं है:

 const int speed; if (shifKeyDown) speed = 10; // error - can't assign to a const else speed = 1; // error 

इसी प्रकार आप दूसरे कोड में एक तृतीयक अभिव्यक्ति को एम्बेड कर सकते हैं। साथ ही सोर्स कोड को अधिक कॉम्पैक्ट (और कुछ मामलों में परिणाम के रूप में अधिक पठनीय) बनाने के साथ ही यह भी उत्पन्न मशीन कोड को अधिक कॉम्पैक्ट और कुशल बना सकता है:

 MoveCar((shiftKeyDown) ? 10 : 1); 

… दो बार समान विधि को कॉल करने के लिए कम कोड उत्पन्न कर सकता है:

 if (shiftKeyDown) MoveCar(10); else MoveCar(1); 

बेशक, यह एक अधिक सुविधाजनक और संक्षिप्त रूप है (कम टाइपिंग, कम पुनरावृत्ति, और त्रुटियों की संभावना को कम कर सकता है यदि आपको किसी अन्य / अगर में कोड की मात्रा डुप्लिकेट करना है)। इस तरह के स्वच्छ "सामान्य पैटर्न" मामलों में:

 object thing = (reference == null) ? null : reference.Thing; 

… यह बहुत तेजी से / पढ़ने / समझने के लिए तेज़ है (एक बार आप इसे करने के लिए उपयोग किया जाता है) लंबे winded से अगर / या बराबर, तो यह आपको 'grok' कोड में तेजी से मदद कर सकता है

बेशक, सिर्फ इसलिए कि यह उपयोगी है इसका यह अर्थ नहीं है कि हर मामले में उपयोग करना सबसे अच्छी बात है। मैं इसे केवल संक्षेप कोड के लिए उपयोग करने की सलाह देता हूं जहां अर्थ स्पष्ट है (या अधिक स्पष्ट किया जाता है) ?: – यदि आप इसका इस्तेमाल अधिक जटिल कोड में करते हैं, या एक दूसरे के अंदर घोंसला टर्नरी ऑपरेटर करते हैं तो यह कोड को बहुत मुश्किल बना सकता है पढ़ने के लिए।

मैं आमतौर पर टर्नेरी ऑपरेटर का चुनाव करता हूं जब मेरे पास कई डुप्लिकेट कोड होते हैं

 if (a > 0) answer = compute(a, b, c, d, e); else answer = compute(-a, b, c, d, e); 

टर्नरी ऑपरेटर के साथ, यह निम्नलिखित के साथ पूरा किया जा सकता है

 answer = compute(a > 0 ? a : -a, b, c, d, e); 

वास्तव में एक शांत उपयोग है:

 x = foo ? 1 : bar ? 2 : baz ? 3 : 4; 

वेब डेवलपमेंट करते समय मुझे यह विशेष रूप से सहायक लगता है अगर मैं एक वैरिएबल को अनुरोध में भेजे गए मान में सेट करना चाहता हूँ यदि यह परिभाषित है या कुछ डिफ़ॉल्ट मान के लिए अगर यह नहीं है।

सशर्त ऑपरेटर शॉर्ट स्थितियों के लिए महान है, जैसे:

 varA = boolB ? valC : valD; 

मैं इसे कभी-कभी उपयोग करता हूं क्योंकि इस तरह से कुछ लिखने में कम समय लगता है … दुर्भाग्यवश, यह शाखाएं कभी-कभी आपके कोड पर किसी अन्य डेवलपर ब्राउज़िंग द्वारा याद किया जा सकता है। इसके अलावा, कोड आमतौर पर कम नहीं है, इसलिए मैं आमतौर पर इसे डालकर पठनीयता में मदद करता हूं? और: अलग लाइनों पर, इस तरह:

 doSomeStuffToSomething(shouldSomethingBeDone() ? getTheThingThatNeedsStuffDone() : getTheOtherThingThatNeedsStuffDone()); 

हालांकि, यदि / अन्य ब्लॉक (और मैं उन्हें पसंद क्यों करता है) का उपयोग करने का बड़ा लाभ यह है कि बाद में आने और शाखा में कुछ अतिरिक्त तर्क जोड़ना आसान है,

 if (shouldSomethingBeDone()) { doSomeStuffToSomething(getTheThingThatNeedsStuffDone()); doSomeAdditionalStuff(); } else { doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone()); } 

या एक और शर्त जोड़ें:

 if (shouldSomethingBeDone()) { doSomeStuffToSomething(getTheThingThatNeedsStuffDone()); doSomeAdditionalStuff(); } else if (shouldThisOtherThingBeDone()){ doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone()); } 

तो, अंत में, यह आपके लिए अब सुविधा है (कम उपयोग करने के लिए:?) बनाम आपके लिए सुविधा (और अन्य) बाद में यह एक फैसले कॉल है … लेकिन अन्य सभी कोड-स्वरूपण मुद्दों की तरह, एकमात्र वास्तविक नियम सुसंगत होना है, और उन लोगों को विनम्र रूप से विनम्र होना चाहिए जिनके पास (या ग्रेड!) आपके कोड को बनाए रखना है

(सभी कोड आंख संकलित)

जबकि उपर्युक्त उत्तर मान्य हैं, और मैं पठनीयता के लिए महत्वपूर्ण होने से सहमत हूं, इस पर विचार करने के लिए दो और बिंदु हैं:

  1. सी # 6 में, आप अभिव्यक्ति-शरीर पद्धतियां पा सकते हैं।

इससे टर्नरी का उपयोग करने के लिए इसे विशेष रूप से संक्षिप्त किया गया है:

 string GetDrink(DayOfWeek day) => day == DayOfWeek.Friday ? "Beer" : "Tea"; 
  1. व्यवहार भिन्न होता है जब यह निहित प्रकार रूपांतरण के लिए आता है।

यदि आपके पास प्रकार T1 और T2 जो दोनों पर सम्मत रूप से T परिवर्तित हो जाते हैं, तो नीचे काम नहीं करता है:

 T GetT() => true ? new T1() : new T2(); 

(क्योंकि संकलक टर्नरी अभिव्यक्ति के प्रकार को निर्धारित करने की कोशिश करता है, और T1 और T2 बीच कोई रूपांतरण नहीं है।)

दूसरी ओर, if/else नीचे if/else संस्करण काम करता है:

 T GetT() { if (true) return new T1(); return new T2(); } 

क्योंकि T1 को T1 में बदल दिया जाता है और ऐसा T2

टर्नरी ऑपरेटर का उपयोग करते समय पहचानने के लिए एक बात यह है कि यह एक अभिव्यक्ति नहीं है जो एक बयान नहीं है।

स्कीम जैसी कार्यात्मक भाषाओं में अंतर मौजूद नहीं है:

(यदि (> एबी) अब)

सशर्त ?: ऑपरेटर "अगर / अन्य निर्माण के रूप में लचीला नहीं लगता"

कार्यात्मक भाषाओं में यह है।

जब अनिवार्य भाषाओं में प्रोग्रामिंग मैं परिस्थितियों में टर्नर ऑपरेटर को लागू करता हूं, जहां मैं आमतौर पर अभिव्यक्ति (असाइनमेंट, सशर्त बयान, आदि) का उपयोग करता हूं।

कभी-कभी यह पहली नज़र में पढ़ने के लिए आसान बूल मूल्य का काम कर सकता है:

 // With button.IsEnabled = someControl.HasError ? false : true; // Without button.IsEnabled = !someControl.HasError; 

अगर मैं एक मान सेट कर रहा हूं और मुझे पता है कि यह हमेशा ऐसा करने के लिए कोड की एक पंक्ति होगी, तो मैं सामान्यतः टर्नरी (सशर्त) ऑपरेटर का उपयोग करता हूं अगर भविष्य में मेरा कोड और तर्क बदल जाएगा, तो मैं एक अन्य / प्रोग्रामर के लिए और अधिक स्पष्ट है क्योंकि I

आप के लिए और ब्याज की हो सकती है ?? ऑपरेटर

सशर्त ऑपरेटर का लाभ यह है कि यह एक ऑपरेटर है। दूसरे शब्दों में, यह एक मूल्य देता है चूंकि if कोई बयान है, तो यह कोई मूल्य नहीं लौटा सकता है।

मैं त्रिशूल के उपयोग को सीमित करने की सिफारिश करता हूं (? 🙂 ऑपरेटर को साधारण एकल पंक्ति असाइनमेंट अगर / अन्य तर्क इस पैटर्न के समान कुछ:

 if(<boolCondition>) { <variable> = <value>; } else { <variable> = <anotherValue>; } 

आसानी से इन्हें परिवर्तित किया जा सकता है:

 <variable> = <boolCondition> ? <value> : <anotherValue>; 

मैं टर्नेरी ऑपरेटर का उपयोग परिस्थितियों में करने से बचना चाहूंगा / if IF / if, नेस्टेड अगर / एफ़, या यदि / और ब्रांच लॉजिक जिसके परिणामस्वरूप कई लाइनों के मूल्यांकन में। इन परिस्थितियों में टर्नरी ऑपरेटर को लागू करने से संभवतः अपठनीय, भ्रामक और असुविधाजनक कोड होगा उम्मीद है की यह मदद करेगा।

इस का उपयोग करने के लिए कुछ प्रदर्शन लाभ है? ऑपरेटर में उदाहरण एमएस विज़ुअल सी ++, लेकिन यह वास्तव में एक कंपाइलर विशिष्ट चीज़ है संकलक वास्तव में कुछ मामलों में सशर्त शाखा का अनुकूलन कर सकता है।

यह परिदृश्य जिसे मैंने सबसे ज्यादा इस्तेमाल किया है, वह यह है कि वह मूल्यों को चुकाना और विशेषकर रिटर्न में

 return someIndex < maxIndex ? someIndex : maxIndex; 

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

यद्यपि आप बूलियन की तलाश कर रहे हैं, यह कभी कभी एक उपयुक्त चीज़ की तरह लग सकता है:

 bool hey = whatever < whatever_else ? true : false; 

क्योंकि यह पढ़ना और समझना इतना आसान है, लेकिन यह विचार हमेशा अधिक स्पष्ट रूप से फेंकना चाहिए:

 bool hey = (whatever < whatever_else); 

यदि आपको एक ही शर्त पर कई शाखाएं चाहिए, तो इसका उपयोग करें:

 if (A == 6) f(1, 2, 3); else f(4, 5, 6); 

यदि आपको अलग-अलग स्थितियों के साथ कई शाखाएं चाहिए, तो यदि बयान की संख्या में स्नोबॉल होता है, तो आप त्रिगुट का उपयोग करना चाहेंगे:

 f( (A == 6)? 1: 4, (B == 6)? 2: 5, (C == 6)? 3: 6 ); 

साथ ही, आप प्रारंभ में टर्नर ऑपरेटर का उपयोग कर सकते हैं

 const int i = (A == 6)? 1 : 4; 

यह बहुत गड़बड़ कर रही है:

 int i_temp; if (A == 6) i_temp = 1; else i_temp = 4; const int i = i_temp; 

आप / if के अंदर इनिशियलाइजेशन नहीं डाल सकते, क्योंकि यह दायरा बदलता है। लेकिन संदर्भ और const चर केवल प्रारंभिक रूप से बाध्य किया जा सकता है।

टर्नरी ऑपरेटर को एक रैवल्यू में शामिल किया जा सकता है, जबकि एक-दूसरे-तो नहीं; दूसरी तरफ, अगर-तब-दूसरे छोरों और अन्य बयानों को निष्पादित कर सकते हैं, जबकि टर्नरी ऑपरेटर केवल निष्पादित कर सकता है (संभवतः शून्य) रैवल्यूज़

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