ग्रूवी में एक स्पष्ट वापसी विवरण कब लिखना है?

Question

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

कुछ उदाहरण:

def foo(boolean bar) {
    // Not consistent
    if (bar) {
        return positiveBar()
    }
    negativeBar()
}

def foo2() {
    // Special Grails example
    def entitiy = new Entity(foo: 'Foo', bar: 'Bar')
    entity.save flush: true
    // Looks strange to me this way
    entity
}

Comments

पर्ल में एक समान मुद्दा है: एक फ़ंक्शन returnस्टेटमेंट में अंतिम मूल्यांकन की गई अभिव्यक्ति को tbe अनुपस्थिति में लौटाता है । व्यक्तिगत रूप से, मैं हमेशा स्पष्ट का उपयोग करता returnहूं, लेकिन मैं ग्रूवी को नहीं जानता।

— कीथ थॉम्पसन

व्यक्तिगत रूप से मैं निहित का उपयोग return तभी करूँगा जब यह पूरी तरह से स्पष्ट हो। toStringएक विशिष्ट उदाहरण है: यह एक-लाइनर है और गणना की गई कीमत स्पष्ट रूप से वापसी मूल्य है। लेकिन फिर, मैंने यह जानने के लिए पर्याप्त ग्रूवी को प्रोग्राम नहीं किया कि क्या बड़ा समुदाय सोचता है।

— जोआचिम सोउर

Answer 1

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

अन्यथा यह एक टाइपिंग त्रुटि की तरह लग सकता है।

दूसरी बात यह है कि फ़ंक्शंस / क्लोज़र को घोषित करने के लिए याद रखें, जो कि शून्य को 'शून्य' के रूप में लौटाने की उम्मीद कर रहे हैं - फिर से भविष्य के रखवाले को यह स्पष्ट करने के लिए कि आप क्या करने की कोशिश कर रहे हैं।

Answer 2

स्पष्टता राजा है।

साथी प्रोग्रामर के लिए जो सबसे स्पष्ट है, उसे लिखने के बाद अपना कोड पढ़ें।

Answer 3

यहाँ रिटर्न स्टेटमेंट को छोड़ने का तर्क दिया गया है ( स्रोत ):

ग्रूवी में एक अंडरस्टैड फीचर

पृष्ठभूमि

मैंने कुछ समय के लिए ग्रूवी के साथ काम किया है, लेकिन एक विशेषता का लाभ उठाया है: अंतिम अभिव्यक्ति का निहित रिटर्न मूल्यांकन किया गया है। उदाहरण के लिए:

def getFoo() {
  def foo = null
  if (something) {
    foo = new Foo()
  }
  foo // no 'return' necessary
}

उपरोक्त कोड में, मैं वापसी का उपयोग करूंगा क्योंकि यह मुझे सुरक्षित लगता है। मैं एरिक की पोस्ट (स्पष्ट रिटर्न के संबंध में) से सहमत था।

रहस्योद्घाटन

मैं इसे अभी प्राप्त करता हूं, और यह सब ग्रूवी में बढ़ाया संग्रह विधियों के लिए धन्यवाद है।

संग्रह विधि पर विचार करें। यह एक फ़ंक्शन को लागू करके एक सूची को बदल देता है। छद्मकोश में:

[ a, b, c, d] => [ f(a), f(b), f(c), f(d) ]

इसे ध्यान में रखते हुए, यहां एक और उदाहरण दिया गया है:

class Composer {
  def name
  // def era, etc
}

def list = [ 'Bach', 'Beethoven', 'Brahms' ]

// the closure returns the new Composer object, as it is the last
// expression evaluated.

def composers = list.collect { item -> new Composer(name : item) }

assert 'Bach' == composers[0].name

विचार बस स्ट्रिंग की सूची से संगीतकार वस्तुओं की एक सूची बनाने के लिए है। जैसा कि टिप्पणी में कहा गया है, इकट्ठा करने के लिए पारित क्लोजर महान प्रभाव के लिए निहित वापसी का उपयोग करता है। एक समय में, मैंने उस विचार को व्यक्त करने के लिए 3-4 लाइनें ली होंगी।

लेकिन अब, यह कोड केवल संक्षिप्त नहीं है: यह वास्तव में सुरुचिपूर्ण है। अन्य भाषाओं जैसे पायथन की बहुत याद ताजा करती है।

टेक-होम संदेश

उत्कृष्ट ग्रूवी सुविधाओं की कई सूचियाँ हैं। हालाँकि हम शायद ही कभी 'निहित प्रतिफल' को सूचीबद्ध देखें। मैं एक प्रशंसक हूं: यह अन्य विशेषताओं के लिए पहियों को कम करता है।

मुझे लगता है कि यह कई भाषाओं में उपलब्ध है: मैंने अभी इसे ग्रूवी में इस्तेमाल नहीं किया है। मुझे लगता है कि मैं इसके बिना नहीं रह पाऊंगा।