Type assertion ve type switch nedir?

Question

Accepted Answer

Bir **type assertion**, bir interface değerinden somut tipi çıkarır ve bir **type switch**, bir interface'in temel tipi üzerinde branşlanır. Bunlar, bir interface'ten (özellikle boş interface / `any`) spesifik tip bilgisini nasıl geri alacağınızı gösterir.

## Type assertion — somut tipi çıkartın

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

`i.(Type)` sözdizimi, interface `i`'nin `Type` tipi değeri tuttuğunu ileri sürer ve onu çıkartır. Ancak yanlış bir assertion **panik** oluşturur — bu nedenle genellikle güvenli virgül-ok formunu kullanırsınız.

## Güvenli virgül-ok formu

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

İki değer formu, değeri ve bir boolean döndürür — assertion başarısız olursa (panik yapmak yerine) `ok` false'tur. **Tipi kesin bilmedikçe her zaman bunu tercih edin**.

## Type switch — birden fazla olası tip üzerinde branşlanın

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

`switch v := i.(type)` formu temel tipi kontrol eder ve `v`'yi (her durumda uygun şekilde yazılmış) bağlar. Bir interface birden fazla tipi tutabileceği zaman bunu işlemek için temiz bir yoludur.

## Interface tiplerini de assert etme

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## Bunlara ihtiyacınız olduğunda

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

## Neden önemli

Type assertion ve type switch, interface değerleriyle çalışmak için gerekli araçlardır — `interface{}`/`any`'den somut tip bilgisini geri almak veya bir değerin belirli bir interface'i uygulayıp uygulamadığını kontrol etmek için kullanılırlar.

Bilinmeyen veya değişken tipte verilerle ilgilenirken (dinamik JSON ayrıştırma, genel işleme, "bu io.Closer'ı uygulayan mı?" gibi opsiyonel-interface kontrolleri) gereklidirler.

**Panik-vs-güvenli ayrımını** anlamak kritiktir: düz assertion `i.(T)` uyumsuzlukta paniklenir, oysa **virgül-ok formu** `v, ok := i.(T)` başarısızlığı güvenli bir şekilde rapor eder — güvenli formu kullanmak runtime çökmelerini önlemek için önemli bir uygulamadır.

Type switch, birden fazla olası tipi zarafetle işler.

Bunları bilmek (ve aşırı kullanımının genellikle yerine generics veya daha iyi yazılmış tasarımlar hedeflemesi gerektiği gerçeği) güvenli, diyomatik Go için ve interface'ler ve boş interface dil için çok merkezi olduğundan sık sorulan görüşme sorusu olması açısından önemlidir.