Je, kazi na thamani nyingi za kurudi zinavyofanya kazi katika Go?

Question

Accepted Answer

Kazi za Go zinabayenishwa na `func`, na sifa ya ajabu ni **thamani nyingi za kurudi** — kazi inaweza kurudi thamani nyingi mara moja. Hii inatumika kila mahali, hasa kwa idiom `(result, error)` ambayo inabainisha mbinu ya Go ya kushughulikia hitilafu.

## Kazi ya msingi

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

## Thamani nyingi za kurudi — sifa inayobainisha

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

Kurudi `(value, error)` ni IDIOM ya kushughulikia hitilafu katika Go — badala ya mipango, kazi zinarudi hitilafu kama thamani ambayo wanaita lazima kuzingatia wazi. Hii inafanya kushughulikia hitilafu kuonekana na haiwezekani kukataa kwa upole.

## Muundo wa 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
```

## Thamani za kurudi zilizopewa jina

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

## Kazi za 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
```

## Kazi ni daraja la kwanza

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

## Kwa nini kuwa muhimu

Kazi za Go ni kuu, na **thamani nyingi za kurudi** ni moja ya sifa inayobainisha lugha — zinawezesha idiom `(result, error)` ambayo *ni* mbinu ya Go ya kushughulikia hitilafu (ukaguzi wa wazi wa hitilafu kama thamani badala ya mipango).

Muundo huu, unaotumika katika takriban kila programu ya Go, inafanya kushughulikia hitilafu kuonekana na kumaksudi.

Idiom inayohusiana ya comma-ok (`value, ok :=`) inaonekana kila mahali (ikiwa na ramani, type assertions, channel receives).

Kuelewa thamani nyingi za kurudi, muundo wa hitilafu, thamani za kurudi zilizopewa jina, kazi za variadic, na kazi za daraja la kwanza ni muhimu kwa kusoma na kuandika nambari ya Go — na falsafa ya hitilafu kama thamani ni tofauti moja ya maoni muhimu zaidi kati ya Go na lugha inayohusiana na mipango.