त्रिगुट करने के लिए या नहीं करने के लिए? [बन्द है]

Question

मैं व्यक्तिगत रूप से टर्नरी ऑपरेटर का एक वकील हूँ: ()? :; मुझे एहसास है कि यह अपनी जगह है, लेकिन मैं कई प्रोग्रामर के सामने आया हूं जो पूरी तरह से इसके इस्तेमाल के खिलाफ हैं, और कुछ ऐसे भी हैं जो अक्सर इसका इस्तेमाल करते हैं।

उस पर आपकी क्या भावनाएं हैं? आपने किस दिलचस्प कोड का उपयोग करते हुए देखा है?

Comments

किसी चीज का पैरोकार वह व्यक्ति होता है जो उस चीज का समर्थन करता है।

— डग मैकलीन

जब यह स्पष्ट हो तो इसका उपयोग करें, इसे भ्रमित होने से बचें। यह एक निर्णय कॉल है। यह कोड को अधिक पठनीय बना सकता है, लेकिन केवल सरल अभिव्यक्तियों के लिए। हमेशा इसका उपयोग करने की कोशिश करना उतना ही एक खतरा है जितना कि लगातार इसे से बचना।

— हाबिल

दरअसल, यह सशर्त ऑपरेटर है। एक क्लोज-टू-डुप्लिकेट प्रश्न stackoverflow.com/questions/725973/… है ।

— डैनियल डारनास

मैं कभी-कभी उपयोग कर रहा था, x = x if x else yलेकिन फिर इसके बारे में पूछा और दूसरों के साथ महसूस किया कि यह वास्तव में सिर्फ x = x या y ( stackoverflow.com/questions/18199381/self-referencing-ternary/… ) को कम करता है

— Scruffel

इन जैसे प्रश्नों को रचनात्मक नहीं माना जाना चाहिए।

— अनघेउर

Answer 1

केवल सरल भाव के लिए इसका उपयोग करें :

int a = (b > 10) ? c : d;

चेन या नेस्ट टर्नरी ऑपरेटरों को पढ़ना और भ्रमित करना कठिन नहीं है:

int a = b > 10 ? c < 20 ? 50 : 80 : e == 2 ? 4 : 8;

इसके अलावा, जब टर्नरी ऑपरेटर का उपयोग करते हैं, तो कोड को इस तरह से प्रारूपित करने पर विचार करें जो पठनीयता में सुधार करे:

int a = (b > 10) ? some_value                 
                 : another_value;

Comments

पूरी तरह से पहले कुछ बयानों से सहमत हैं लेकिन "बेहतर पठनीयता" के आपके उदाहरण से पूरी तरह असहमत हैं। यदि आप मल्टी-लाइन के लिए जा रहे हैं तो सिर्फ एक if स्टेटमेंट का उपयोग क्यों न करें?

— जो फिलिप्स

सिर्फ इसलिए कि अगर कोई और सरल निर्णयों के लिए एक बहुत अधिक क्रिया है: int a = 0; if (b> 10) a = some_value; और एक = other_value; आप क्या करना चाहते हैं?

— marcospereira

@ d03boy: क्योंकि अगर-स्टेटमेंट सिर्फ इतना ही है, एक स्टेटमेंट, और जब आप चाहते हैं, तो एक अभिव्यक्ति नहीं होगी।

— फॉल्सट्रो

कुछ भाषाओं में @roe अगर अभिव्यक्ति है (उदाहरण के लिए स्काला में), तो val x = if(true) 0 else 1पूरी तरह से कानूनी है

— om-nom-nom

@ om-nom-nom मामला है, जो इसे एक if-statement के बजाय एक if-अभिव्यक्ति बनाता है, और अनिवार्य रूप से एक ही चीज़ है?: - ऑपरेटर।

— फालस्ट्रो

Answer 2

यह डिबगिंग को थोड़ा और कठिन बना देता है क्योंकि आप प्रत्येक उप अभिव्यक्तियों पर ब्रेकपॉइंट नहीं लगा सकते हैं। मैं शायद ही कभी इसका इस्तेमाल करता हूं।

Comments

मैंने कभी सुना है कि टर्नरी ऑपरेटर के खिलाफ सबसे अच्छा तर्क है। मैं "पठनीय नहीं" तर्क नहीं खरीदता (यह मुझे लगता है कि लोगों को इसकी आदत होने के लिए बहुत आलसी लगता है) लेकिन यह वास्तव में पदार्थ है।

