Go'da çalışma zamanında bir değişkenin türünü nasıl…

Go'da, çalışma zamanında bir değişkenin tipi birkaç farklı şekilde kontrol edilebilir:

Type assertion kullanarak: Bu, arayüz değişkeninde belirli bir tipi kontrol etmek için uygundur.

package main

import "fmt"

func main() {
    var i interface{} = "merhaba"

    s, ok := i.(string) // i'yi string tipine dönüştürmeye çalışma
    if ok {
        fmt.Printf("Değişken i'nin tipi string: %s\n", s)
    } else {
        fmt.Println("Değişken i'nin tipi string değil")
    }
}

Type switch kullanarak: Bu, arayüz değişkeninde birkaç olası tipi kontrol etmek için uygundur.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt, durumlara göre belirli bir tipe sahip olacak
    case int:
        fmt.Printf("Değişkenin tipi int: %d\n", tt)
    case string:
        fmt.Printf("Değişkenin tipi string: %s\n", tt)
    case bool:
        fmt.Printf("Değişkenin tipi bool: %t\n", tt)
    case nil:
        fmt.Println("Değişkenin değeri nil")
    default:
        fmt.Printf("Bilinmeyen tip: %T\n", tt) // tt, interface{} tipinde olacak
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("Değişkenin tipi int: %d\n", tt)
    case string:
        fmt.Printf("Değişkenin tipi string: %s\n", tt)
    case bool:
        fmt.Printf("Değişkenin tipi bool: %t\n", tt)
    case nil:
        fmt.Println("Değişkenin değeri nil")
    default:
        fmt.Printf("Bilinmeyen tip: %T\n", tt)
    }
}

reflect paketini kullanarak: Bu, değişkenin tipi ve değer bilgilerini çalışma zamanında almayı sağlar. Tipler derleme zamanında bilinmiyorsa veya daha karmaşık kontroller yapmak gerekiyorsa kullanılır.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Reflection değeri al

    fmt.Println("Tip:", v.Type())                 // "Tip: float64" gösterir
    fmt.Println("Kategori:", v.Kind())             // "Kategori: float64" gösterir

    y := "merhaba"
    vv := reflect.ValueOf(y)
    fmt.Println("Tip:", vv.Type())               // "Tip: string" gösterir
    fmt.Println("Kategori:", vv.Kind())           // "Kategori: string" gösterir

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Tip:", vvv.Type())             // "Tip: []int" gösterir
    fmt.Println("Kategori:", vvv.Kind())         // "Kategori: slice" gösterir
}

reflect paketi daha güçlüdür, ancak kullanımı daha karmaşıktır. Basit tip kontrolleri için type assertion ve type switch tercih edilir, çünkü daha güvenlidir ve tipe odaklıdır.

Go'da çalışma zamanında bir değişkenin türünü nasıl kontrol edersiniz?