क्या मुझे किसी फ़ंक्शन से जल्दी लौटना चाहिए या यदि एक स्टेटमेंट का उपयोग करना चाहिए? [बन्द है]

Question

मैंने अक्सर दोनों प्रारूपों में इस प्रकार के फ़ंक्शन को लिखा है, और मैं सोच रहा था कि क्या एक प्रारूप दूसरे पर पसंद किया जाता है, और क्यों।

public void SomeFunction(bool someCondition)
{
    if (someCondition)
    {
        // Do Something
    }
}

या

public void SomeFunction(bool someCondition)
{
    if (!someCondition)
        return;

    // Do Something
}

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

Comments

मुझे इस चर्चा में थोड़ी देर हो गई है इसलिए मैं इसे एक उत्तर में नहीं रखूंगा; मैंने इस बारे में दो साल पहले भी सोचा था: lecterror.com/articles/view/code-formatting-and-readability मुझे पढ़ने, संशोधित करने, बनाए रखने और डिबग करने के लिए दूसरा आसान लगता है। लेकिन हो सकता है कि मैं सिर्फ :) :)

— हनीबल लेक्टर

संबंधित: "केवल एक वापसी" की धारणा कहां से आई?

— यानिस

अब यह प्रश्न एक राय-आधारित प्रश्न का एक अच्छा उदाहरण है

— रुडोल्फ ओलह

तो क्या होगा अगर एक या किसी अन्य दिशा में कोई पूर्ण प्रमाण नहीं है? जब एक और दूसरी दिशा में पर्याप्त तर्क दिया जाता है और उत्तर सही होने पर मतदान होता है - यह इसे बहुत उपयोगी बनाता है। मुझे इस साइट के मूल्य के लिए हानिकारक होने के लिए इस तरह के समापन प्रश्न मिलते हैं।

— gsf

और मुझे राय आधारित प्रश्न और उत्तर पसंद हैं। वे मुझे बताते हैं कि बहुमत क्या पसंद करता है और इससे मुझे दूसरों को पढ़ने के लिए कोड लिखने की सुविधा मिलती है।

— ज़िगिमंतास

Answer 1

मैं दूसरी शैली पसंद करता हूं। अवैध मामलों को पहले से बाहर करें, या तो केवल अपवादों से बाहर निकलें या उपयुक्त के रूप में उठाएं, वहां एक रिक्त रेखा डालें, फिर विधि के "वास्तविक" शरीर को जोड़ें। मुझे पढ़ना आसान लगता है।

Comments

स्मॉलटाक इन "गार्ड क्लॉस" को बुलाता है। कम से कम यही केंट बेक उन्हें स्मॉलटाकल बेस्ट प्रैक्टिस पैटर्न में कहता है; मुझे नहीं पता कि यह सामान्य समानता है।

— फ्रैंक शीयर

जल्दी बाहर निकलने से आप अपने सीमित मानसिक ढेर से सामान निकाल सकते हैं। :)

— जोरेन

मैंने पहले सुना है कि इसे "बाउंसर पैटर्न" के रूप में संदर्भित किया जाता है - दरवाजे में आने से पहले खराब मामलों से छुटकारा पाएं।

— RevBingo

मैं यहाँ तक जाऊँगा और कहूँगा कि निश्चित रूप से यह करना सही है।

— ओलिवर वीलर

यदि आप शुरुआत में सीमा के मामलों से छुटकारा पा लेते हैं, तो आप इंडेंट जोड़ते नहीं हैं।

— डोपेलग्रेनर

Answer 2

निश्चित रूप से बाद वाला। पूर्व अभी खराब नहीं दिखता है, लेकिन जब आपको अधिक जटिल कोड मिलता है, तो मैं सोच भी नहीं सकता कि कोई भी ऐसा सोचेगा:

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    int retval = SUCCESS;
    if (someCondition)
    {
        if (name != null && name != "")
        {
            if (value != 0)
            {
                if (perms.allow(name)
                {
                    // Do Something
                }
                else
                {
                    reval = PERM_DENY;
                }
            }
            else
            {
                retval = BAD_VALUE;
            }
        }
        else
        {
            retval = BAD_NAME;
        }
    }
    else
    {
        retval = BAD_COND;
    }
    return retval;
}

