2013-02-26 47 views
22

किसी फ़ंक्शन के रिटर्न पैरामीटर नामकरण से क्या लाभ उठते हैं?वापसी पैरामीटर का नाम क्यों दिया जाना चाहिए?

func namedReturn(i int) (ret int) { 
    ret = i 
    i += 2 
    return 
} 

func anonReturn(i int) int { 
    ret := i 
    i += 2 
    return ret 
} 
+0

@ थॉमस्कैप्लर से उत्तर में जोड़ने के लिए और वहां चर्चा (मैं अभी तक टिप्पणी नहीं कर सकता), आप नामित परिणाम पैरामीटर का उपयोग कर सकते हैं और अपनी वापसी में चर निर्दिष्ट भी कर सकते हैं। यह दस्तावेज़ीकरण का लाभ प्रदान करता है लेकिन छायांकन चिंताओं को हटा देता है। हालांकि, यह खत्म हो जाता है> यदि आपके पास एकाधिक रिटर्न साइटें हैं, तो आपको फ़ंक्शन के रिटर्न मानों को बदलने पर उन्हें सभी को बदलने की आवश्यकता नहीं है क्योंकि यह केवल "वापसी" कहेंगे। लाभ। – darkwing

उत्तर

28

उनका नाम इस के लिए कुछ फायदे होते हैं:

  • यह प्रलेखन के रूप में कार्य करता है।
  • वे स्वतः घोषित किए गए हैं और शून्य मानों में प्रारंभ किए गए हैं।
  • यदि आपके पास एकाधिक रिटर्न साइटें हैं, तो आपको फ़ंक्शन के रिटर्न मानों को बदलने पर उन्हें सभी को बदलने की आवश्यकता नहीं है क्योंकि यह केवल "वापसी" कहेंगे।

डाउनसाइड्स भी हैं, मुख्य रूप से यह भी एक ही नाम के चर को घोषित करके गलती से छाया करना आसान है।

प्रभावी गो section on named result parameters है।

+4

छायांकन एक प्रमुख मुद्दा है। मेरे पास अक्सर ऐसा कुछ होता है: 'मैं, गलती: = strconv.Atoi (...) '। 'i' एक स्थानीय चर है, लेकिन मैं एक वापसी मूल्य होने के लिए गलती चाहता हूँ। इसे काम करने के लिए, मुझे पहले घोषित करना होगा और उपयोग नहीं करना होगा: = – tjameson

+0

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

3

यह कम से कम दो मामलों में उपयोगी होता है:

  1. जब भी आप चर है कि आप वापस जाने के लिए जा रहे हैं की घोषणा करने के लिए है। जैसे

    func someFunc() (int, error) { 
        var r int 
        var e error 
        ok := someOtherFunc(&r) // contrived, I admit 
        if !ok { 
         return r, someError() 
        } 
        return r, nil 
    } 
    

    बनाम

    func someFunc() (r int, e error) { 
        ok := someOtherFunc(&r) 
        if !ok { 
         e = someError() 
        } 
        return 
    } 
    

    इस समारोह बढ़ जाती है के माध्यम से निष्पादन रास्तों की संख्या के रूप में और अधिक महत्वपूर्ण हो जाता है।

  2. जब आप वापसी मान दस्तावेज कर रहे हैं और उन्हें नाम से संदर्भित करना चाहते हैं। godoc किसी फ़ंक्शन के हस्ताक्षर के वापसी चर भाग को मानता है।

2

उदाहरण के लिए, नाम वापसी रिटर्न पैरामीटर, अच्छी तरह से, नाम से सुलभ हैं।

func foo() (a, b, c T) { 
     // ... 
     if qux { 
       b = bar() 
     } 
     // ... 
     return 
} 

वापसी पैरामीटर नामक w/o को दोहराना आसान नहीं है। एक का नाम वापसी पैरामीटर के रूप में मूलतः एक ही कार्यक्षमता के स्थानीय चर को पेश करने के लिए होता है:

func foo() (T, T, T) { 
     var a, b, c T 
     // ... 
     if qux { 
       b = bar() 
     } 
     // ... 
     return a, b, c 
} 

तो यह है कि सीधे अनुमति देने के लिए आसान है।

इसके अतिरिक्त, वे दूसरी दिशा में accessibly भी कर रहे हैं:

func foo() (a, b, c T) { 
     // ... 
     if a > c { 
       b = bar() 
     } 
     // ... 
     return 
} 

आदि

16

नाम वापसी चर के लिए एक और विशेष उपयोग एक आस्थगित समारोह शाब्दिक द्वारा कब्जा कर लिया जा रहा है। एक मामूली चित्रण:

package main 

import (
    "errors" 
    "fmt" 
) 

func main() { 
    fmt.Println(f()) 
} 

var harmlessError = errors.New("you should worry!") 

func f() (err error) { 
    defer func() { 
     if err == harmlessError { 
      err = nil 
     } 
    }() 
    return harmlessError 
} 

आउटपुट <nil> है। अधिक व्यावहारिक परिदृश्यों में, स्थगित फ़ंक्शन पैनिक्स को संभाल सकता है, और त्रुटि परिणाम के अलावा अन्य रिटर्न मानों को संशोधित कर सकता है। हालांकि सामान्य में जादू यह है कि स्थगित शाब्दिक को एफ के रिटर्न वैल्यू को संशोधित करने का मौका होता है, जिसके बाद एफ समाप्त होता है, या तो सामान्य रूप से या आतंक द्वारा।

+0

f() उसी तरह काम नहीं करेगा, भले ही त्रुटि को स्थानीय रूप से f() के अंदर घोषित किया गया हो और फिर डिफर द्वारा उपयोग किया जाए? => func f() (त्रुटि त्रुटि) {} @sonia –