एकाधिक रिटर्न और नामित रिटर्न

गो में, एक फ़ंक्शन एकाधिक मान लौटा सकता है। यह वह तंत्र है (value, error) पैटर्न को सक्षम करता है जिसे आप पहले ही देख चुके हैं और जो व्याप्त है संपूर्ण मानक पुस्तकालय।

एकाधिक रिटर्न

रिटर्न प्रकार कोष्ठक के बीच, अल्पविराम से अलग किए गए होते हैं:

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

q, r := divmod(17, 5) // q=3, r=2

वे एकाधिक असाइनमेंट के साथ नष्ट हो गए हैं। इनमें से किसी एक को त्यागना मान _ का उपयोग करते हैं:

_, r := divmod(17, 5) // solo il resto

विहित (T, error) पैटर्न

लगभग सभी stdlib इसका अनुसरण करते हैं। error हमेशा अंतिम होता है:

func read(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("read %q: %w", path, err)
    }
    return data, nil
}

नामित रिटर्न

आप रिटर्न मानों को नाम दे सकते हैं: वे पूर्व-घोषित चर बन जाते हैं शून्य से प्रारंभ किया गया, और return बिना किसी तर्क के उन्हें लौटा देता है ("नग्न)। वापसी"):

func divmod(a, b int) (q, r int) {
    q = a / b
    r = a % b
    return       // naked: ritorna q, r
}

नामांकित रिटर्न दस्तावेज़ीकरण टूलटिप्स में भी दिखाई देते हैं, इसलिए वे उपयोगी हैं जटिल कार्यों के लिए इनलाइन दस्तावेज़ के एक रूप के रूप में - न केवल नग्न वापसी के लिए.

दो से अधिक रिटर्न?

आपको (int, int, int, error) से कोई नहीं रोकता, लेकिन यदि आपको आवश्यकता महसूस होती है यह लगभग हमेशा एक संकेत है कि आपको struct वापस करना चाहिए:

type Result struct {
    Sum  int
    Avg  float64
    Max  int
}

func analyze(nums []int) (Result, error) { ... }

इसे अजमाएं

func f() (a, b int) {
    a = 1
    b = 2
    return
}
x, y := f()
fmt.Println(x, y)

संक्षिप्त

• कोष्ठकों के बीच एकाधिक मान: func f() (T1, T2, error)।
• कन्वेंशन: error हमेशा अंतिम मान के रूप में; त्रुटि पर, शून्य मान + त्रुटि।
• नामित रिटर्न वेरिएबल्स को पूर्व-घोषित करते हैं और नग्न रिटर्न सक्षम करते हैं।
• केवल बहुत ही छोटे समारोहों में नग्न रिटर्न; इससे परे, पठनीयता प्रभावित होती है।
• 2-3 से अधिक रिटर्न? आप शायद एक संरचना चाहते हैं।