लेखन श्रृंखला कोड को कैसे रोकें?

Question

उदाहरण के लिए

...

if (/* Condition */) { 

    if (/* Condition */) { 

     if (/* Condition */) { 

      // Superb! 

     } else { 

      // Error 3 

     } 

    } else { 

     // Error 2 

    } 

} else { 

    // Error 1 

} 

क्या आप जानते हैं कि यह कैसे से बचने के लिए करते हैं? धन्यवाद!

Answer 1

यदि यह एक लाइब्रेरी फ़ंक्शन है, throw उचित कार्रवाई हो सकती है।

if (!condition1) { 
    throw "Condition 1 failed."; 
} 

if (!condition2) { 
    throw "Condition 2 failed."; 
} 

if (!condition3) { 
    throw "Condition 3 failed."; 
} 

// Superb! 

अन्य स्वीकार्य कार्रवाई हो सकती है:

• 0, null, या undefined रिटर्निंग।
• उपयोगकर्ता को एक त्रुटि प्रदर्शित करने और लौटने पर।

आपको यह निर्धारित करना होगा कि आपके उपयोग के मामले में कौन सी विफलता कार्रवाई सही है।

Answer 2

क्या आप इसे पसंद करेंगे?

if (/* Condition 1*/ && /* Condition 2*/ && /* Condition 3 */) { 
    // Superb! 
} 
else if (! /* Condition 1*/){ 
    // Error 1 
} 
else if (! /* Condition 2*/){ 
    // Error 2 
} 
else if (! /* Condition 3*/){ 
    // Error 3 
} 

Answer 3

if (! /* Condition */) { 
Error 1 
throw someSortOfException 
} 

if (! condition 2){ 
Error 2 
throw someSortOfOtherException 
} 

if (! condition 3){ 
Error 3 
throw another Exception 
} 

// Success! 

स्थिति पर निर्भर करता है, अपने कोड पसंद हो सकता है। उदाहरण के लिए आप शायद उन अपवादों को कहीं पकड़ना चाहेंगे।

Answer 4

ठीक है आप अपवाद का उपयोग कर सकते हैं, या ब्लॉक के भीतर तोड़ सकते हैं, या कई फ़ंक्शन। कोड को सही तरीके से आदेश देने के लिए अक्सर इसकी शर्तों को बदलने की आवश्यकता होती है।

do { 
    if (! /* Condition 1 */) { 
     // Error 1 
     break; 
    } 

    if (! /* Condition 2 */) { 
     // Error 2 
     break; 
    } 

    if (! /* Condition 3 */) { 
     // Error 3 
     break; 
    } 

    // Superb! 
} while (false); 

do-, जबकि (गलत) पाश एक ब्लॉक है कि आप जिन भाषाओं में एक गुमनाम ब्लॉक को बर्दाश्त नहीं करेगा में से बाहर तोड़ सकते हैं बनाने का एक तरीका है। यह आसानी से एक समारोह हो सकता है और रिटर्न का उपयोग कर सकता है, या अपवादों के साथ प्रयास कर सकता है।

Answer 5

if (!condition1) 
    // Error 1 (and exit scope if necessary) 

if (!condition2) 
    // Error 2 (and exit scope if necessary) 

if (!condition3) 
    // Error 3 (and exit scope if necessary) 

// Superb! 

Answer 6

हां; आप अपने if कथन को एक ऑपरेटर का उपयोग करके एक एकल कंपाउंड स्टेटमेंट में एक साथ लिख सकते हैं, और एक ही ब्लॉक में त्रुटि शर्तों को संभाल सकते हैं। आपकी त्रुटि प्रबंधन आवश्यकताओं के आधार पर, आपको यह सुनिश्चित करने के लिए कि आप सही ढंग से त्रुटि को संभालने में सक्षम हैं, यह आपको कई if एस की आवश्यकता हो सकती है (यह वास्तव में आपके त्रुटि हैंडलिंग रिज़ॉल्यूशन पर निर्भर करता है)।

बुद्धि के लिए:

if (CondA && CondB && CondC) 
    { 
    // Execute success 
    } 
else 
    { 
    if (!CondA) 
     // Do error A 
    else if (!CondB) 
     // Do error B 
    else if (!CondC) 
    // Do error C 
    } 
} 

Answer 7

ऐसा लगता है कि जाँच करने के लिए 3 की स्थिति और 4 क्रिया (3 अलग त्रुटियों +1 सफलता) है। दुर्भाग्य से सामान्य मामले में इसे 3 सशर्त चेक और 4 कार्यों की आवश्यकता होगी। मुझे लगता है कि कोड निम्नलिखित संरचना का उपयोग करके थोड़ा साफ किया जा सकता है, हालांकि

if (! /* condition 1 */) { 
    // Error 1 
} else if (! /* condition 2 */) { 
    // Error 2 
} else if (! /* condition 3 */) { 
    // Error 3 
} else { 
    // superb 
} 

Answer 8

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

if (/* Condition */) { 
    value = aFunctionSaysWhat(); 
} else { 
    // value = Error 1 
} 

.... 
value aFunctionSaysWhat(){ 
    if (/* Condition */) { 
     return aSecondFunctionHere(); 
    } else { 
     // return Error 2 
    } 
} 

मूल आधार है कि एक समारोह अमूर्त यदि संभव हो तो से एक परत पर रहना चाहिए, और एक काम करते है।

अगली संभावना यह सब बाहर निकलना है, यह आपके प्रारंभिक नेस्टेड विधि से बेहतर है, लेकिन मूल रूप से समान जटिलता है। यदि आपके पास केवल कुछ विकल्प हैं और आप अधिक जोड़ने की योजना नहीं बनाते हैं तो यह कार्यात्मक दृष्टिकोण से अधिक क्लीनर हो सकता है।

if(ErrorCondition1){ 
    //Error 1 
}else if(ErrorCondition2){ 
    //Error 2 
}else if(ErrorCondition3){ 
    //Error 3 
}else{ 
    //Superb 
} 

अंत में, आप एक हैश की दुकान या वांछित जवाब के साथ नक्शा और अगर पूरी तरह से हटा सकते हैं, यह आपकी क्षमता पर निर्भर करता है को लागू करने की क्षमता कुछ परिणाम हैश करने के लिए:

Results = {'Result1':'Error1', 'Result2':'Error2', 'Result3':'Error3', 'Success':'Superb'} 

return Results[ConditionHash(Condition)];