से अधिक पठनीय है

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    if (!someCondition)
        return BAD_COND;

    if (name == null || name == "")
        return BAD_NAME;

    if (value == 0)
        return BAD_VALUE;

    if (!perms.allow(name))
        return PERM_DENY;

    // Do something
    return SUCCESS;
}

मैं पूरी तरह से स्वीकार करता हूं कि मैंने एकल निकास बिंदुओं के लाभ को कभी नहीं समझा।

Comments

एक निकास बिंदु का लाभ यह है कि ... एक एकल निकास बिंदु है! आपके उदाहरण के साथ, कई बिंदु हैं जो वापस आ सकते हैं। अधिक जटिल फ़ंक्शन के साथ, जब रिटर्न वैल्यू में बदलाव होता है, तो शिकार-ए-एग्जिट-पॉइंट में बदल सकता है। बेशक, ऐसा कई बार होता है जब किसी एकल निकास बिंदु से कोई मतलब नहीं होता।

— जॉनएल

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

— दान रोसेनस्टार्क

@ यार: सच है, लेकिन बिंदु खड़ा है। मैं किसी को भी बदलने और बदलने की कोशिश नहीं कर रहा हूं, और मैं बस कुछ एक्ज़िट पॉइंट्स के लिए जाने का फायदा बता रहा था (और वैसे भी जेसन का उदाहरण स्ट्रॉ मैन की तरह था)। अगली बार जब आप अपने बालों को बाहर निकालने की कोशिश कर रहे हों, तो यह जानने की कोशिश करें कि SomeFunction कभी-कभी अजीब मान देता है, शायद आप चाहते हैं कि आप वापसी से ठीक पहले एक लॉगिंग कॉल जोड़ सकें । यदि बगर्स में से केवल एक ही पर डिबग करना ज्यादा आसान है! :)

— जॉनएल

@ जेसन वियर्स मानो एक ही return value;मदद करता है!?! फिर किसी को आधा दर्जन शिकार करना होगा value = ..., इस नुकसान के साथ कि आप कभी भी निश्चित नहीं हैं कि इस असाइनमेंट और अंतिम रिटर्न के बीच मूल्य नहीं बदला जाएगा। कम से कम तत्काल वापसी स्पष्ट है कि अब कुछ भी परिणाम नहीं बदलेगा।

— सोजर्ड

@ खुश: मैं यहाँ दूसरी Sjoerd। यदि आप परिणाम को लॉग इन करना चाहते हैं, तो आप कॉलर साइट पर लॉग इन कर सकते हैं। यदि आप कारण जानना चाहते हैं, तो आपको प्रत्येक एग्जिट पॉइंट / असाइनमेंट पर लॉग इन करना होगा, इसलिए दोनों इस पहलू में समान हैं।

— मैथ्यू एम।

Answer 3

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

हालांकि, अगर किसी फ़ंक्शन को कॉल करने के लिए कुछ डेटा की आवश्यकता होती है, तो मैं आमतौर पर केवल अपवाद (उदाहरण देखें) को फेंकने जा रहा हूं, क्योंकि यह केवल लौटने का विरोध करता है।

public int myFunction(string parameterOne, string parameterTwo) {
  // Can't work without a value
  if (string.IsNullOrEmpty(parameterOne)) {
    throw new ArgumentNullException("parameterOne");
  } 
  if (string.IsNullOrEmpty(parameterTwo)) {
    throw new ArgumentNullException("parameterTwo");
  }

  // ...      
  // Do some work
  // ...

  return value;
}

Comments

और अगर अंतिम परिणाम बनाए रखने योग्य है, तो कौन परवाह करता है कि किस शैली का चयन किया गया था?

— जेफ सिवर

@ जेफ सिवर - इस प्रकार यह एक "पवित्र-युद्ध" शैली का प्रश्न है, दिन के अंत में यह व्यक्तिगत प्राथमिकता के लिए नीचे आता है और जो भी एक आंतरिक शैली गाइड कहता है।

