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 च्या एरर हँडलिंग* दृष्टिकोन आहे (अपवादांऐवजी एरर-अस-व्हॅल्यू तपासणी).

ही पॅटर्न, व्यावहारिकपणे प्रत्येक Go प्रोग्राममध्ये वापरली जाते, एरर हँडलिंगला दृश्यमान आणि जानीवपूर्ण बनवते.

संबंधित comma-ok idiom (`value, ok :=`) सर्वत्र दिसते (map access, type assertions, channel receives).

अनेक रिटर्न्स, एरर पॅटर्न, नामांकित रिटर्न्स, variadic फंक्शन्स, आणि प्रथम-श्रेणी फंक्शन्स समजणे हे idiomatical Go वाचण्या आणि लिहिण्यासाठी आवश्यक आहे — आणि error-as-value तत्वज्ञान हे Go आणि exception-based भाषांमधील सर्वात महत्वाचा संकल्पात्मक फरक आहे.