एक कोडिंग शैली सिद्धांत है - जैसे एकल-निकास सिद्धांत
जो लोग अभी भी सिंगल-एग्जिट या मल्टीपल एग्जिट में हर्क करते हैं, वे अभी भी 1960 के दशक के अंत में अटक गए हैं। इसके बाद, जब हम संरचित प्रोग्रामर की शैशवावस्था में थे, तब इस तरह की चर्चा महत्वपूर्ण थी, और यह घोषणा करते हुए एक बहुत से शिविर थे कि Bohm-Jacopini संरचित प्रोग्राम Theorem के पीछे निष्कर्ष सभी प्रोग्रामिंग कंस्ट्रक्ट्स पर सार्वभौमिक रूप से लागू नहीं थे।
यह कुछ ऐसा है जिसे बहुत पहले सुलझा लिया जाना चाहिए था। खैर, इसे (अकादमिक और उद्योग दोनों में, लगभग सटीक होने के लिए 4 दशक) निपटाया गया है, लेकिन लोग (जो बिल्कुल समर्थक या विरोधी हैं) ध्यान नहीं दे रहे हैं।
मेरे जवाब के बाकी हिस्सों के लिए, यह सब सापेक्ष है (सॉफ्टवेयर में क्या नहीं है?):
- वास्तव में एक अच्छी बात है?
हाँ। सामान्य मामलों के अधिकांश समय, किनारे के मामलों और भाषा-विशिष्ट प्रोग्रामिंग निर्माणों के लिए विशिष्ट केवेट के साथ।
हमेशा, या कभी-कभी?
सर्वाधिक समय।
वास्तव में इससे कितना फर्क पड़ता है?
निर्भर करता है।
पढ़ने योग्य कोड बनाम अपठनीय कोड। बढ़ी हुई जटिलता (जिसे हमें अब तक त्रुटियों को पेश करने की संभावना बढ़ जाती है) बनाम सरल जटिलता (और इरगो, त्रुटियों की छोटी संभावना) बढ़ जाती है। ऐसी भाषाएं जिनके कंपाइलर एक निहित रिटर्न नहीं कहते हैं (जैसे, पास्कल, जावा या सी #) और उन int (C और C ++) के लिए डिफ़ॉल्ट।
अंत में, यह एक कीबोर्ड के पीछे आदमी / घंटों के साथ सम्मानित किया जाने वाला कौशल है। कभी-कभी, कई रिटर्न स्टेटमेंट रखना ठीक होता है, जैसे यहाँ (कुछ पास्कलसीक स्यूडोकोड में):
function foo() : someType
begin
if( test1 == true )
then
return x;
end
doSomethignElseThatShouldnHappenIfTest1IsTrue();
return somethingElse();
end;
आशय स्पष्ट है, और एल्गोरिथ्म काफी छोटा है और पर्याप्त रूप से सरल है कि यह एक 'फ्लैग' वैरिएबल के निर्माण को वारंट नहीं करता है जो एकल रिटर्न प्वाइंट में उपयोग किए जाने वाले अंतिम रिटर्न वैल्यू को रखता है। एल्गोरिथ्म त्रुटि में हो सकता है, लेकिन इसकी संरचना काफी सरल है कि एक त्रुटि का पता लगाने का प्रयास (सबसे अधिक संभावना है) नगण्य है।
कभी-कभी यह नहीं होता है (यहां सी-लाइक स्यूडोकोड का उपयोग करके):
switch(someVal)
{
case v1 : return x1;
case v2 : return x2:
case v3 : doSomething(); // fall-through
case v4: // fall-through
case v5: // fall-through
case v6: return someXthingie;
...
...
default:
doSomething(); // no return statement yet
}
यहां, एल्गोरिथ्म में एक सरल संरचना नहीं है, और स्विच स्टेटमेंट (एक सी-स्टाइल एक) गिरने के चरणों की अनुमति देता है जो एल्गोरिथ्म के भाग के रूप में जानबूझकर नहीं किया जा सकता है या नहीं कर सकता है।
शायद एल्गोरिथ्म सही है, लेकिन खराब लिखा गया है।
या हो सकता है, प्रोग्रामर की क्षमता से परे बाहरी ताकतों द्वारा, यह वैध रूप से आवश्यक एल्गोरिथ्म का वास्तविक (और सही) प्रतिनिधित्व हो।
शायद यह गलत है।
इनमें से किसी की सच्चाई को उजागर करने के लिए पिछले उदाहरण की तुलना में कहीं अधिक प्रयास की आवश्यकता है । और यहाँ कुछ ऐसा है जिस पर मैं दृढ़ता से विश्वास करता हूँ (आप को लगता है कि मुझे इसे वापस करने के लिए कोई औपचारिक अध्ययन नहीं है):
एक कोड स्निपेट माना जाता है जिसे सही माना जाता है:
मल्टीपल रिटर्न स्टेटमेंट ऐसे कोड स्निपेट की पठनीयता और सरलता को बढ़ाते हैं, यदि स्निपेट एक साधारण एल्गोरिथ्म को अंतर्निहित सरल प्रवाह संरचना के साथ दर्शाता है। साधारण रूप से, मेरा मतलब छोटा नहीं है, लेकिन मेरा मतलब है कि सहज रूप से समझ में आने वाला या आत्म-साक्ष्य , वह है जिसे पढ़ने में असम्मानजनक प्रयास की आवश्यकता नहीं है (न ही लोगों को उल्टी करने के लिए प्रेरित करना, किसी की मां को शाप देना, या जब इसे पढ़ना हो तो एक गोली निगल लेना)। )
एक सिंगल रिटर्न स्टेटमेंट ऐसे कोड के टुकड़े की पठनीयता और सरलता को बढ़ाता है यदि रिटर्न वैल्यू या तो एल्गोरिथ्म के निष्पादन के दौरान गणना की जाती है या यदि गणना के लिए जिम्मेदार एल्गोरिथ्म में चरणों को एल्गोरिथम की संरचना में एक स्थान पर एक साथ समूहीकृत किया जा सकता है। ।
एक एकल रिटर्न स्टेटमेंट में इस तरह के कोड की पठनीयता और सरलता कम हो जाती है, अगर इसे एक या एक से अधिक फ्लैग वैरिएबल के लिए असाइनमेंट की आवश्यकता होती है, इस तरह के असाइनमेंट के स्थानों को पूरे एल्गोरिथ्म में समान रूप से स्थित नहीं किया जाता है।
एकाधिक रिटर्न स्टेटमेंट कोड के ऐसे टुकड़े की पठनीयता और सरलता को कम कर देते हैं यदि रिटर्न स्टेटमेंट को एल्गोरिथम में समान रूप से वितरित नहीं किया जाता है, और यदि वे कोड के पारस्परिक रूप से अनन्य ब्लॉकों का सीमांकन करते हैं जो आपस में आकार या संरचना में समान नहीं हैं।
यह प्रश्न में कोड स्निपेट की जटिलता से निकटता से संबंधित है। और यह बदले में साइक्लोमैटिक और हॉलस्टीड जटिलता उपायों से संबंधित है। इससे व्यक्ति निम्नलिखित का पालन कर सकता है:
एक सबरूटीन या फ़ंक्शन का आकार जितना बड़ा होता है, उतना ही बड़ा और अधिक जटिल इसकी आंतरिक नियंत्रण प्रवाह संरचना होती है, और अधिक संभावना यह है कि आप एक प्रश्न का सामना करेंगे कि एकाधिक या एकल रिटर्न स्टेटमेंट का उपयोग करना है या नहीं।
इसका निष्कर्ष यह है: अपने कार्यों को एक काम करने के लिए छोटा रखें और केवल एक चीज (और इसे अच्छी तरह से करें)। यदि वे नाममात्र के छोटे साइक्लोमैटिक और हैलस्टेड जटिलता मेट्रिक्स का प्रदर्शन करते हैं, तो न केवल वे सबसे अधिक सही होने के लिए बाध्य होते हैं और उन कार्यों के कार्यान्वयन के लिए होते हैं जो समझ में नहीं आते हैं, उनकी आंतरिक संरचना भी अपेक्षाकृत स्व-स्पष्ट होगी।
फिर, और उसके बाद ही आप काफी आसानी से और बिना ज्यादा नींद खोए, आप यह तय कर सकते हैं कि किसी भी विकल्प के साथ त्रुटियों को शुरू करने के बहुत जोखिमों को चलाने के बिना एक ही रिटर्न और कई रिटर्न का उपयोग करें या नहीं।
कोई भी यह सब देख सकता है और सुझाव दे सकता है कि जब लोग एकल रिटर्न या कई रिटर्न के मुद्दे से जूझते हैं, तो ऐसा इसलिए होता है - या तो अनुभवहीनता, मूर्खता या काम नैतिकता की कमी के कारण - वे साफ कोड नहीं लिखते हैं और लिखना छोड़ देते हैं चक्रवाती और पड़ाव उपायों की पूर्ण अवहेलना के साथ राक्षसी कार्य करता है।