— एप्सिलॉनवेक्टर

Answer 3

मैं उनसे प्यार करता हूं, खासकर टाइप-सेफ भाषाओं में।

मैं यह नहीं देखता कि यह कैसे:

int count = (condition) ? 1 : 0;

क्या इससे कोई कठिन है:

int count;

if (condition)
{
  count = 1;
} 
else
{
  count = 0;
}

संपादित करें -

मेरा तर्क है कि टर्नरी ऑपरेटर विकल्प की तुलना में सब कुछ कम जटिल और अधिक साफ-सुथरा बनाते हैं।

Comments

जब चर स्थिर होता है, तो D या C ++ में टर्नरी आरंभीकरण और भी उपयोगी होता है। जैसे const int count = ...;

— 16

ठीक है, आप if/elseवहां मौजूद अनावश्यक ब्रेसिज़ के साथ गलत तरह से पेश आ रहे हैं।

— बोबोबोबो

इसके अलावा, इस मामले में अगर conditionहै bool तो आप सिर्फ कर सकता है int count = condition;

— bobobobo

@ बोबोबोबो इस if/elseब्रेसिज़ के साथ है कि प्रोग्रामर के बहुमत को फिर से लिखना होगा ..

— आंद्रे Figueiredo

@bobobobo अगर / वर w / ओ ब्रेसिज़ सिर्फ परेशानी के लिए पूछ रहा है। किसी के लिए एक पंक्ति जोड़ना बहुत आसान है, लेकिन यह भूल जाते हैं कि इसके बाद उन्हें ब्रेस की आवश्यकता होगी जो वे उम्मीद करते हैं (एक ब्लॉक के हिस्से के रूप में अतिरिक्त लाइन को निष्पादित करें): stackoverflow.com/a/381274/377225

— जॉर्ज मैरियन

Answer 4

जंजीर मैं ठीक हूँ - नेस्टेड, इतना नहीं।

मैं उन्हें सी में बस ज्यादा इस्तेमाल करता हूं b / c वे एक if स्टेटमेंट हैं जिसका वैल्यू है, इसलिए यह अनावश्यक पुनरावृत्ति और वैरिएबल में कटौती करता है:

x = (y < 100) ? "dog" :
    (y < 150) ? "cat" :
    (y < 300) ? "bar" : "baz";

बजाय

     if (y < 100) { x = "dog"; } 
else if (y < 150) { x = "cat"; }
else if (y < 300) { x = "bar"; } 
else              { x = "baz"; }

इस तरह के असाइनमेंट में, मुझे लगता है कि रिफ्लेक्टर और क्लीयर कम है।

जब मैं दूसरी तरफ रूबी में काम कर रहा होता हूं, तो मैं if...else...endइसका उपयोग करने की अधिक संभावना रखता हूं क्योंकि यह एक अभिव्यक्ति भी है।

x =   if (y < 100) then "dog"
    elif (y < 150) then "cat"
    elif (y < 300) then "bar"
    else                "baz"
    end

(हालांकि, माना जाता है कि इस सरल चीज़ के लिए, मैं अभी भी टर्नरी ऑपरेटर का उपयोग कर सकता हूं)।

Comments

मुझे आपका पहला उदाहरण पसंद है - मैंने पहले इस तरह उनका पीछा करने के बारे में नहीं सोचा था। साझा करने के लिए धन्यवाद। =)

— एरिक फोर्ब्स

+1 मैंने वास्तव में हाल ही में ऐसा करना शुरू किया है। मैं वास्तव में भी यह स्विच बयानों को बदलने के लिए करते हैं।

— डेवी

उत्कृष्ट उदाहरण @ क्रैम्पियन।

— यूलुनेट

Answer 5

Ternary ?:ऑपरेटर प्रक्रियात्मक ifनिर्माण के एक कार्यात्मक समकक्ष के रूप में है । इसलिए जब तक आप नेस्टेड ?:अभिव्यक्तियों का उपयोग नहीं कर रहे हैं , तब तक किसी भी ऑपरेशन के कार्यात्मक प्रतिनिधित्व के खिलाफ / तर्क यहां लागू होते हैं। लेकिन नेस्टिंग टर्नरी ऑपरेशन के परिणामस्वरूप कोड हो सकता है जो सर्वथा भ्रामक है (पाठक के लिए व्यायाम: एक पार्सर लिखने की कोशिश करें जो नेस्टेड टर्नरी सशर्त को संभाल लेगा और आप उनकी जटिलता की सराहना करेंगे)।

