कैसे कई में ध्वज को संभालने के लिए अगर

Question

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

If variable == A
    if (Flag == true)
        doFooA()
    else
        doFooA2

else if variable == B
    if (Flag == true)
        doFooB()
    else
        doFooB2
else if variable == C
    if (Flag == true)
        doFooC()
    else
        doFooC2

ऐसा लगता है कि इसे "फैक्टर" करने के कई तरीके हैं, जैसे कि इफ़-इलेज़ के 2 सेट, जहाँ फ्लैग == सही होने पर एक सेट हैंडल होता है।

क्या यह कारक के लिए एक "अच्छा तरीका" है, या शायद जब यह अगर-और एल्गोरिथ्म होता है तो आमतौर पर इसका मतलब है कि आप कुछ गलत कर रहे हैं?

Comments

क्या फ्लैग वैरिएबल को doFooX से गुजारना संभव हो सकता है जो स्वयं फ्लैग से निपट सकता है?

— जीन-फ्रांस्वा कोटे

यकीन है लेकिन फिर आपके पास बस एक तरीका है doFooX, जो मूल्यांकन करता है कि क्या झंडा सच है और फिर doFooX1 या doFooX2 करता है

— TruthOf42

IMHO, यह अभी भी पढ़ने के लिए स्पष्ट हो जाएगा। फिर यह निर्भर करता है कि doFooA और doFooA2 क्या करते हैं ...

— जीन-फ्रांस्वा कोटे

if (Flag == true)सिर्फ लिखने के बजाय क्यों लिखें If (Flag)? अगर आपको लगता है कि If (Flag == true)बेहतर है, तो क्यों नहीं if ((Flag == true) == true)?

— कीथ थॉम्पसन

नीचे दिए गए अधिकांश उत्तरों से सबसे महत्वपूर्ण यह है कि तार्किक प्रवाह और कोड को भविष्य में बनाए रखने के लिए सादगी और सुगमता चालाक चाल से कहीं अधिक महत्वपूर्ण है ।

— पैट्रिक ह्यूजेस

Answer 1

इसे बहुरूपता से संभाला जा सकता है।

factory(var, flag).doFoo();

जब भी आपके पास किसी चीज़ के प्रकार पर चेक / if का एक गुच्छा होता है, तो आप फ़ैक्टरी विधि में if / अन्यथा चेक को केंद्रीकृत करने पर विचार कर सकते हैं, फिर doFoo () पॉलीमॉर्फिक कॉलिंग। लेकिन 1-समाधान के लिए यह ओवर-किल हो सकता है।

हो सकता है कि आप एक कुंजी / मान मानचित्र बना सकते हैं जहाँ कुंजी var / ध्वज है, और मान ही कार्य है।

do[var, flag]();

Comments

+1: टेबल लुकअप ने लगभग हर बार स्टेटमेंट्स को नेस्टेड बीट किया।

— केविन क्लाइन

मैं कहना चाहता हूं कि यह सबसे अच्छा समाधान है।

— मफिन मैन

Answer 2

एकाधिक नेस्टेड ifs कोड की चक्रीय जटिलता को बढ़ाते हैं। हाल ही में, फ़ंक्शंस में कई एग्ज़िट पॉइंट्स होने से खराब स्ट्रक्चर्ड कोड को कॉसिड किया गया था, लेकिन अब, जब तक कोड सिंपल है, और शॉर्ट है , आप ऐसा कर सकते हैं, जिससे कोड को पढ़ने के लिए तुच्छ बनाया जा सके:

    if (variable == A && Flag) {
        doFooA();
        return;
    }

    if (variable == A) {
        doFooA2();
        return;
    }

    if (variable == B && Flag){
        doFooB();
        return;
    }

    if (variable == B){
        doFooB2();
        return;
    }

    if (variable == C && Flag){
         doFooC();
         return;
    }

    if (variable == C){
         doFooC2();
    }

    return;

Answer 3

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

if (flag)
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
    }
}
else // flag == false
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
}

Answer 4

खैर, यह हमेशा है ...

if variable == A && Flag
    doFooA()
else if variable == A 
    doFooA2    
else if variable == B && Flag
    doFooB()
else if variable == B
    doFooB2
else if variable == C && Flag
     doFooC()
else if variable == C
     doFooC2

लेकिन स्पष्ट रूप से, मुझे लगता है कि पहली जगह में मूल कोड आधा बुरा नहीं है।

Answer 5

बहुरूपता और एक ruleसरणी का उपयोग करें

interface IRule() {
  boolean applicable(args...);
  obj apply(args...);
}

static final Array<IRule> rules = [new MeaningfulNameRule1(), new MeaningfulNameRule2(), ...];

/* where */
class MeaningfulNameRuleX extends IRule{ /* */ }

/* In your method */

for (rule in rules) {
  if (rule.applicable(a,b,c)){
    return rule.apply(e,f,g);
  }
}

या जैसा कि mike30सुझाव दिया गया है: यदि नियम की शर्तें आसानी से एक कुंजी बना सकती हैं तो एक हैशमाप सबसे अच्छा तरीका है।