Comment trouver un type d’object dans Go?

Comment trouver le type d’object dans Go? En Python, j’utilise simplement typeof pour récupérer le type d’object. De même dans Go, y a-t-il un moyen d’implémenter la même chose?

Voici le conteneur à partir duquel je fais des itérations:

 for e := dlist.Front(); e != nil; e = e.Next() { lines := e.Value fmt.Printf(reflect.TypeOf(lines)) } 

Je ne peux pas obtenir le type des lignes d’object dans ce cas, qui est un tableau de chaînes.

    Le package de reflection Go a des méthodes pour inspecter le type de variables.

    L’extrait suivant affichera le type de reflection d’une chaîne, d’un entier et d’un flottant.

     package main import ( "fmt" "reflect" ) func main() { tst := "ssortingng" tst2 := 10 tst3 := 1.2 fmt.Println(reflect.TypeOf(tst)) fmt.Println(reflect.TypeOf(tst2)) fmt.Println(reflect.TypeOf(tst3)) } 

    voir: http://play.golang.org/p/XQMcUVsOja pour le voir en action.

    Plus de documentation ici: http://golang.org/pkg/reflect/#Type

    J’ai trouvé 3 façons de reconnaître le type à l’exécution:

    Utiliser le formatage de chaîne

     func typeof(v interface{}) ssortingng { return fmt.Sprintf("%T", v) } 

    Utiliser le paquet de reflection

     func typeof(v interface{}) ssortingng { return reflect.TypeOf(v).Ssortingng() } 

    Utiliser des assertions de type

     func typeof(v interface{}) ssortingng { switch v.(type) { case int: return "int" case float64: return "float64" //... etc default: return "unknown" } } 

    Chaque méthode a son meilleur cas d’utilisation:

    • formatage des chaînes – faible encombrement (pas besoin d’importer le paquet reflété)

    • refléter le paquet – quand besoin de plus de détails sur le type nous avons access aux capacités de reflection complètes

    • assertions de type – permet les types de regroupement, par exemple reconnaître tous les types int32, int64, uint32, uint64 comme “int”

    Utilisez le package de reflection :

    Le paquet Reflect implémente la reflection au moment de l’exécution, permettant à un programme de manipuler des objects avec des types arbitraires. L’utilisation typique consiste à prendre une valeur avec l’interface de type statique {} et à extraire ses informations de type dynamic en appelant TypeOf, qui renvoie un Type.

     package main import ( "fmt" "reflect" ) func main() { b := true s := "" n := 1 f := 1.0 a := []ssortingng{"foo", "bar", "baz"} fmt.Println(reflect.TypeOf(b)) fmt.Println(reflect.TypeOf(s)) fmt.Println(reflect.TypeOf(n)) fmt.Println(reflect.TypeOf(f)) fmt.Println(reflect.TypeOf(a)) } 

    Produit:

    bool
    chaîne
    int
    float64
    []chaîne

    Cour de récréation

    Exemple utilisant ValueOf(i interface{}).Kind() :

     package main import ( "fmt" "reflect" ) func main() { b := true s := "" n := 1 f := 1.0 a := []ssortingng{"foo", "bar", "baz"} fmt.Println(reflect.ValueOf(b).Kind()) fmt.Println(reflect.ValueOf(s).Kind()) fmt.Println(reflect.ValueOf(n).Kind()) fmt.Println(reflect.ValueOf(f).Kind()) fmt.Println(reflect.ValueOf(a).Index(0).Kind()) // For slices and ssortingngs } 

    Produit:

    bool
    chaîne
    int
    float64
    chaîne

    Cour de récréation

    Pour obtenir une représentation sous forme de chaîne:

    De http://golang.org/pkg/fmt/

    % T une représentation de la syntaxe Go du type de la valeur

     package main import "fmt" func main(){ types := []interface{} {"a",6,6.0,true} for _,v := range types{ fmt.Printf("%T\n",v) } } 

    Les sorties:

     ssortingng int float64 bool 

    Je restrais loin de la reflection. paquet. Au lieu de cela, utilisez% T

     package main import ( "fmt" ) func main() { b := true s := "" n := 1 f := 1.0 a := []ssortingng{"foo", "bar", "baz"} fmt.Printf("%T\n", b) fmt.Printf("%T\n", s) fmt.Printf("%T\n", n) fmt.Printf("%T\n", f) fmt.Printf("%T\n", a) } 

    Le meilleur moyen est d’utiliser le concept de reflection dans Google.
    reflect.TypeOf donne le type avec le nom du package
    reflect.TypeOf().Kind() donne le type de soulignement

    pour obtenir le type de champs dans struct

     package main import ( "fmt" "reflect" ) type testObject struct { Name ssortingng Age int Height float64 } func main() { tstObj := testObject{Name: "yog prakash", Age: 24, Height: 5.6} val := reflect.ValueOf(&tstObj).Elem() typeOfTstObj := val.Type() for i := 0; i < val.NumField(); i++ { fieldType := val.Field(i) fmt.Printf("object field %d key=%s value=%v type=%s \n", i, typeOfTstObj.Field(i).Name, fieldType.Interface(), fieldType.Type()) } } 

    Sortie

     object field 0 key=Name value=yog prakash type=ssortingng object field 1 key=Age value=24 type=int object field 2 key=Height value=5.6 type=float64 

    Voir dans l'IDE https://play.golang.org/p/bwIpYnBQiE

    Vous pouvez vérifier le type de toute variable / instance à l’exécution en utilisant la fonction TypeOf packages “reflect” ou en utilisant fmt.Printf() :

     package main import ( "fmt" "reflect" ) func main() { value1 := "Have a Good Day" value2 := 50 value3 := 50.78 fmt.Println(reflect.TypeOf(value1 )) fmt.Println(reflect.TypeOf(value2)) fmt.Println(reflect.TypeOf(value3)) fmt.Printf("%T",value1) fmt.Printf("%T",value2) fmt.Printf("%T",value3) } 

    vous pouvez utiliser reflect.TypeOf .

    • type de base (ex: int , ssortingng ): il renverra son nom (ex: int , ssortingng )
    • struct: il retournera quelque chose au format . (ex: main.test )

    Pour être bref, veuillez utiliser fmt.Println("%T", var1) ou ses autres variantes dans le paquetage fmt.

    refléter le paquet vient à sauver:

     reflect.TypeOf(obj).Ssortingng() 

    Vérifiez cette démo

    Vous pouvez simplement utiliser la méthode fmt package fmt.Printf (), plus d’informations: https://golang.org/pkg/fmt/

    exemple: https://play.golang.org/p/aJG5MOxjBJD