Yadda ayyukan da dawowar ƙiyaye masu yawa suke aiki a Go?

Question

Accepted Answer

Ayyukan Go ana bayyantar da su tare da `func`, kuma sifa ta musamman ita ce **dawowar ƙiyaye masu yawa** — aiki zai iya mayar da ƙiyaye da yawa a jiya. Ana amfani da haka sosai, musamman don idiom na `(result, error)` wanda ke bayyana yadda Go ke magani da kuskure.

## Aiki na asali

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

## Dawowar ƙiyaye masu yawa — sidar da ta bayyana

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

Dawowa `(value, error)` shi ne idiom da ake amfani da shi don magani da kuskure a Go — a maimakon sakamako, ayyuka suna mayar da kusurar a matsayin ƙiyaye wanda kira sukan duba a wazi. Hakan ya sa magani da kuskure ya kasance a gida kuma ba zai yiwu a yi watsi da shi ba.

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

## Dawowar ƙiyaye da suna

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

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

## Ayyuka na farko-ajiye

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

## Me yasa ya fi dacewa

Ayyukan Go sune tsakiya, kuma **dawowar ƙiyaye masu yawa** ita ce daya daga siiffoyin da ta bayyana yare — suna bada damar idiom na `(result, error)` wanda *shi ne* hanyar Go na magani da kuskure (bincike ainihin kuskure a matsayin ƙiyaye maimakon sakamako).

Tsarin nan, wanda ake amfani da shi kusan a kowane shiri na Go, ya sa magani da kuskure ya kasance a gida kuma ya dace.

Idiom na comma-ok da ke da alaƙa (`value, ok :=`) yana fitowa a duka (shiga taswira, ƙididdiga nau'i, karɓa tsarin).

Tuntuni da ƙiyaye masu yawa, tsarin kuskure, dawowar ƙiyaye da suna, ayyukan variadic, da ayyuka na farko-ajiye ya dace don karanta da rubuta Go a tsari — kuma falsafar error-as-value ita ce daya daga wuraren tunani mafi mahimmanci na bambanci tsakanin Go da harsunan da suke amfani da sakamako.