बेहतर जावा विधि सिंटेक्स? जल्दी या देर से वापसी?

Question

डुप्लिकेट:Should a function have only one return statement?

अक्सर आप एक विधि है कि कई की स्थिति की जाँच करता है और स्थिति देता है हो सकता है (देता है अब के लिए बूलियन कहते हैं)। यह बेहतर एक ध्वज को परिभाषित करने, विधि के दौरान यह निर्धारित करते हैं, और यह अंत में वापसी है:

boolean validate(DomainObject o) { 
    boolean valid = false; 
    if (o.property == x) { 
    valid = true; 
    } else if (o.property2 == y) { 
    valid = true; 
    } ... 
    return valid; 
} 

या एक बार आप विधि के परिणाम पता है कि यह बेहतर/अधिक बस वापस जाने के लिए सही है?

boolean validate(DomainObject o) { 

    if (o.property == x) { 
    return true; 
    } else if (o.property2 == y) { 
    return true; 
    } ... 
    return false; 
} 

अब स्पष्ट रूप से वहाँ की कोशिश/पकड़ ब्लॉक और शर्तों के अन्य सभी प्रकार के हो सकता है, लेकिन मुझे लगता है कि अवधारणा स्पष्ट है। राय?

Answer 1

यदि यह एक विधि है तो आप हजारों बार कॉल करेंगे, फिर प्रारंभिक वापसी [थोड़ा] बढ़ी हुई प्रदर्शन को प्राप्त करने के लिए बेहतर है।

यदि नहीं, तो मैं देर से वापसी पसंद करूंगा, क्योंकि यह पठनीयता में सुधार करता है।

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

Answer 2

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

Answer 3

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

Answer 4

अधिकांश कोडिंग शैलियों के साथ, यह वास्तव में प्राथमिकता का विषय है, लेकिन guard clauses को कई लोगों द्वारा सर्वोत्तम अभ्यास माना जाता है।

Answer 5

यदि अपवाद चित्र का हिस्सा नहीं हैं, तो मैं तुरंत लौटने पर प्राथमिकता देना पसंद करता हूं।

फ्लैग वैरिएबल को गलत तरीके से प्रबंधित करना आसान हो सकता है और मैं सामान्य रूप से ध्वज चर के खिलाफ हूं। वापस नहीं लौटने से एक रखरखाव भी सोच सकता है कि आगे का काम किया जा सकता है (यदि विधि लंबी है)।

Answer 6

ईमानदारी से मुझे लगता है कि यह स्थिति पर निर्भर करता है। व्यक्तिगत रूप से मैं दोनों का उपयोग करता हूं, और मैं तय करता हूं कि कौन सा कोड कोड को और अधिक स्पष्ट और पढ़ने में आसान बना देगा।

यदि आप भारी अगर बयान (या किसी अन्य नियंत्रण संरचना) और यह भ्रामक मिल सकता है नेस्ट है, तो मैं बयान के अंदर वापसी होगी

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

Answer 7

मैं जल्दी लौटने और गहरी घोंसले से परहेज करना पसंद करता हूं। यह विशेष रूप से विधि की शुरुआत में सही है: सरल कुछ भी जांचें, और बाहर निकलें (या अपवाद फेंक दें) यदि आप वास्तव में ऐसा कर सकते हैं।

यदि यह एक विधि के बीच में सही है, यह एक निर्णय कॉल की अधिक है।

ध्यान दें कि मैं अपने उदाहरण refactor था सीधे उपयोग करने के लिए एक एकल if:

boolean validate(DomainObject o) {  
    if (o.property == x || o.property2 == y) { 
    return true; 
    } ... 
    return false; 
} 

मैं यह केवल एक खिलौना उदाहरण था एहसास, लेकिन मेरी बात यह है कि यह हमेशा अधिक तरीकों को आसान बनाने के लिए देख रहे हैं लायक है है अपने कोड :)

Answer 8

इस मामले के लिए, मैं पसंद करते हैं:

boolean validate (DomainObject o) { 
    if (o.property == x || 
     o.property2 == y || 
     ...) { 
      return true; 
    } else { 
      return false; 
} 

सामान्य तौर पर, मैं त्रुटि की स्थिति को संभालने के लिए जल्दी वापसी का उपयोग करना चाहते हैं, और बदले गणना के परिणाम वापस करने के अंत में।

Answer 9

एक दूसरे के खिलाफ खींच दो कारकों रहे हैं।

पहला कारक डिबगिंग में आसानी है। यदि आप तुरंत लौटते हैं (जैसा कि आपके दूसरे कोड स्निपेट में दिखाया गया है), कभी-कभी एक बड़े फ़ंक्शन को डीबग करना मुश्किल हो जाता है क्योंकि इन वापसी विवरणों को ढूंढना मुश्किल होता है, विशेष रूप से यदि उन्हें गलती से रखा जाता है।

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

तो, इस सवाल का जवाब इस तरह हो सकता है:

If the function is small, 
     save the return status in a variable and return at the end. 
else 
     return immediately. 

Answer 10

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

केवल समय मैं कहूंगा कि आप निश्चित रूप से वापस आ जाएगी अपने कोड की तरह लग रहा है, तो जल्दी है ...

boolean valid = true; 
if(condition1) { 
    valid = false; 
} 
if(valid) { 
    ... 
    if(condition2) { 
     valid = false; 
    } 
} 
if(valid) { 
    ... 
    if(condition3) { 
     valid = false; 
    } 
} 
... (etc) 

आप इन स्थितियों में से किसी में अपने आप को मिल जाए, फिर भी ... आप शायद रिफैक्टरिंग होना चाहिए कार्यक्रम।