Go hata yönetimini nasıl gerçekleştirir?

Question

Accepted Answer

Go, sıradan hatalar için **hiçbir istisna mekanizması** yoktur. Bunun yerine hatalar, fonksiyonlardan döndürülen **değerlerdir** (tipik olarak son dönüş değeri), ve çağıranlar onları **açıkça kontrol ederler**. Bu, hata yönetimini görünür, kasıtlı ve sessizce göz ardı edilmesi imkansız kılar — Go felsefesinin tanımlayıcı özelliğidir.

## error türü ve temel örüntü

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

`if err != nil { ... }` kontrolü Go'da sürekli görünür — her hata verebilecek işlem, ardından açık bir hata kontrolü gelir. Bu ayrıntılılık kasıtlıdır: hatalar her zaman görünür ve çağrı yerinde işlenir.

## Hata oluşturma

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## Hataları sarmalama ve inceleme

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

Sarmalama (`%w`) hatalar yukarı doğru yayıldıkça bağlam ekler, `errors.Is`/`errors.As` ise belirli alttaki hataları kontrol etmenize veya çıkarmanıza izin verir — hata zincirlerini işlemek için modern yol.

## Özel hata türleri

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## error vs panic

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

## Neden önemli

Go'nun hata-olarak-değer yaklaşımı, en tanımlayıcı ve tartışmalı özelliklerinden biridir ve istisna tabanlı dillerden temelde farklıdır.

Hataları, çağıranların açıkça kontrol etmesi gereken değerler olarak döndürerek (`if err != nil`), Go hata yönetimini **görünür, yerel ve yanlışlıkla göz ardı edilmesi imkansız** kılar — her hatanın tam olarak nerede işlendiğini görürsünüz, bu da güvenilirliği ayrıntılılık pahasına iyileştirir.

Bu felsefeyi, `(result, error)` örüntüsünü, hata sarmalamayı (`%w`) `errors.Is`/`errors.As` ile bağlam ekleme ve zincirleri inceleme için, özel hata türlerini ve hatalar (normal, kurtarılabilir) ile panic (istisnai, programcı hataları) arasındaki ayrımı anlamak kesinlikle gereklidir — bu, her Go programında yaygın olarak görülür ve istisna tabanlı dillerden gelen geliştiriciler için temel bir zihinsel kaymayı temsil eder.

Aynı zamanda Go mülakatlarının en yaygın konularından biridir.