लेकिन ऐसी बहुत सी परिस्थितियाँ हैं जहाँ ?:ऑपरेटर के रूढ़िवादी उपयोग में कोड हो सकता है जो वास्तव में अन्यथा पढ़ने में आसान है। उदाहरण के लिए:

int compareTo(Object object) {
    if((isLessThan(object) && reverseOrder) || (isGreaterThan(object) && !reverseOrder)) {
       return 1;
    if((isLessThan(object) && !reverseOrder) || (isGreaterThan(object) && reverseOrder)) {
       return -1;
    else
      return 0;              
}

अब इससे तुलना करें:

int compareTo(Object object) {
    if(isLessThan(object))
        return reverseOrder ? 1 : -1;         
    else(isGreaterThan(object))
        return reverseOrder ? -1 : 1;
    else        
       return 0;              
}

जैसा कि कोड अधिक कॉम्पैक्ट है, इसमें कम सिंटैक्टिक शोर है, और टर्नरी ऑपरेटर का विवेकपूर्ण तरीके से उपयोग करके (जो कि रिवर्सऑडर प्रॉपर्टी के संबंध में है) अंतिम परिणाम विशेष रूप से नहीं है।

Comments

मैं अभी भी हर अगर / फिर / निर्माण पर है कि ternary थियो नहीं है पर प्रशंसा का उपयोग करने की वकालत करेंगे, तो अपने दूसरे उदाहरण कुछ imho याद आ रही है।

— क्रिस

हाँ, यह कार्यात्मक है। यह एक छोटे से फंक्शन की तरह है जिसमें एक ही बूलियन तर्क होता है और, किसी भी प्रकार को आप चाहते हैं! दरअसल एक साफ सुथरा संचालक।

— बोब्बोबो

Answer 6

यह वास्तव में शैली का सवाल है; अवचेतन नियम जिनका मैं अनुसरण करता हूं वे हैं:

• केवल 1 अभिव्यक्ति का मूल्यांकन करें - इसलिए foo = (bar > baz) ? true : false, लेकिन नहींfoo = (bar > baz && lotto && someArray.Contains(someValue)) ? true : false
• अगर मैं इसे प्रदर्शन तर्क के लिए उपयोग कर रहा हूं, जैसे <%= (foo) ? "Yes" : "No" %>
• केवल इसे असाइनमेंट के लिए उपयोग करें; तर्क प्रवाह कभी नहीं (ऐसा कभी नहीं (foo) ? FooIsTrue(foo) : FooIsALie(foo)) टर्नरी में प्रवाह तर्क अपने आप में एक झूठ है, उस अंतिम बिंदु को अनदेखा करें।

मुझे यह पसंद है क्योंकि यह सरल काम संचालन के लिए संक्षिप्त और सुरुचिपूर्ण है।

Comments

अच्छे दिशानिर्देश और अच्छे उदाहरण!

— 23

मुझे लगता है कि अधिकांश लॉंगुग आपको प्रवाह तर्क के लिए इसका उपयोग नहीं करने देंगे, इसलिए आप (फू) नहीं कर सकते; सच (फू): गलत (फू); जब तक यह एक असाइनमेंट नहीं था।

— हेनरी बी

उफ़, हाँ तुम सही हो, मेरा बुरा।

— कीथ विलियम्स

आपके दो पहले उदाहरण वास्तव में बुरे हैं। तुलना के परिणाम पहले से ही बूलियन मान हैं, इसलिए आपके टर्नरी ऑपरेटर बेकार हैं और केवल कोड को जटिल करते हैं।

— ट्रिलियन

@ ट्रिलियन +1 हां, एक अलग असाइनमेंट के साथ जाना चाहिए था। foo = (bar > baz);बहुत सरल है

— एरिक

Answer 7

इतने सारे राय प्रश्नों की तरह, उत्तर अनिवार्य रूप से है: यह निर्भर करता है

कुछ इस तरह के लिए:

return x ? "Yes" : "No";

मुझे लगता है कि इसकी तुलना में बहुत अधिक संक्षिप्त (और मेरे लिए जल्दी है):

if (x) {
    return "Yes";
} else {
    return "No";
}

अब यदि आपकी सशर्त अभिव्यक्ति जटिल है, तो टर्नरी ऑपरेशन एक अच्छा विकल्प नहीं है। कुछ इस तरह:

x && y && z >= 10 && s.Length == 0 || !foo

ternary ऑपरेटर के लिए एक अच्छा उम्मीदवार नहीं है।

एक तरफ के रूप में, यदि आप एक सी प्रोग्रामर हैं, तो जीसीसी के पास वास्तव में एक एक्सटेंशन है जो आपको इस तरह से टर्नरी के अगर-सच्चे हिस्से को बाहर करने की अनुमति देता है:

/* 'y' is a char * */
const char *x = y ? : "Not set";

जो मानने के xलिए तैयार है वह नहीं है । अच्छी चीज़।yyNULL

Comments

फिक्स्ड मामूली वाक्यविन्यास और व्याकरण की संभावना, शॉन :-) कोड के अंतिम बिट से मिसिंग वाई और "असाइन एक्स टू वाई" का अर्थ "वाई = एक्स" है, इसलिए मैं "सेट एक्स टू वाई" के लिए chgd करता हूं।

— paxdiablo

@ पैक्स: धन्यवाद! जब से मैं यह बताना चाह रहा था कि जीसीसी एक्सटेंशन के साथ आपको टर्नरी के अगर-सच्चे हिस्से की आवश्यकता नहीं है, तो मैंने वाक्यविन्यास में बदलाव किया।

— शॉन ब्राइट

क्षमा करें, उस अनुच्छेद को नहीं देखा। नहीं जानते कि मैं इस तरह के सामान से सहमत हूं, क्योंकि यह लोगों को कोड लिखने की अनुमति देता है जो आईएसओ-मानक संकलक के साथ संकलन नहीं करेगा। फिर भी, जब GCC आखिरी आदमी है, तो यह कोई फर्क नहीं पड़ेगा :-)

