Go फ़ंक्शन को func के साथ घोषित किया जाता है, और एक विशिष्ट विशेषता है मल्टीपल रिटर्न वैल्यूज़ — एक फ़ंक्शन एक ही बार में कई मान वापस कर सकता है। यह व्यापक रूप से उपयोग किया जाता है, विशेष रूप से (result, error) idiom के लिए जो Go की error handling को परिभाषित करता है।
{
a + b
}
{
+ name
}
func divide(a, b int) (int, error) { // returns BOTH a result AND an error
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil // nil error = success
}
// callers handle both — the ubiquitous Go error pattern
result, err := divide(10, 2)
if err != nil {
log.Fatal(err) // handle the error
}
fmt.Println(result)
(value, error) वापस करना Go में error handling के लिए यह idiom है — exceptions के बजाय, फ़ंक्शन errors को values के रूप में वापस करते हैं जिन्हें callers स्पष्ट रूप से check करते हैं। यह error handling को दृश्यमान और अदृश्य रूप से ignore करना असंभव बनाता है।
// many built-ins return (value, ok) — a boolean for "did it work?"
value, ok := myMap["key"] // ok = false if the key is missing
if ok { ... }
v, ok := someInterface.(string) // type assertion with ok
func split(sum int) (x, y int) { // named returns
x = sum * 4 / 9
y = sum - x
return // "naked return" — returns the named values
}
func sum(nums ...int) int { // accepts any number of ints
total := 0
for _, n := range nums {
total += n
}
return total
}
sum(1, 2, 3) // 6
sum(nums...) // spread a slice into args
var op func(int, int) int = add // assign functions to variables
func apply(fn func(int) int, x int) int { return fn(x) } // pass as arguments
Go के फ़ंक्शन केंद्रीय हैं, और मल्टीपल रिटर्न वैल्यूज़ भाषा की परिभाषित विशेषताओं में से एक हैं — वे (result, error) idiom को enable करते हैं जो Go की error handling approach है (exceptions के बजाय explicit error-as-value checking)।
यह पैटर्न, लगभग हर Go प्रोग्राम में उपयोग किया जाता है, error handling को दृश्यमान और intentional बनाता है।
संबंधित comma-ok idiom (value, ok :=) हर जगह दिखाई देता है (map access, type assertions, channel receives)।
मल्टीपल returns, error pattern, नामांकित returns, variadic functions, और first-class functions को समझना idiomatic Go को read और write करने के लिए आवश्यक है — और error-as-value philosophy Go और exception-based languages के बीच सबसे महत्वपूर्ण conceptual अंतरों में से एक है।