— rjzii

यहां महत्वपूर्ण बात यह है कि वह जल्दी लौटने के बजाय अपवाद फेंक रहा है। वैधता जांच के लिए रिटर्न वैल्यू को फिर से नहीं लगाया जाना चाहिए। यदि आपके पास विभिन्न शर्तें थीं और विधि का उपयोग करके कोड को यह बताने देना चाहते थे कि यह विफल क्यों हुआ? अचानक आप वास्तविक व्यवसाय डेटा, कुछ भी (खाली परिणाम) या कई अलग-अलग तार, कोड, अंक, ... एक एकल विधि से वापस कर सकते हैं। बस यह वर्णन करने के लिए कि यह क्यों विफल रहा। जी नहीं, धन्यवाद।

— दानमैन

जैसा कि मेरे संकलक ने बताया कि चक्रवाती जटिलता के बारे में क्या है? अगर यह मदद कर सकता है तो घोंसला कोड नहीं करना बेहतर है?

— l

Answer 4

मैं जल्दी वापसी पसंद करता हूं।

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

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

Answer 5

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

C ++ प्रोग्रामिंग में आपके पास विध्वंसक हैं और अब भी स्कोप-एग्जिट गार्ड हैं। कोड को सुनिश्चित करने के लिए इन सभी को यहां होना चाहिए, पहली जगह में अपवाद सुरक्षित है, इसलिए कोड को जल्दी बाहर निकलने से बचाया जाता है और इसलिए ऐसा करने से कोई तार्किक गिरावट नहीं होती है और यह पूरी तरह से एक स्टाइल मुद्दा है।

मैं जावा के बारे में पर्याप्त जानकार नहीं हूं, चाहे "अंत में" ब्लॉक कोड कहा जाए और क्या कुछ सुनिश्चित करने के लिए फाइनलर्स जरूरत की स्थिति को संभाल सकते हैं।

सी # मैं निश्चित रूप से जवाब नहीं दे सकता।

डी-लैंग्वेज आपको उचित बिल्ट-इन स्कोप-एग्जिट गार्ड देती है और इसलिए जल्दी बाहर निकलने के लिए अच्छी तरह से तैयार होती है और इसलिए स्टाइल के अलावा कोई अन्य मुद्दा पेश नहीं करना चाहिए।

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

Comments

C ++ रिटर्न वैल्यू ऑप्टिमाइजेशन नामक कुछ चीज़ों की अनुमति देता है जो कंपाइलर को अनिवार्य रूप से कॉपी ऑपरेशन को छोड़ देने की अनुमति देता है जो सामान्य रूप से तब होता है जब आप कोई मान लौटाते हैं। हालाँकि, विभिन्न परिस्थितियों में ऐसा करना कठिन है, और कई रिटर्न मान उन मामलों में से एक है। दूसरे शब्दों में, C ++ में कई रिटर्न वैल्यू का उपयोग करने से वास्तव में आपका कोड धीमा हो सकता है। यह निश्चित रूप से एमएससी पर पकड़ है, और यह देखते हुए कि कई संभावित रिटर्न मूल्यों के साथ आरवीओ को लागू करने के लिए काफी मुश्किल (यदि असंभव नहीं है) होगा, यह सभी कंपाइलरों में एक समस्या है।

— ईमोन नेरबोन

