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

Go-లో `(value, error)` రిటర్న్ చేయడం ఎర్రర్ హ్యాండ్లింగ్ కోసం 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 ఆక్సెస్, type assertions, channel receives).

బహుళ రిటర్న్ విలువలు, ఎర్రర్ నమూనా, పేరు పెట్టిన రిటర్న్ విలువలు, variadic ఫంక్షన్‌లు మరియు ఫర్స్ట్-క్లాస్ ఫంక్షన్‌లను అర్థం చేసుకోవడం idiomatik Go ను చదవడానికి మరియు వ్రాయడానికి అవసరం — మరియు ఎర్రర్-ఆజ్-వ్యాలూ తత్వశాస్త్రం Go మరియు అసెప్షన్ -ఆధారిత భాషల మధ్య అత్యంత ముఖ్యమైన సంభావిత వ్యత్యాసాలలో ఒకటి.