it-swarm.com.de

Wie finde ich einen Objekttyp in Go?

Wie finde ich den Typ eines Objekts in Go? In Python benutze ich einfach typeof, um den Objekttyp abzurufen. Gibt es in Go eine Möglichkeit, dasselbe zu implementieren?

Hier ist der Container, aus dem ich iteriere:

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

In diesem Fall kann ich den Typ der Objektzeilen nicht ermitteln, da es sich um ein Array von Zeichenfolgen handelt.

326
Rahul

Das Go Reflection-Paket enthält Methoden zum Überprüfen des Variablentyps.

Das folgende Snippet gibt den Reflektionstyp eines Strings, einer Ganzzahl und eines Floats aus.

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))

}

siehe: http://play.golang.org/p/XQMcUVsOja um es in Aktion zu sehen.

Weitere Dokumentation hier: http://golang.org/pkg/reflect/#Type

404
dethtron5000

Ich habe drei Möglichkeiten gefunden, den Typ einer Variablen zur Laufzeit zurückzugeben:

Verwenden von Zeichenfolgenformatierung

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

Verwenden von Paket widerspiegeln

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

Verwenden von Typzusicherungen

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

Jede Methode hat einen anderen besten Anwendungsfall:

  • zeichenfolgenformatierung - kurze und geringe Stellfläche (nicht erforderlich, um das Reflect-Paket zu importieren)

  • reflect-Paket - Wenn Sie weitere Informationen zum Typ benötigen, haben Sie Zugriff auf alle Reflect-Funktionen

  • typzusicherungen - Ermöglichen das Gruppieren von Typen, beispielsweise das Erkennen aller int32-, int64-, uint32- und uint64-Typen als "int".

399

Verwenden Sie das Paket reflect :

Package reflect implementiert die Laufzeitreflexion, sodass ein Programm Objekte mit beliebigen Typen bearbeiten kann. Die typische Verwendung besteht darin, einen Wert mit der statischen Typschnittstelle {} zu verwenden und seine dynamischen Typinformationen durch Aufrufen von TypeOf zu extrahieren, das einen Typ zurückgibt.

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))
}

Produziert:

bool
string
int
float64
[]string

Spielplatz

Beispiel mit 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
}

Produziert:

bool
string
int
float64
string

Spielplatz

48
Intermernet

So rufen Sie eine Zeichenfolgendarstellung ab:

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

% T eine Go-Syntax-Darstellung des Werttyps

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

Ausgänge:

string
int
float64
bool
42
globby

Ich würde mich vom Spiegeln fernhalten. Paket. Verwenden Sie stattdessen% 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

Der beste Weg ist das Reflection-Konzept in Google.
reflect.TypeOf gibt den Typ zusammen mit dem Paketnamen an
reflect.TypeOf().Kind() gibt den Unterstreichungstyp an

10
Jiten

Um es kurz zu machen, benutzen Sie bitte fmt.Printf("%T", var1) oder seine anderen Varianten im fmt-Paket.

7

Sie können den Typ einer Variablen/Instanz zur Laufzeit entweder mit der Funktion "reflect" packages TypeOf oder mit fmt.Printf() überprüfen:

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

Um die Art der Felder in struct zu erhalten

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())
   }
}

Ausgabe

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

Siehe in IDE https://play.golang.org/p/bwIpYnBQiE

2
negi Yogi

sie können reflect.TypeOf verwenden.

  • basistyp (z. B .: int, string): Der Name wird zurückgegeben (z. B .: int, string)
  • struct: gibt etwas im Format <package name>.<struct name> zurück (z. B .: main.test)
0
夜阑听风

reflektieren Paket kommt zur Rettung:

reflect.TypeOf(obj).String()

Überprüfen Sie diese Demo

0

Sie können einfach die Methode fmt.Printf () des fmt-Pakets verwenden, weitere Informationen: https://golang.org/pkg/fmt/

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

0
JORDANO