— paxdiablo

यह सुनिश्चित करने के लिए वूडू है ... और कौन जीसीसी का उपयोग नहीं करता है? : डी

— सीन ब्राइट

Answer 8

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

अन्य मामलों में, ऐसा लगता है कि टर्नरी ऑपरेटर की स्पष्टता कम हो जाती है।

Comments

समस्या यह है कि भाषा का 99% है, एक अभिव्यक्ति को एक फ़ंक्शन द्वारा बदला जा सकता है ... और टर्नरी ऑपरेटर से बचने वाले पीपीएल भी उस समाधान को पसंद करेंगे।

— पियरेबर्ड

Answer 9

साइक्लोमैटिक जटिलता के माप से , ifबयानों या टर्नरी ऑपरेटर का उपयोग बराबर है। तो उस माप से, उत्तर नहीं है , जटिलता पहले जैसी ही होगी।

पठनीयता, अनुरक्षण और DRY (दोहराव-खुद को) जैसे अन्य उपायों द्वारा, या तो विकल्प दूसरे से बेहतर साबित हो सकता है।

Answer 10

मैं इसका उपयोग अक्सर उन जगहों पर करता हूँ जहाँ मैं एक कंस्ट्रक्टर में काम करने के लिए विवश हूँ - उदाहरण के लिए, XML .NET का नया .NET 3.5 LINQ - एक वैकल्पिक पैरामीटर के शून्य होने पर डिफ़ॉल्ट मानों को परिभाषित करने के लिए।

उदाहरण दिया गया:

var e = new XElement("Something",
    param == null ? new XElement("Value", "Default")
                  : new XElement("Value", param.ToString())
);

या (धन्यवाद एस्टेराइट)

var e = new XElement("Something",
    new XElement("Value",
        param == null ? "Default"
                      : param.ToString()
    )
);

कोई फर्क नहीं पड़ता कि आप टर्नरी ऑपरेटर का उपयोग करते हैं या नहीं, यह सुनिश्चित करना कि आपका कोड पठनीय है महत्वपूर्ण बात है। किसी भी निर्माण को अपठनीय बनाया जा सकता है।

Comments

या ... var e = नया XElement ("कुछ", नया XElement ("मान", param == null; "डिफ़ॉल्ट": param.toString ()));

— एस्टोराइट