सी में, बस का उपयोग करें gotoऔर, संभवतः, दो-बिंदु वापसी। उदाहरण (टिप्पणियों में foo() { init(); if (bad) goto err; bar(); if (bad) goto err; baz(); return 0; err: cleanup(); return 1; }

— कोडिंग

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

— BrandonLWhite

"कोई व्यक्ति आपके कार्य को संपादित कर सकता है" - यह निर्णय लेने के लिए एक हास्यास्पद व्याख्या है। भविष्य में कोई भी कुछ भी कर सकता है। इसका मतलब यह नहीं है कि भविष्य में किसी को चीजों को तोड़ने से रोकने के लिए आपको आज कुछ विशिष्ट करना चाहिए।

— विक्टर यारमा

आपके कोड को बनाए रखने योग्य कहा जाता है। वास्तविक दुनिया में कोड को व्यावसायिक उद्देश्यों के लिए लिखा जाता है और कभी-कभी एक डेवलपर को इसे बदलने की आवश्यकता होती है। उस समय मैंने उस उत्तर को लिखा था, हालांकि मैंने CURL को कैशिंग शुरू करने और स्पेगेटी गड़बड़ को याद करने के लिए कहा था कि यह वास्तव में आधुनिक C ++ में एक उचित पुनर्लेखन की आवश्यकता थी

— CashCow

Answer 6

जीत के लिए शुरुआती रिटर्न। वे बदसूरत लग सकते हैं, लेकिन बड़े ifरैपर की तुलना में बहुत कम बदसूरत हैं , खासकर अगर जांच करने के लिए कई स्थितियां हैं।

Answer 7

मैं दोनों का उपयोग करता हूं।

यदि DoSomethingकोड की 3-5 पंक्तियाँ हैं तो पहले स्वरूपण विधि का उपयोग करके कोड केवल सुंदर दिखता है।

लेकिन अगर इसकी तुलना में कई अधिक लाइनें हैं, तो मैं दूसरा प्रारूप पसंद करता हूं। मुझे पसंद नहीं है जब उद्घाटन और समापन कोष्ठक एक ही स्क्रीन पर नहीं होते हैं।

Comments

सुंदर कोई रास्ता नहीं! बहुत ज्यादा इंडेंटेशन!

— जिमीकेन

@ जिमीकेन केवल इतना इंडेंटेशन है जो 3-5 लाइनों में हो सकता है, विशेष रूप से आपको 2 (?) लाइनों की आवश्यकता होती है, बाकी का स्तर इंडेंट हो जाता है: एक नियंत्रण-संरचना और ब्लॉक की शुरुआत के लिए, एक ब्लॉक के अंत के लिए।

— Deduplicator

Answer 8

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

एक और तरीका रखो, यह इस बारे में तर्क करना आसान है कि आपका सॉफ्टवेयर नियमित रूप से बाहर निकल जाएगा यदि आपके पास केवल 1 रिटर्न है। जो अपवादों के खिलाफ एक तर्क भी है।

आमतौर पर मैं शुरुआती रिटर्न को कम से कम करता हूं।

Comments

लेकिन एक औपचारिक विश्लेषण उपकरण के लिए आप उपकरण की ज़रूरत वाले सिमेंटिक्स के साथ एक बाहरी फ़ंक्शन को संश्लेषित कर सकते हैं, और कोड को मानव पठनीय रख सकते हैं।

— टिम विस्क्राफ्ट

@Tim। यह इस बात पर निर्भर करता है कि आप कितनी तन्हाई करना चाहते हैं और आप क्या विश्लेषण कर रहे हैं। मुझे लगता है कि कोडर चीजों के बारे में समझदार था, तो मैं काफी पढ़ सकता हूं।

— पॉल नाथन

विश्लेषण के लिए मेरा दृष्टिकोण स्व परियोजना से अनुकूलन द्वारा आकार का है। 99% डायनेमिक मेथड कॉल्स को स्टेटिकली हल किया जा सकता है और समाप्त किया जा सकता है। तो आप कुछ सुंदर सीधी रेखा कोड का विश्लेषण कर सकते हैं। एक कामकाजी प्रोग्रामर के रूप में, मैं विश्वास कर सकता हूं कि अधिकांश कोड मैं काम करूंगा जो औसत प्रोग्रामर द्वारा लिखा गया था। इसलिए वे बहुत अच्छा कोड नहीं लिखेंगे।

— टिम विस्क्रॉफ्ट

@ समय: पर्याप्त निष्पक्ष। हालाँकि मुझे यह महसूस करने के लिए मजबूर होना पड़ता है कि स्थिर भाषाओं में अभी भी बहुत खेल है।

— पॉल नाथन

एक कारण जो अपवादों का सामना नहीं करता है। यही कारण है कि एकल-निकास सी में महान है, लेकिन आपको सी ++ में कुछ भी नहीं खरीदता है।

— पीटरचेन

Answer 9

व्यक्तिगत रूप से, मैं शुरुआत में पास / फेल हालत जांच करना पसंद करता हूं। यह मुझे फ़ंक्शन के शीर्ष पर सबसे आम विफलताओं के समूह का पालन करने की अनुमति देता है, शेष तर्क का पालन करने के लिए।

Answer 10

निर्भर करता है।

जल्दी वापसी अगर वहाँ कुछ स्पष्ट मृत अंत हालत के लिए सही दूर की जाँच करने के लिए है कि समारोह के बाकी बेकार चला जाएगा। *

यदि फ़ंक्शन अधिक जटिल है, तो रिटवल + एकल वापसी सेट करें, अन्यथा कई निकास बिंदु हो सकते हैं अन्यथा (पठनीयता मुद्दा)।

* यह अक्सर एक डिजाइन समस्या का संकेत कर सकता है। यदि आप पाते हैं कि आपके बहुत से तरीकों को कुछ बाहरी / पैरामाटर स्थिति की जाँच करने की आवश्यकता है या इस तरह के बाकी कोड को चलाने से पहले, तो शायद यह कुछ ऐसा है जिसे कॉलर द्वारा नियंत्रित किया जाना चाहिए।

Comments

जब मैं कोड लिखता हूं जिसे साझा किया जा सकता है, तो मेरा मंत्र है "कुछ भी नहीं मानो। ट्रस्ट नो वन।" आपको हमेशा अपने इनपुट और आपके द्वारा निर्भर किसी भी बाहरी स्थिति को मान्य करना चाहिए। संभवतः किसी भ्रष्ट व्यक्ति की तुलना में अपवाद को फेंकना बेहतर है क्योंकि किसी ने आपको खराब डेटा दिया है।

— TMN

@TMN: अच्छी बात है।

— बॉबी टेबल्स

यहाँ मुख्य बिंदु यह है कि OO में आप एक अपवाद फेंकते हैं , वापस नहीं । कई रिटर्न खराब हो सकते हैं, कई अपवाद थ्रो जरूरी नहीं कि एक कोड गंध हो।

— माइकल के

@MichaelK: यदि पोस्ट-शर्त पूरी नहीं की जा सकती है तो एक विधि को एक अपवाद होना चाहिए। कुछ मामलों में, एक विधि को जल्दी से बाहर निकलना चाहिए क्योंकि फ़ंक्शन शुरू होने से पहले ही पोस्ट-स्थिति प्राप्त हो गई है। उदाहरण के लिए, यदि कोई नियंत्रण के लेबल को बदलने के लिए एक "सेट कंट्रोल लेबल" विधि को लागू करता है Fred, तो विंडो का लेबल पहले से ही है Fred, और नियंत्रण के नाम को उसकी वर्तमान स्थिति में सेट करने से एक redraw मजबूर हो जाएगा (जो, जबकि कुछ मामलों में संभावित रूप से उपयोगी है,) हाथ में गुस्सा होना), अगर पुराने और नए नामों का मिलान होता है, तो सेट-नेम पद्धति को जल्दी से बाहर निकलना पूरी तरह से उचित होगा।

