Hogyan ellenőrizzük egy változó típusát Go-ban futás…

Go-ban a futási környezetben lévő változót többféleképpen lehet ellenőrizni:

Type assertion használatával: Kifejezetten az interfész típusának ellenőrzésére alkalmas.

package main

import "fmt"

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

    s, ok := i.(string) // Megpróbálja konvertálni i-t string típusra
    if ok {
        fmt.Printf("Az i változó string típusú: %s\n", s)
    } else {
        fmt.Println("Az i változó nem string típusú")
    }
}

Type switch használatával: Több lehetséges típus ellenőrzésére alkalmas.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt a konkrét típus lesz
    case int:
        fmt.Printf("Az t változó int típusú: %d\n", tt)
    case string:
        fmt.Printf("Az t változó string típusú: %s\n", tt)
    case bool:
        fmt.Printf("Az t változó bool típusú: %t\n", tt)
    case nil:
        fmt.Println("Az t változó nil értékű")
    default:
        fmt.Printf("Ismeretlen típus: %T\n", tt) // tt az interface{} típus
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("Az t változó int típusú: %d\n", tt)
    case string:
        fmt.Printf("Az t változó string típusú: %s\n", tt)
    case bool:
        fmt.Printf("Az t változó bool típusú: %t\n", tt)
    case nil:
        fmt.Println("Az t változó nil értékű")
    default:
        fmt.Printf("Ismeretlen típus: %T\n", tt)
    }
}

A reflect csomag használatával: Lehetővé teszi a típus és érték információinak lekérdezését futási időben. Akkor hasznos, ha a típusok nem ismertek fordításkor vagy összetettebb ellenőrzésekhez.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Reflexió értékének lekérése

    fmt.Println("Típus:", v.Type())                 // "Típus: float64"
    fmt.Println("Kategória:", v.Kind())             // "Kategória: float64"

    y := "hello"
    vv := reflect.ValueOf(y)
    fmt.Println("Típus:", vv.Type())               // "Típus: string"
    fmt.Println("Kategória:", vv.Kind())           // "Kategória: string"

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Típus:", vvv.Type())             // "Típus: []int"
    fmt.Println("Kategória:", vvv.Kind())         // "Kategória: slice"
}

A reflect csomag erőteljes, de összetettebb használni. A type assertion és a type switch egyszerűbb típusellenőrzésekhez ajánlott, mivel biztonságosabbak és típusorientáltak.

Hogyan ellenőrizzük egy változó típusát Go-ban futás közben?