Wie überprüft man den Typ einer Variablen in Go zur…

In Go kann der Typ einer Variablen zur Laufzeit auf mehrere Arten überprüft werden:

Verwendung von Type Assertion: Geeignet zur Überprüfung eines bestimmten Typs bei einer Schnittstellenvariablen.

package main

import "fmt"

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

    s, ok := i.(string) // Versuch, i in den Typ string zu konvertieren
    if ok {
        fmt.Printf("Variable i hat den Typ string: %s\n", s)
    } else {
        fmt.Println("Variable i hat nicht den Typ string")
    }
}

Verwendung von Type Switch: Geeignet zur Überprüfung mehrerer möglicher Typen bei einer Schnittstellenvariablen.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt hat einen konkreten Typ aus den Fällen
    case int:
        fmt.Printf("Variable hat den Typ int: %d\n", tt)
    case string:
        fmt.Printf("Variable hat den Typ string: %s\n", tt)
    case bool:
        fmt.Printf("Variable hat den Typ bool: %t\n", tt)
    case nil:
        fmt.Println("Variable hat den Wert nil")
    default:
        fmt.Printf("Unbekannter Typ: %T\n", tt) // tt hat den Typ interface{}
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("Variable hat den Typ int: %d\n", tt)
    case string:
        fmt.Printf("Variable hat den Typ string: %s\n", tt)
    case bool:
        fmt.Printf("Variable hat den Typ bool: %t\n", tt)
    case nil:
        fmt.Println("Variable hat den Wert nil")
    default:
        fmt.Printf("Unbekannter Typ: %T\n", tt)
    }
}

Verwendung des Pakets reflect: Ermöglicht das Abrufen von Informationen über den Typ und den Wert der Variablen zur Laufzeit. Wird verwendet, wenn die Typen zur Kompilierungszeit unbekannt sind oder für komplexere Überprüfungen.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Reflexionswert erhalten

    fmt.Println("Typ:", v.Type())                 // Gibt "Typ: float64" aus
    fmt.Println("Kategorie:", v.Kind())             // Gibt "Kategorie: float64" aus

    y := "hallo"
    vv := reflect.ValueOf(y)
    fmt.Println("Typ:", vv.Type())               // Gibt "Typ: string" aus
    fmt.Println("Kategorie:", vv.Kind())           // Gibt "Kategorie: string" aus

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Typ:", vvv.Type())             // Gibt "Typ: []int" aus
    fmt.Println("Kategorie:", vvv.Kind())         // Gibt "Kategorie: slice" aus
}

Das Paket reflect ist mächtiger, aber auch komplexer in der Anwendung. Type Assertion und Type Switch sind für einfache Typüberprüfungen bei Schnittstellenvariablen vorzuziehen, da sie sicherer und typorientierter sind.

Wie überprüft man den Typ einer Variablen in Go zur Laufzeit?