— सुपरकैट

Answer 11

एक का उपयोग करें

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

यदि आप उपरोक्त सलाह का पालन करते हैं, तो आपको फ़ंक्शन के निचले भाग में उस रिटर्न को डालना होगा, और फिर आप इसे वहां रिटर्न भी नहीं कह सकते हैं, बस त्रुटि कोड सेट करें और इसे दो पंक्तियों को वापस कर दें। जिससे 1 प्रविष्टि 1 निकास आदर्श को प्राप्त कर रहा है।

डेल्फी विशिष्ट ...

मेरा मन है कि डेल्फी प्रोग्रामर्स के लिए यह एक अच्छा प्रोग्रामिंग अभ्यास है, हालांकि मेरे पास कोई सबूत नहीं है। प्री-डी 2009, हमारे पास एक परमाणु रास्ता नहीं है कि हम एक मूल्य वापस कर सकें , हमारे पास है exit;और result := foo;या हम सिर्फ अपवादों को फेंक सकते हैं।

अगर आपको स्थानापन्न करना था

if (true) {
 return foo;
} 

के लिये

if true then 
begin
  result := foo; 
  exit; 
end;

आप बस यह देख कर बीमार पड़ सकते हैं कि आपके हर एक कार्य में सबसे ऊपर और पसंद है

