Go मा functions र multiple return values कसरी काम गर्छन्?

Question

Accepted Answer

Go functions `func` को साथ घोषणा गरिन्छ, र एक विशिष्ट विशेषता **multiple return values** हो — एक function एकै पल कई मान फर्काउन सक्छ। यो व्यापक रूपमा प्रयोग गरिन्छ, विशेष गरी `(result, error)` idiom को लागि जसले Go को error handling परिभाषित गर्छ।

## आधारभूत function

```go
func add(a int, b int) int {     // params with types, then the return type
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// shorthand for same-typed params: func add(a, b int) int
```

## Multiple return values — परिभाषित विशेषता

```go
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 को सट्टा, functions errors लाई मान को रूपमा फर्काउँछन् जसलाई callers स्पष्टतः जाँच गर्छन्। यसले error handling दृश्यमान र अप्रयोग्यताले बेवास्ता गर्न असम्भव बनाउँछ।

## Comma-ok pattern

```go
// 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
```

## Named return values

```go
func split(sum int) (x, y int) {   // named returns
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — returns the named values
}
```

## Variadic functions

```go
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
```

## Functions are first-class

```go
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 का functions केन्द्रीय छन्, र **multiple return values** भाषा को परिभाषित विशेषताहरु मध्ये एक हो — तिनीहरु `(result, error)` idiom को सक्षम गर्छन् जो Go को error handling को दृष्टिकोण हो (exceptions को सट्टा स्पष्ट error-as-value जाँच)।

यो pattern, लगभग हरेक Go program मा प्रयोग गरिन्छ, error handling दृश्यमान र जानबूझकर बनाउँछ।

सम्बन्धित comma-ok idiom (`value, ok :=`) पूरामा देखिन्छ (map access, type assertions, channel receives)।

Multiple returns, error pattern, named returns, variadic functions, र first-class functions बुझ्नु idiomatic Go पढ्न र लेख्न को लागि आवश्यक छ — र error-as-value दर्शन Go र exception-आधारित भाषाहरु बीचको सबैभन्दा महत्त्वपूर्ण वैचारिक भेद हो।