Hoe controleer je het type van een variabele in Go…

In Go kan het type van een variabele tijdens runtime op verschillende manieren worden gecontroleerd:

Gebruik maken van type assertion: Geschikt voor het controleren van een specifiek type op een interface-variabele.

package main

import "fmt"

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

    s, ok := i.(string) // Poging om i te converteren naar string
    if ok {
        fmt.Printf("Variabele i heeft type string: %s\n", s)
    } else {
        fmt.Println("Variabele i heeft niet het type string")
    }
}

Gebruik maken van type switch: Geschikt voor het controleren van meerdere mogelijke types op een interface-variabele.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt krijgt een concreet type uit de cases
    case int:
        fmt.Printf("Variabele heeft type int: %d\n", tt)
    case string:
        fmt.Printf("Variabele heeft type string: %s\n", tt)
    case bool:
        fmt.Printf("Variabele heeft type bool: %t\n", tt)
    case nil:
        fmt.Println("Variabele heeft waarde nil")
    default:
        fmt.Printf("Onbekend type: %T\n", tt) // tt krijgt type interface{}
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("Variabele heeft type int: %d\n", tt)
    case string:
        fmt.Printf("Variabele heeft type string: %s\n", tt)
    case bool:
        fmt.Printf("Variabele heeft type bool: %t\n", tt)
    case nil:
        fmt.Println("Variabele heeft waarde nil")
    default:
        fmt.Printf("Onbekend type: %T\n", tt)
    }
}

Gebruik maken van het reflect-pakket: Hiermee kan informatie over het type en de waarde van de variabele worden verkregen tijdens runtime. Wordt gebruikt wanneer de types niet bekend zijn tijdens compilatie of voor complexere controles.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Verkrijg de reflectiewaarde

    fmt.Println("Type:", v.Type())                 // Geeft "Type: float64" weer
    fmt.Println("Categorie:", v.Kind())             // Geeft "Categorie: float64" weer

    y := "hallo"
    vv := reflect.ValueOf(y)
    fmt.Println("Type:", vv.Type())               // Geeft "Type: string" weer
    fmt.Println("Categorie:", vv.Kind())           // Geeft "Categorie: string" weer

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Type:", vvv.Type())             // Geeft "Type: []int" weer
    fmt.Println("Categorie:", vvv.Kind())         // Geeft "Categorie: slice" weer
}

Het reflect-pakket is krachtiger, maar ook complexer in gebruik. Type assertion en type switch worden aanbevolen voor eenvoudige typecontroles op interface-variabelen, omdat ze veiliger en typegericht zijn.

Hoe controleer je het type van een variabele in Go tijdens runtime?