if false then 
begin
  result := bar;

   ... 
end
else
   result := foo;

और बस exitपूरी तरह से बचें ।

Comments

नई डेल्फ़िस के साथ, यह संक्षिप्त किया जा सकता है कि if true then Exit(foo);मैं अक्सर पहले या फिर क्रमशः शुरू resultकरने के लिए तकनीक का उपयोग करता हूं , फिर सभी त्रुटि स्थितियों की जांच कर रहा हूं और बस अगर कोई मिला है। सफलता-मामला तब (आमतौर पर) विधि के अंत में कहीं निर्धारित होता है। nilFALSEExit;result

— जेन्सजी

हाँ, मुझे वह नई सुविधा पसंद है, हालांकि ऐसा लगता है कि यह जावा प्रोग्रामर को खुश करने के लिए सिर्फ कैंडी है, अगली बात आपको पता है कि वे हमें प्रक्रियाओं के अंदर हमारे चर को परिभाषित करने देंगे।

— पीटर टर्नर

और सी # प्रोग्रामर। हां, ईमानदार होने के लिए, मुझे लगता है कि वास्तव में उपयोगी होगा क्योंकि यह घोषणा और उपयोग के बीच लाइनों की संख्या कम कर देता है (IIRC वहाँ भी है कि इसके लिए कुछ मीट्रिक है, नाम भूल गया)।

— जेन्सजी

Answer 12

मैं निम्नलिखित कथन से सहमत हूँ:

मैं व्यक्तिगत रूप से गार्ड क्लॉस (दूसरा उदाहरण) का प्रशंसक हूं क्योंकि यह फ़ंक्शन के इंडेंटिंग को कम करता है। कुछ लोग उन्हें पसंद नहीं करते हैं क्योंकि इससे फ़ंक्शन से कई रिटर्न पॉइंट मिलते हैं, लेकिन मुझे लगता है कि यह उनके साथ स्पष्ट है।

इस सवाल से stackoverflow में लिया गया ।

Comments

