एकाधिक रिटर्न वैल्यू में

एकाधिक रिटर्न वैल्यू के बारे में

Go के फंक्शन और मेथड कई वैल्यू लौटा सकते हैं:

func GetCard() (Card, error) { ... }

हर रिटर्न वैल्यू को क्रम से असाइन करना ज़रूरी है और उनके बीच कॉमा लगाने होते हैं:

card, err := GetCard()

ब्लैंक आइडेंटिफायर

असाइनमेंट के हर स्थान पर एक वेरिएबल घोषित होता है। Go में किसी वेरिएबल को घोषित करके उसका उपयोग न करना मान्य नहीं है। उस रिटर्न वैल्यू को छोड़ने के लिए वेरिएबल के नाम की जगह ब्लैंक आइडेंटिफायर _ लिखिए।

card, _ := GetCard() // error intentionally ignored
_, err := GetCard()  // card ignored, only checking for error

एरर को संभालना

error एक बिल्ट-इन इंटरफेस है। nil एरर का मतलब है कि कोई एरर नहीं हुई। कोई भी दूसरी वैल्यू इस बात का संकेत देती है कि कुछ गड़बड़ हुई। परंपरा के अनुसार जो फंक्शन विफल हो सकते हैं, उन्हें अपनी अंतिम वैल्यू के रूप में error लौटाना चाहिए। इसे कॉल करने वाले को बाकी किसी भी रिटर्न वैल्यू का उपयोग करने से पहले इसकी जाँच करनी चाहिए:

card, err := GetCard()
if err != nil {
    // unsafe to use card here
    return err
}
// safe to use card here

कॉमा-ok मुहावरा

दो वैल्यू वाला यह असाइनमेंट पैटर्न error को संभालने के अलावा और जगहों पर भी दिखता है। मैप में लुकअप, टाइप असर्शन और चैनल से रिसीव, तीनों एक दूसरी बूलियन वैल्यू का उपयोग करते हैं, जिसे परंपरा से ok कहा जाता है। यह वैल्यू सफलता या डेटा मौजूद होने का संकेत देती है:

m := map[string]int{"a": 1}
v, ok := m["a"] // ok is true
v, ok = m["z"]  // ok is false

var i interface{} = "hello"
v, ok := i.(string) // ok is true
v, ok = i.(int)     // ok is false

v, ok := <-ch // ok is false if ch is closed and empty

नामित रिटर्न वैल्यू

फंक्शन सिग्नेचर में रिटर्न वैल्यू को नाम भी दिए जा सकते हैं। ये वेरिएबल फिर फंक्शन की बॉडी के अंदर उपयोग किए जा सकते हैं।

func divide(a, b int) (quotient, remainder int) {
    quotient = a / b
    remainder = a % b
    return quotient, remainder
}

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

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

लंबे फंक्शन में नेकेड रिटर्न अक्सर पढ़ने में दिक्कत करते हैं, क्योंकि साफ नहीं होता कि क्या लौटाया जा रहा है। जब तक फंक्शन इतना छोटा न हो कि उसका सिग्नेचर हमेशा सामने रहे, रिटर्न वैल्यू साफ-साफ लिखना ही बेहतर है।

अधिक जानने के लिए Go by Example: Multiple Return Values, Effective Go: Multiple Returns या Tour of Go देखिए।