Go માં ફંક્શનો અને મલ્ટીપલ રીટર્ન વેલ્યુઝ કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

Go ફંક્શનો `func` સાથે ઘોષિત કરવામાં આવે છે, અને એક વિશિષ્ટ વૈશિષ્ટ્ય **મલ્ટીપલ રીટર્ન વેલ્યુઝ** છે — એક ફંક્શન એક સાથે ઘણી વેલ્યુઝ રીટર્ન કર્યા શકે છે. આ વ્યાપક રીતે ઉપયોગ થાય છે, ખાસ કરીને `(result, error)` idiom માટે જે Go ની એરર હેન્ડલિંગને વ્યાખ્યાયિત કરે છે.

## મૂળ ફંક્શન

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

## મલ્ટીપલ રીટર્ન વેલ્યુઝ — વ્યાખ્યાયિત વૈશિષ્ટ્ય

```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 માં એરર હેન્ડલિંગ માટે આ idiom છે — અપવાદોની જગ્યાએ, ફંક્શનો એરર્સને વેલ્યુઝ તરીકે રીટર્ન કરે છે જે કૉલર્સ સ્પષ્ટરૂપે તપાસે છે. આ એરર હેન્ડલિંગને દૃશ્યમાન અને અલક્ષણીય તરીકે અવગણવું અશક્ય બનાવે છે.

## comma-ok પેટર્ન

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

## નામ આપવામાં આવેલ રીટર્ન વેલ્યુઝ

```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 ફંક્શનો

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

## ફંક્શનો પ્રથમ-વર્ગ છે

```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 ફંક્શનો કેન્દ્રીય છે, અને **મલ્ટીપલ રીટર્ન વેલ્યુઝ** ભાષાની વ્યાખ્યાયિત વૈશિષ્ટ્યોમાંથી એક છે — તેઓ `(result, error)` idiom સક્ષમ કરે છે જે Go ની એરર હેન્ડલિંગ પદ્ધતિ છે (અપવાદો-આધારિત ભાષાઓની જગ્યાએ સ્પષ્ટ error-as-value તપાસ).

યા પેટર્ન, વર્ચુअલ રીતે દરેક Go પ્રોગ્રામમાં ઉપયોગ થાય છે, એરર હેન્ડલિંગને દૃશ્યમાન અને ઇચ્છાવીય બનાવે છે.

સંબંધિત comma-ok idiom (`value, ok :=`) દરેક જગ્યায় દેખાય છે (map પ્રવેશ, પ્રકાર અવતરણ, channel પ્રાપ્તિ).

મલ્ટીપલ રીટર્નો, એરર પેટર્ન, નામ આપવામાં આવેલ રીટર્નો, variadic ફંક્શનો અને પ્રથમ-વર્ગ ફંક્શનોને સમજવું idiomatic Go વાંચવા અને લખવા માટે આવશ્યક છે — અને error-as-value તત્વજ્ઞાન Go અને અપવાદ-આધારિત ભાષાઓ વચ્ચેના સૌથી મહત્વપૂર્ણ વૈચારિક તફાવતોમાંથી એક છે.