Jak zjistit typ proměnné v Go za běhu?

V prostředí běhu v Go lze proměnnou ověřit několika způsoby:

1. Použití type assertion: Vhodné pro ověření konkrétního typu u rozhraní.

   package main
   
   import "fmt"
   
   func main() {
       var i interface{} = "hello"
   
       s, ok := i.(string) // Pokus o konverzi i na typ string
       if ok {
           fmt.Printf("Proměnná i má typ string: %s\n", s)
       } else {
           fmt.Println("Proměnná i nemá typ string")
       }
   }
   

2. Použití type switch: Vhodné pro ověření několika možných typů.

   package main
   
   import "fmt"
   
   func main() {
       var t interface{}
   
       switch tt := t.(type) { // tt bude mít konkrétní typ
       case int:
           fmt.Printf("Proměnná má typ int: %d\n", tt)
       case string:
           fmt.Printf("Proměnná má typ string: %s\n", tt)
       case bool:
           fmt.Printf("Proměnná má typ bool: %t\n", tt)
       case nil:
           fmt.Println("Proměnná má hodnotu nil")
       default:
           fmt.Printf("Neznámý typ: %T\n", tt) // tt bude mít typ interface{}
       }
   
       t = 123
       switch tt := t.(type) {
       case int:
           fmt.Printf("Proměnná má typ int: %d\n", tt)
       case string:
           fmt.Printf("Proměnná má typ string: %s\n", tt)
       case bool:
           fmt.Printf("Proměnná má typ bool: %t\n", tt)
       case nil:
           fmt.Println("Proměnná má hodnotu nil")
       default:
           fmt.Printf("Neznámý typ: %T\n", tt)
       }
   }
   

3. Použití balíčku reflect: Umožňuje získat informace o typu a hodnotě proměnné za běhu. Používá se, když typy nejsou známy při kompilaci nebo pro složitější kontroly.

   package main
   
   import (
       "fmt"
       "reflect"
   )
   
   func main() {
       var x float64 = 3.4
       v := reflect.ValueOf(x) // Získání hodnoty reflexe
   
       fmt.Println("Typ:", v.Type())                 // Vypíše "Typ: float64"
       fmt.Println("Kategorie:", v.Kind())             // Vypíše "Kategorie: float64"
   
       y := "hello"
       vv := reflect.ValueOf(y)
       fmt.Println("Typ:", vv.Type())               // Vypíše "Typ: string"
       fmt.Println("Kategorie:", vv.Kind())           // Vypíše "Kategorie: string"
   
       z := []int{1, 2, 3}
       vvv := reflect.ValueOf(z)
       fmt.Println("Typ:", vvv.Type())             // Vypíše "Typ: []int"
       fmt.Println("Kategorie:", vvv.Kind())         // Vypíše "Kategorie: slice"
   }
   

Balíček reflect je mocnější, ale i složitější na použití. type assertion a type switch jsou vhodnější pro jednoduché kontroly typů rozhraní, protože jsou bezpečnější a typově orientované.