मुझे पसंद है कि आप इसे पठनीयता के लिए स्वरूपित कर रहे हैं, इतने सारे नहीं हैं।

— ब्रुसेक

यदि मानव पठनीय नहीं है तो मानव पठनीय स्रोत कोड कितना अच्छा है? =)

— एरिक फोर्ब्स

Answer 11

मैं जहां कभी भी कर सकता हूं, वहां मैं टर्नरी ऑपरेटर का उपयोग करता हूं, जब तक कि यह कोड को पढ़ने के लिए बहुत कठिन नहीं बनाता है, लेकिन तब यह आमतौर पर सिर्फ एक संकेत होता है कि मेरा कोड थोड़ा रिफैक्टिंग का उपयोग कर सकता है।

यह हमेशा मुझे याद दिलाता है कि कैसे कुछ लोग सोचते हैं कि टर्नरी ऑपरेटर एक "छिपी हुई" विशेषता है या कुछ रहस्यमय है। यह पहली चीजों में से एक है जिसे मैंने सी में प्रोग्रामिंग शुरू करते समय सीखा था, और मुझे नहीं लगता कि यह पठनीयता कम हो जाती है। यह भाषा का एक स्वाभाविक हिस्सा है।

Comments

मैं पूरी तरह से सहमति में हूं। इसके बारे में कुछ भी छिपा या मुश्किल नहीं है।

— एममैटैक्स

यह पठनीयता के मुद्दों का कारण बन सकता है, खासकर जब नेस्टेड हो।

— डेविड थॉर्नले

मुझे लगता है कि " पढ़ने के लिए बेहद कठिन" थोड़ा बहुत अनुमति है, लेकिन कुल मिलाकर मैं आपसे सहमत हूं। इसके बारे में कुछ भी मुश्किल या रहस्यमय नहीं है।

— एप्सिलॉनवेक्टर

Answer 12

(दिन की हैक)

#define IF(x) x ?
#define ELSE :

तो आप कर सकते हैं अगर-तो-अभिव्यक्ति के रूप में:

int b = IF(condition1)    res1
        ELSE IF(condition2)  res2
        ELSE IF(conditions3) res3
        ELSE res4;

Answer 13

मैं jmulder से सहमत हूं: इसका उपयोग a के स्थान पर नहीं किया जाना चाहिए if, लेकिन इसकी वापसी अभिव्यक्ति या अभिव्यक्ति के अंदर के लिए अपनी जगह है:

echo "Result: " + n + " meter" + (n != 1 ? "s" : "");
return a == null ? "null" : a;

पूर्व सिर्फ एक उदाहरण है, बहुवचन के बेहतर i18n समर्थन का उपयोग किया जाना चाहिए!

Comments

पहला टर्नरी गलत है - आपको एक: कहाँ है? जाना चाहिए: (n! = 1 ? "s": "")

— एरिक फोर्ब्स

हाँ, यह इंगित करने के लिए धन्यवाद! फिक्स्ड।

— फीलो

Answer 14

यदि आप एक साधारण सशर्त असाइनमेंट के लिए टर्नरी ऑपरेटर का उपयोग कर रहे हैं तो मुझे लगता है कि यह ठीक है। मैंने देखा है कि यह (एब) प्रोग्राम फ्लो को नियंत्रित करने के लिए उपयोग किया जाता है, यहां तक ​​कि एक असाइनमेंट किए बिना भी, और मुझे लगता है कि इसे टाला जाना चाहिए। इन मामलों में एक बयान का उपयोग करें।

Answer 15

मुझे लगता है कि जरूरत पड़ने पर टर्नरी ऑपरेटर का उपयोग किया जाना चाहिए। यह स्पष्ट रूप से एक बहुत ही व्यक्तिपरक विकल्प है, लेकिन मुझे लगता है कि एक साधारण अभिव्यक्ति (विशेष रूप से एक वापसी अभिव्यक्ति के रूप में) एक पूर्ण परीक्षा की तुलना में बहुत स्पष्ट है। C / C ++ में उदाहरण:

return (a>0)?a:0;

की तुलना में:

if(a>0) return a;
else return 0;

आपके पास ऐसा मामला भी है जहां समाधान टर्नरी ऑपरेटर के बीच होता है और एक फ़ंक्शन बनाता है। उदाहरण के लिए पायथन:

l = [ i if i > 0 else 0 for i in lst ]

विकल्प है:

def cap(value):
    if value > 0:
        return value
    return 0
l = [ cap(i) for i in lst ]

यह पर्याप्त है कि पायथन में (उदाहरण के रूप में), ऐसा मुहावरा नियमित रूप से देखा जा सकता है:

l = [ ((i>0 and [i]) or [0])[0] for i in lst ]

यह पंक्ति पायथन में तार्किक संचालकों के गुणों का उपयोग करती है: वे आलसी हैं और अंतिम स्थिति के बराबर होने पर गणना की गई अंतिम मान लौटाते हैं।

Comments

वह आखिरी पंक्ति मेरे मस्तिष्क को चोट पहुँचाती है ...

— एरिक फोर्ब्स

Answer 16

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

Answer 17

मैंने ऐसे जानवरों को देखा है (यह वास्तव में बहुत बुरा था क्योंकि यह isValidDate था और महीने और दिन की जाँच की, लेकिन मैं पूरी बात याद रखने की कोशिश कर परेशान नहीं हो सकता)

isLeapYear =
    ((yyyy % 400) == 0)
    ? 1
    : ((yyyy % 100) == 0)
        ? 0
        : ((yyyy % 4) == 0)
            ? 1
            : 0;

जहां, स्पष्ट रूप से, अगर-कथनों की एक श्रृंखला बेहतर होती (हालांकि यह मैक्रो संस्करण की तुलना में बेहतर है जो मैंने एक बार देखा था)।

मैं इसे छोटी चीजों के लिए बुरा नहीं मानता हूँ:

reportedAge = (isFemale && (Age >= 21)) ? 21 + (Age - 21) / 3 : Age;

या यहां तक ​​कि थोड़ा मुश्किल चीजों की तरह:

printf ("Deleted %d file%s\n", n, (n == 1) ? "" : "s");

Comments

यदि बयान अधिक पठनीय होंगे तो आप अलग-थलग कैसे कह सकते हैं ? मैंने आपका "जानवर" ठीक पढ़ा । reportedAgeउदाहरण है कि कुछ समझ में आता है - शायद क्योंकि यह एक विशेष मामले की तुलना में अधिक हैisThisYearALeapYear

— एक्समेन

Answer 18

खैर, इसके लिए वाक्य रचना भयावह है। मुझे कार्यात्मक आईपीएस बहुत उपयोगी लगते हैं, और अक्सर कोड को अधिक पठनीय बनाता है।

मैं इसे और अधिक पठनीय बनाने के लिए एक मैक्रो बनाने का सुझाव दूंगा, लेकिन मुझे यकीन है कि कोई भयानक किनारे के मामले के साथ आ सकता है (जैसा कि हमेशा सीपीपी के साथ होता है)।

Comments

कई मूल कार्यान्वयन और वेरिएंट में एक IF फ़ंक्शन होता है जो टर्नरी ऑपरेटर की जगह लेता है। मैंने सी में एक मैक्रो के रूप में परिभाषित कई कोडबेस देखे हैं

— स्पर्स

खैर, मैं कार्यात्मक प्रोग्रामिंग भाषाओं के बारे में सोच रहा था, लेकिन हाँ।

— मार्सिन

"इसे अधिक पठनीय बनाने के लिए मैक्रो बनाना," आप काफी जोकर हैं!

— niXar

Answer 19

मुझे त्रुटि मान मुद्रित करने के लिए डिबग कोड में ऑपरेटर का उपयोग करना पसंद है ताकि मुझे हर समय उन्हें देखना न पड़े। आमतौर पर मैं डिबग प्रिंट के लिए ऐसा करता हूं जो एक बार विकसित होने के बाद भी नहीं रहने वाले हैं।

int result = do_something();
if( result != 0 )
{
  debug_printf("Error while doing something, code %x (%s)\n", result,
                result == 7 ? "ERROR_YES" :
                result == 8 ? "ERROR_NO" :
                result == 9 ? "ERROR_FILE_NOT_FOUND" :
                "Unknown");
}

Comments

scnr: thedailywtf.com/Articles/What_Is_Truth_0x3f_.aspx

— Meinersbur

Answer 20