+1 गार्ड क्लॉस के लिए। मैं एक सकारात्मक रूप से उन्मुख गार्ड को भी पसंद करता हूं जैसे: अगर (स्थिति = असत्य) वापसी के विपरीत अगर ((स्थिति) वापसी

— जस्टिन

Answer 13

मैं इन दिनों लगभग विशेष रूप से शुरुआती रिटर्न का उपयोग चरम सीमा तक करता हूं। मैं यह लिखता हूं

self = [super init];

if (self != nil)
{
    // your code here
}

return self;

जैसा

self = [super init];
if (!self)
    return;

// your code here

return self;

लेकिन यह वास्तव में कोई फर्क नहीं पड़ता। यदि आपके पास अपने कार्यों में घोंसले के शिकार के एक या दो से अधिक स्तर हैं, तो उन्हें समाप्त करने की आवश्यकता है।

Comments

मैं सहमत हूँ। इंडेंटेशन वह है जो पढ़ने में परेशानी पैदा करता है। कम इंडेंटेशन बेहतर है। आपके सरल उदाहरण में समान स्तर का इंडेंटेशन है लेकिन यह पहला उदाहरण निश्चित रूप से अधिक इंडेंटेशन की ओर बढ़ेगा जिसके लिए अधिक मस्तिष्क शक्ति की आवश्यकता होती है।

— user441521

Answer 14

मैं लिखना पसंद करूंगा:

if(someCondition)
{
    SomeFunction();
}

Comments

eww। क्या यह पूर्व-मान्यता है? या यह एक मान्यता-समर्पित mehtod में है DoSomeFunctionIfSomeCondition?

— एसटीडब्ल्यू

यह आपकी चिंताओं को कैसे अलग रखता है?

— justkt

आप फ़ंक्शन के कार्यान्वयन (इसकी निर्भरता तर्क) को बाहरी बनाकर इनकैप्सुलेशन का उल्लंघन कर रहे हैं।

— टीएमएन

यदि यह एक सार्वजनिक विधि में चलाया जाता है और SomeFunction () उसी कक्षा में एक निजी विधि है तो यह ठीक हो सकता है। लेकिन अगर कोई और व्यक्ति SomeFunction () कॉल कर रहा है, तो आपको वहां चेक की नक़ल करनी होगी। मुझे यह बेहतर लगता है कि प्रत्येक विधि को यह ध्यान रखना चाहिए कि उसे अपना काम करने की क्या आवश्यकता है, किसी और को यह जानना नहीं चाहिए।

— प्रति विकलैंडर

यह निश्चित रूप से शैली है जिसे रॉबर्ट सी। मार्टिन ने "क्लीन कोड" में प्रस्तावित किया है। एक फ़ंक्शन को केवल एक काम करना चाहिए। हालांकि "कार्यान्वयन पैटर्न" में, केंट बेक सुझाव देता है, ओपी में प्रस्तावित दो विकल्पों में से, दूसरा बेहतर है।

— स्कॉट व्हिटलॉक

Answer 15

आप की तरह, मैं आमतौर पर पहला लिखता हूं, लेकिन आखिरी पसंद करता हूं। अगर मेरे पास बहुत से नेस्टेड चेक हैं तो मैं आमतौर पर दूसरी विधि के लिए रिफ्लेक्टर करता हूं।

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

if not error A
  if not error B
    if not error C
      // do something
    else handle error C
  else handle error B
else handle error A

यह मेरे लिए ज़्यादा प्रधान है:

if error A
  handle error A; return
if error B
  handle error B; return
if error C
  handle error C; return

// do something

Answer 16

शीर्ष पर स्थितियां "पूर्व शर्त" कहलाती हैं। डालते हुए if(!precond) return;, आप नेत्रहीन सभी पूर्व शर्त को सूचीबद्ध कर रहे हैं।

बड़े "if-else" ब्लॉक का उपयोग करने से इंडेंट ओवरहेड बढ़ सकता है (मैं 3-स्तरीय इंडेंट्स के बारे में उद्धरण भूल गया)।

Comments

क्या? आप जावा में जल्दी वापसी नहीं कर सकते हैं? C #, VB (.NET और 6), और जाहिरा तौर पर जावा (जो मैंने ग्रहण किया था, लेकिन ऊपर देखना था क्योंकि मैंने 15 साल में भाषा का उपयोग नहीं किया है) सभी शुरुआती रिटर्न की अनुमति देते हैं। इसलिए सुविधा न होने के कारण 'जोरदार टाइप की गई भाषाएं' पर आरोप न लगाएं। stackoverflow.com/questions/884429/…

— ps2goat 21

Answer 17

अगर बयान छोटे हैं तो रखना पसंद करता हूं।

तो, के बीच चयन:

if condition:
   line1
   line2
    ...
   line-n

तथा

if not condition: return

line1
line2
 ...
line-n

मैं आपको "प्रारंभिक वापसी" के रूप में वर्णित करता हूं।

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

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

Answer 18

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

Answer 19

मैं फंक्शन-लेवल पर फेल-फास्ट प्रैक्टिस करता हूं। यह कोड को सुसंगत और स्वच्छ रखता है (मेरे और उन लोगों के साथ जो मैंने काम किया है)। उसकी वजह से मैं हमेशा जल्दी लौटता हूं।

यदि आप AOP का उपयोग करते हैं, तो कुछ चेक-इन स्थितियों के लिए, आप उन जाँचों के पहलुओं को लागू कर सकते हैं।