Kif jaħdmu l-funzjonijiet u l-valuri ta' ritorn multipli fi Go?

Question

Accepted Answer

Il-funzjonijiet Go jiddikjaraw bi `func`, u karatteristika distintiva hija **valuri ta' ritorn multipli** — funzjoni tista' tqiegħed diversi valuri fl-istess ħin. Dan jintuża ħafna, partikolarment għall-idiom `(result, error)` li jiddefinixxxi t-tippuċċar tal-iżbalji ta' Go.

## Funzjoni bażika

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

## Valuri ta' ritorn multipli — il-karatteristika distintiva

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

Qiegħed `(value, error)` hija l-idiom għat-tippuċċar tal-iżbalji fi Go — minflok eccezzjonijiet, il-funzjonijiet jirritornaw iżbalji bħala valuri li l-mitlub jinħolqu esplicitament. Dan jagħmel it-tippuċċar tal-iżbalji viżibbli u impossibbli li jiġi injorat b'mod sillenti.

## Il-mudell 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
```

## Valuri ta' ritorn imsemmija

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

## Funzjonijiet variadici

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

## Il-funzjonijiet huma tal-ewwel klassi

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

## Għaliex hu importanti

Il-funzjonijiet Go huma ċentrali, u **valuri ta' ritorn multipli** huma waħda mill-karatteristiċi distintivi tal-lingwa — jippermettu l-idiom `(result, error)` li *hija* l-approċċ ta' Go għat-tippuċċar tal-iżbalji (verifika esplicita tal-iżball-bħala-valur minflok eccezzjonijiet).

Dan il-mudell, iżguż f'praktikament kull programm Go, jagħmel it-tippuċċar tal-iżbalji viżibbli u intenzjonali.

L-idiom comma-ok relatat (`value, ok :=`) jidher kullimkien (aċċess tal-mappa, asserti tat-tip, ir-riċevimenti tal-kanali).

Fhim tal-valuri ta' ritorn multipli, il-mudell tal-iżball, il-valuri ta' ritorn imsemmija, il-funzjonijiet variadici, u il-funzjonijiet tal-ewwel klassi huma essenzjali għall-qari u l-kitba ta' Go idiomatiku — u l-filosofija tal-iżball-bħala-valur hija waħda mill-aktar differenzi kunċettwali importanti bejn Go u l-lingwi bbażati fuq eccezzjonijiet.