वापसी पैरामीटर का नाम क्यों दिया जाना चाहिए?

Question

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

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

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

Answer 1

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

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

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

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

Answer 2

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

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 किसी फ़ंक्शन के हस्ताक्षर के वापसी चर भाग को मानता है।

Answer 3

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

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 
} 

आदि

Answer 4

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

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