Go'da fonksiyonlar ve çoklu dönüş değerleri nasıl çalışır?

Question

Accepted Answer

Go fonksiyonları `func` ile bildirilir ve ayırt edici bir özelliği **çoklu dönüş değerleridir** — bir fonksiyon aynı anda birkaç değer döndürebilir. Bu yaygın olarak kullanılır, özellikle Go'nun hata işleme yaklaşımını tanımlayan `(result, error)` idiomunda.

## Temel fonksiyon

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

## Çoklu dönüş değerleri — tanımlayıcı özellik

```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)` döndürmek, Go'da hata işleme için IDIOM'dur — istisnalar yerine, fonksiyonlar hataları arayanların açıkça kontrol etmesi gereken değerler olarak döndürür. Bu, hata işlemeyi görünür ve sessizce görmezden gelmek imkansız hale getirir.

## comma-ok deseni

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

## Adlandırılmış dönüş değerleri

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

## Variadic fonksiyonlar

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

## Fonksiyonlar birinci sınıf

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

## Neden önemli

Go fonksiyonları merkezi konumdadır ve **çoklu dönüş değerleri**, dili tanımlayan özelliklerden biridir — Go'nun hata işleme yaklaşımı olan `(result, error)` idiomunu etkinleştirir (istisnalar yerine açık hata-değer-olarak kontrolü).

Hemen hemen her Go programında kullanılan bu desen, hata işlemeyi görünür ve kasıtlı hale getirir.

İlgili comma-ok idiomı (`value, ok :=`) her yerde görünür (harita erişimi, tür onaylamaları, kanal alımları).

Çoklu dönüş değerleri, hata deseni, adlandırılmış dönüş değerleri, variadic fonksiyonları ve birinci sınıf fonksiyonları anlamak, idiyomatik Go kodu okumak ve yazmak için gereklidir — ve hata-değer-olarak felsefesi, Go ile istisna tabanlı diller arasındaki en önemli kavramsal farklardan biridir.