როგორ მუშაობს ფუნქციები და მრავალი დაბრუნების მნიშვნელობები Go-ში?

Question

Accepted Answer

Go ფუნქციები დეკლარირდება `func`-ით, და განმასხვავებელი თავისებურება არის **მრავალი დაბრუნების მნიშვნელობები** — ფუნქცია შეიძლება ერთდროულად დააბრუნოს რამდენიმე მნიშვნელობა. ეს ფართოდ გამოიყენება, განსაკუთრებით `(result, error)` იდიომისთვის, რომელიც 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-ს შეცდომის სამართავისთვის — გამონაკლისების ნაცვლად, ფუნქციები აბრუნებენ შეცდომებს როგორც მნიშვნელობები, რომლებსაც მწვილმოუდეলეები ცხადად ამოწმებენ. ეს შეცდომის სამართავს ხილულს ხდის და შეუძლებელი ხდის მის ჩაბნელებით უგულებელყოფას.

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

## დასახელებული დაბრუნების მნიშვნელობები

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

## ვარიადული ფუნქციები

```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)` იდიომას, რომელიც *არის* Go-ს შეცდომის სამართავის მიდგომა (გამონაკლისების ნაცვლად ცხადი შეცდომა-როგორც-ღირებულება თქმის).

ეს ნიმუში, რომელიც გამოიყენება ფაქტიურად ყოველ Go პროგრამაში, შეცდომის სამართავს ხილულს და განზრახ ხდის.

დაკავშირებული comma-ok იდიომა (`value, ok :=`) გამოჩნდება ყველგან (რუქის წვდომა, ტიპის მტკიცებული განცხადება, არხის მიღება).

mრავალი დაბრუნების მნიშვნელობების, შეცდომის ნიმუშის, დასახელებული დაბრუნების მნიშვნელობების, ვარიადული ფუნქციების და პირველი კლასის ფუნქციების გაგება აუცილებელია იდიომატური Go-ს წაკითხვისა და წერისთვის — და შეცდომა-როგორც-ღირებულება ფილოსოფია არის Go-ს და გამონაკლისზე დაფუძნებული ენების შორის ყველაზე მნიშვნელოვანი კონცეპტუალური განსხვავება.