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

## ਨਾਮਜ਼ਦ ਵਾਪਸੀ ਮੁੱਲ

```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 ਪਹੁੰਚ, ਕਿਸਮ ਦੁਆਰਾ, ਚੈਨਲ ਪ੍ਰਾਪਤੀ)।

ਕਈ ਵਾਪਸੀ ਮੁੱਲ, ਗਲਤੀ ਪੈਟਰਨ, ਨਾਮਜ਼ਦ ਵਾਪਸੀ ਮੁੱਲ, variadic ਫੰਕਸ਼ਨ, ਅਤੇ ਪਹਿਲੀ-ਸ਼੍ਰੇਣੀ ਫੰਕਸ਼ਨ ਨੂੰ ਸਮਝਣਾ idiomatic Go ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਅਤੇ error-as-value ਦਰਸ਼ਨ Go ਅਤੇ ਅਪਵਾਦ-ਨਿਰਧਾਰਤ ਭਾਸ਼ਾਵਾਂ ਵਿਚਕਾਰ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸੰਕਲਪਾਤਮਕ ਅੰਤਰ ਹੈ।