मैं लगभग कभी भी टर्नरी ऑपरेटर का उपयोग नहीं करता हूं क्योंकि जब भी मैं इसका उपयोग करता हूं, तो यह हमेशा मुझे एक बहुत अधिक लगता है कि मुझे बाद में जब मैं इसे बनाए रखने की कोशिश करता हूं।

मुझे वर्बोसिटी से बचना पसंद है, लेकिन जब यह कोड को लेने में बहुत आसान बनाता है, तो मैं वर्बोसिटी के लिए जाऊंगा।

विचार करें:

String name = firstName;

if (middleName != null) {
    name += " " + middleName;
}

name += " " + lastName;

अब, यह थोड़ा क्रियात्मक है, लेकिन मुझे इसकी तुलना में बहुत अधिक पठनीय लगता है:

String name = firstName + (middleName == null ? "" : " " + middleName)
    + " " + lastName;

या:

String name = firstName;
name += (middleName == null ? "" : " " + middleName);
name += " " + lastName;

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

Comments

हालांकि यह बिल्कुल वैसी बात नहीं है। दूसरे उदाहरण में आप तीनों कथनों को एक पंक्ति में संपीड़ित कर रहे हैं। यही कारण है कि पठनीयता कम हो जाती है, न कि टर्नरी ऑपरेटर।

— २३:५३ पर ilitirit

पर्याप्त रूप से, मैंने आपकी टिप्पणी को शामिल करने के लिए अद्यतन किया, लेकिन यह अभी भी मेरे लिए अव्यवस्थित लगता है ... लेकिन फिर, यह व्यक्तिपरक है ... मैं कह रहा हूं कि टर्नरी पठनीय नहीं है, मैं कह रहा हूं कि यह मेरे लिए पठनीय नहीं है (99) समय का%)

— माइक स्टोन

Answer 21

केवल जब:

$ var = (सरल> परीक्षण; simple_result_1: simple_result_2);

चुम्मा।

Answer 22

मैं आमतौर पर इस तरह की चीजों में उपयोग करता हूं:

before:

if(isheader)
    drawtext(x,y,WHITE,string);
else
    drawtext(x,y,BLUE,string);

after:

    drawtext(x,y,isheader==true?WHITE:BLUE,string);

Comments

अधिकांश भाषाओं में, आपको उस टर्नरी के "== सत्य" भाग की आवश्यकता नहीं होगी।

— माइकल हरेन

मुझे एहसास है कि, हालांकि मैं इसे केवल कोड को अधिक पठनीय बनाने के लिए डाल देता हूं क्योंकि कंपाइलर को इसे उसी चीज़ के बिना ऑप्टिमाइज़ करना चाहिए जैसा कि == सच वैसे भी

— केपीएक्सईए

में कोई भाषा आप संभवतः की जरूरत है सकते हैं "== सच"

— niXar

मुझे यह तय करने में कठिन समय था कि क्या उखाड़ना है या नहीं। उदाहरण अच्छा है, लेकिन == सच कुछ ऐसा है जिसे मैं अन्य लोगों के कोड में नहीं देख सकता।

— पीटर पेर्क

Answer 23

जैसा कि दूसरों ने बताया है कि वे छोटी सरल स्थितियों के लिए अच्छे हैं। मैं विशेष रूप से उनकी तरह चूक (तरह के प्रकार के लिए || और या , जैसे जावास्क्रिप्ट और अजगर में उपयोग)

int repCount = pRepCountIn ? *pRepCountIn : defaultRepCount;

एक अन्य सामान्य उपयोग C ++ में एक संदर्भ को इनिशियलाइज़ करना है। चूंकि संदर्भों को घोषित किया जाना है और एक ही बयान में आरंभीकृत किया गया है आप एक if स्टेटमेंट का उपयोग नहीं कर सकते हैं।

SomeType& ref = pInput ? *pInput : somethingElse;

Comments

आश्चर्यजनक है कि यह शुरुआती संदर्भों का पहला उल्लेख है, जो उन कुछ स्थानों में से एक है जहां "यदि" का उपयोग इसके बजाय नहीं किया जा सकता है:। (मुझे लगता है क्योंकि यह एक C ++ - विशिष्ट प्रश्न नहीं है ...) वे एक ही कारण के लिए, कंस्ट्रक्शन आरंभीकरण सूचियों में भी उपयोगी हैं।

— j_random_hacker

Answer 24

