Comment vérifier le type d'une variable en Go à…

En Go, le type d'une variable à l'exécution peut être vérifié de plusieurs façons :

En utilisant l'assertion de type : Approprié pour vérifier un type spécifique dans une variable d'interface.

package main

import "fmt"

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

    s, ok := i.(string) // Tentative de conversion de i en string
    if ok {
        fmt.Printf("La variable i a le type string : %s\n", s)
    } else {
        fmt.Println("La variable i n'a pas le type string")
    }
}

En utilisant un switch de type : Approprié pour vérifier plusieurs types possibles dans une variable d'interface.

package main

import "fmt"

func main() {
    var t interface{}

    switch tt := t.(type) { // tt aura un type concret parmi les cas
    case int:
        fmt.Printf("La variable a le type int : %d\n", tt)
    case string:
        fmt.Printf("La variable a le type string : %s\n", tt)
    case bool:
        fmt.Printf("La variable a le type bool : %t\n", tt)
    case nil:
        fmt.Println("La variable a la valeur nil")
    default:
        fmt.Printf("Type inconnu : %T\n", tt) // tt aura le type interface{}
    }

    t = 123
    switch tt := t.(type) {
    case int:
        fmt.Printf("La variable a le type int : %d\n", tt)
    case string:
        fmt.Printf("La variable a le type string : %s\n", tt)
    case bool:
        fmt.Printf("La variable a le type bool : %t\n", tt)
    case nil:
        fmt.Println("La variable a la valeur nil")
    default:
        fmt.Printf("Type inconnu : %T\n", tt)
    }
}

En utilisant le package reflect : Permet d'obtenir des informations sur le type et la valeur de la variable à l'exécution. Utilisé lorsque les types sont inconnus lors de la compilation ou pour effectuer des vérifications plus complexes.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x) // Obtention de la valeur de réflexion

    fmt.Println("Type :", v.Type())                 // Affiche "Type : float64"
    fmt.Println("Catégorie :", v.Kind())             // Affiche "Catégorie : float64"

    y := "bonjour"
    vv := reflect.ValueOf(y)
    fmt.Println("Type :", vv.Type())               // Affiche "Type : string"
    fmt.Println("Catégorie :", vv.Kind())           // Affiche "Catégorie : string"

    z := []int{1, 2, 3}
    vvv := reflect.ValueOf(z)
    fmt.Println("Type :", vvv.Type())             // Affiche "Type : []int"
    fmt.Println("Catégorie :", vvv.Kind())         // Affiche "Catégorie : slice"
}

Le package reflect est plus puissant mais aussi plus complexe à utiliser. L'assertion de type et le switch de type sont préférés pour des vérifications simples de types dans des variables d'interface, car ils sont plus sûrs et orientés vers le type.

Comment vérifier le type d'une variable en Go à l'exécution?