Cum verifici tipul unei variabile în Go în timpul…

În Go, tipul unei variabile în timpul execuției poate fi verificat în mai multe moduri:

Folosind aserțiunea de tip: Potrivit pentru verificarea unui tip specific într-o variabilă de interfață.

package main

import "fmt"

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

    s, ok := i.(string) // Încercarea de a converti i în tipul string
    if ok {
        fmt.Printf("Variabila i are tipul string: %s\n", s)
    } else {
        fmt.Println("Variabila i nu are tipul string")
    }
}

Folosind switch pe tip: Potrivit pentru verificarea mai multor tipuri posibile într-o variabilă de interfață.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt va avea un tip concret din cazuri
    case int:
        fmt.Printf("Variabila are tipul int: %d\n", tt)
    case string:
        fmt.Printf("Variabila are tipul string: %s\n", tt)
    case bool:
        fmt.Printf("Variabila are tipul bool: %t\n", tt)
    case nil:
        fmt.Println("Variabila are valoarea nil")
    default:
        fmt.Printf("Tip necunoscut: %T\n", tt) // tt va avea tipul interface{}
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("Variabila are tipul int: %d\n", tt)
    case string:
        fmt.Printf("Variabila are tipul string: %s\n", tt)
    case bool:
        fmt.Printf("Variabila are tipul bool: %t\n", tt)
    case nil:
        fmt.Println("Variabila are valoarea nil")
    default:
        fmt.Printf("Tip necunoscut: %T\n", tt)
    }
}

Folosind pachetul reflect: Permite obținerea de informații despre tipul și valoarea variabilei în timpul execuției. Este utilizat atunci când tipurile nu sunt cunoscute în timpul compilării sau pentru verificări mai complexe.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Obține valoarea de reflecție

    fmt.Println("Tip:", v.Type())                 // Afișează "Tip: float64"
    fmt.Println("Categorie:", v.Kind())             // Afișează "Categorie: float64"

    y := "salut"
    vv := reflect.ValueOf(y)
    fmt.Println("Tip:", vv.Type())               // Afișează "Tip: string"
    fmt.Println("Categorie:", vv.Kind())           // Afișează "Categorie: string"

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Tip:", vvv.Type())             // Afișează "Tip: []int"
    fmt.Println("Categorie:", vvv.Kind())         // Afișează "Categorie: slice"
}

Pachetul reflect este mai puternic, dar și mai complex de utilizat. Aserțiunea de tip și switch-ul de tip sunt preferate pentru verificări simple ale tipurilor variabilelor de interfață, deoarece sunt mai sigure și orientate pe tip.

Cum verifici tipul unei variabile în Go în timpul execuției?