मैं टर्नरी संचालकों को GOTO की तरह मानता हूं। उनके पास अपनी जगह है, लेकिन वे कुछ ऐसे हैं, जिन्हें आपको आमतौर पर कोड को समझने में आसान बनाने से बचना चाहिए।

Answer 25

मैंने हाल ही में टर्नरी ऑपरेटरों पर एक भिन्नता देखी (अच्छी तरह से) जो मानक बनाते हैं "() ?:" वैरिएंट स्पष्टता का एक प्रतिमान प्रतीत होता है:

var Result = [CaseIfFalse, CaseIfTrue][(boolean expression)]

या, अधिक मूर्त उदाहरण देने के लिए:

var Name = ['Jane', 'John'][Gender == 'm'];

ध्यान रहे, यह जावास्क्रिप्ट है, इसलिए इस तरह की चीजें अन्य भाषाओं में संभव नहीं हो सकती हैं (धन्यवाद)।

Comments

वाह, यह बहुत ही भयानक है! एक साथ उन लोगों के घोंसले के शिकार की कल्पना करो! केवल एक उपयोगी चीज जो मैं देख सकता हूं, वह यह है कि अगर आपके पास एक फ़ंक्शन था जो 2-तत्व सरणी लौटाता है: var Name = getNames () [लिंग == 'm']; ... लेकिन यह भी कम पठनीय है!

— निकफ

Answer 26

सरल मामलों के लिए, मुझे इसका उपयोग करना पसंद है। वास्तव में उदाहरण के लिए कार्यों / चीजों के मापदंडों के रूप में पढ़ना / कोड करना बहुत आसान है। इसके अलावा नई लाइन से बचने के लिए मैं अपने सभी के साथ रखना पसंद करता / करती हूं।

Neseting यह मेरी पुस्तक में एक बड़ा NO-NO होगा।

तो, फिर से शुरू, एक एकल के लिए / नहीं तो मैं टर्नरी ऑपरेटर का उपयोग करूंगा। अन्य मामलों के लिए एक नियमित अगर / और अगर / अन्यथा (या स्विच)

Answer 27

मुझे ग्रोवी के टर्नरी ऑपरेटर का विशेष मामला पसंद है, जिसे एल्विस ऑपरेटर कहा जाता है:?:

expr ?: default

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

Comments

हाँ, मुझे लगता है कि एक के रूप में अच्छी तरह से प्यार करता हूँ - यह ??सी # में, अशक्त सम्मिलित ऑपरेटर: stackoverflow.com/questions/278703/...

— जारोड डिक्सन

Answer 28

साधारण कार्यों के लिए एक शर्त के आधार पर एक अलग मूल्य प्रदान करना जैसे वे बहुत अच्छे हैं। मैं उनका उपयोग तब नहीं करूंगा जब हालत थओ के आधार पर लंबे समय तक अभिव्यक्ति हो।

Answer 29

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

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

x[if y > 5 then 5 else y] := "Y" 

... जो मुझे एक टर्निरी तुलना ऑपरेटर की तुलना में बहुत अधिक पठनीय लगता है। :-)

?:ऑपरेटर को आइकन में जोड़ने की संभावना के बारे में हाल ही में एक चर्चा हुई थी , लेकिन कई लोगों ने सही ढंग से बताया कि रास्ते की वजह से कोई ज़रूरत नहीं थीif काम करता है ।

जिसका अर्थ है कि यदि आप ऐसा कर सकते हैं कि C (या अन्य भाषाओं में जो टर्निरी ऑपरेटर है), तो आप वास्तव में, टर्निरी ऑपरेटर की आवश्यकता नहीं होगी।

Answer 30

यदि आप और आपके काम करने वाले समझते हैं कि वे क्या करते हैं और वे बड़े समूहों में नहीं बने हैं, तो मुझे लगता है कि वे कोड को कम जटिल बनाते हैं और पढ़ने में आसान होते हैं क्योंकि बस कम कोड होता है।

केवल एक बार जब मुझे लगता है कि टर्नरी ऑपरेटर कोड को समझना मुश्किल बनाते हैं, जब आपके पास एक पंक्ति में 3 या 4 से अधिक हो। ज्यादातर लोगों को यह याद नहीं है कि वे सही तरह से पूर्वता पर आधारित हैं और जब आपके पास उनमें से एक स्टैक होता है तो यह कोड को एक बुरा सपना बना देता है।