web-dev-qa-db-fra.com

Comment trouver un type d'objet dans Go?

Comment trouver le type d'un objet dans Go? En Python, je viens d'utiliser typeof pour récupérer le type d'objet. De même, dans Go, existe-t-il un moyen de mettre en œuvre le même?

Voici le conteneur à partir duquel je réitère:

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'objet dans ce cas qui est un tableau de chaînes.

gogo-reflect
326
Rahul

Le paquet de réflexion Go contient des méthodes pour inspecter le type de variables.

L'extrait suivant imprimera le type de réflexion d'une chaîne, d'un entier et d'un float.

package main

import (
    "fmt"
    "reflect"
)

func main() {

    tst := "string"
    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

404
dethtron5000

J'ai trouvé 3 façons de renvoyer le type d'une variable au moment de l'exécution:

Utilisation de format de chaîne

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

Utilisation de reflet du paquet

func typeof(v interface{}) string {
    return reflect.TypeOf(v).String()
}

Utilisation de assertions de type

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

Chaque méthode a un meilleur cas d'utilisation différent:

  • formatage de chaîne - encombrement réduit et faible (inutile d'importer le package reflect)

  • reflect package - quand besoin de plus de détails sur le type, nous avons accès à la totalité des capacités de réflexion

  • assertions de type - permet de regrouper les types, par exemple, reconnaît tous les types int32, int64, uint32, uint64 comme "int"

399
Grzegorz Luczywo

Utilisez le package reflect :

Package reflect implémente la réflexion à l'exécution, permettant à un programme de manipuler des objets avec des types arbitraires. L'utilisation typique consiste à prendre une valeur avec l'interface de type statique {} et à extraire ses informations de type dynamique en appelant TypeOf, qui renvoie un type.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"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
string
int
float64
[]string

Terrain de je

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

package main

import (
    "fmt"
    "reflect"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"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 strings
}

Produit:

bool
string
int
float64
string

Terrain de je

48
Intermernet

Pour obtenir une représentation 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:

string
int
float64
bool
42
globby

Je resterais loin de la réflexion. paquet. Utilisez plutôt% T

package main

import (
    "fmt"
)

func main() {
    b := true
    s := ""
    n := 1
    f := 1.0
    a := []string{"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)
 }
15
harold ramos

Le meilleur moyen consiste à utiliser le concept de réflexion dans Google.
reflect.TypeOf donne le type avec le nom du paquet
reflect.TypeOf().Kind() donne le type de soulignement

10
Jiten

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

7
prabhakar palanivel

Vous pouvez vérifier le type de toute variable/instance à l'exécution à l'aide de la fonction "reflect" de packages TypeOf ou de 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)
}
3
Kabeer Shaikh

Pour obtenir le type de champs dans struct

package main

import (
  "fmt"
  "reflect"
)

type testObject struct {
  Name   string
  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=string 
object field 1 key=Age value=24 type=int 
object field 2 key=Height value=5.6 type=float64

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

2
negi Yogi

vous pouvez utiliser reflect.TypeOf.

  • type de base (par exemple: int, string): il renverra son nom (par exemple: int, string)
  • struct: il retournera quelque chose au format <package name>.<struct name> (par exemple: main.test)
0
夜阑听风

réfléchissez le paquet vient à la rescousse:

reflect.TypeOf(obj).String()

Vérifiez ceci démo

0
Ismayil Niftaliyev

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

0
JORDANO