Kako delujejo funkcije in več povratnih vrednosti v Go-u?

Question

Accepted Answer

Go funkcije se deklarirajšo s `func`, značilna lastnost pa je **več povratnih vrednosti** — funkcija lahko vrne več vrednosti hkrati. To se uporabljša povsod, posebej za idiom `(result, error)`, ki definira Go-jev pristop k obravnavanju napak.

## Osnovna funkcija

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

## Več povratnih vrednosti — značilnost jezika

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

Vrnitev `(value, error)` je IDIOM za obravnavanje napak v Go-u — namesto izjem funkcije vrnejo napake kot vrednosti, ki jih klicatelji eksplicitno preverijo. To naredi obravnavanje napak vidno in nemogoče tihošo prezreti.

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

## Poimenovane povratne vrednosti

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

## Variadične funkcije

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

## Funkcije so prva razreda

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

## Zakaj je to pomembno

Go funkcije so osrednje, in **več povratnih vrednosti** je ena izmed značilnih lastnosti jezika — omogočajo idiom `(result, error)`, ki je *Go-jev* pristop k obravnavanju napak (eksplicitna preverka napake kot vrednosti namesto izjem).

Ta vzorec, ki se uporablja v praktično vsakem Go programu, naredi obravnavanje napak vidno in namerno.

Sorodnji idiom comma-ok (`value, ok :=`) se pojavlja povsod (dostop do map, type assertions, channel receives).

Razumevanje več povratnih vrednosti, vzorca napak, poimenovanih povratnih vrednosti, variadičnih funkcij in funkcij prve vrste je nujno za branje in pisanje idiomatičnega Go koda — in filozofija napake kot vrednosti je ena izmed najpomembnejših konceptualnih razlik med Go-om in jeziki na osnovi izjem.