Wie finde ich den Typ eines Objekts in Go?

Question

Wie finde ich den Typ eines Objekts in Go? In Python verwende ich einfach typeof, um den Objekttyp zu erhalten. Gibt es in Go ähnlich wie in Python eine Möglichkeit, dasselbe zu implementieren?

Hier ist der Container, über den ich iteriere:

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

Ich kann den Typ des Objekts lines in diesem Fall nicht erhalten, das ein Array von Strings ist.

Answer 1

Das Go-Reflexionspaket verfügt über Methoden zum Inspezieren des Typs von Variablen.

Der folgende Codeausschnitt gibt den Reflexionstyp eines Strings, einer Ganzzahl und einer Gleitkommazahl 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))

}

Ausgabe:

string
int
float64

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

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

Answer 2

Ich habe 3 Möglichkeiten gefunden, um den Typ einer Variable zur Laufzeit zurückzugeben:

Verwendung von String-Formatierung

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

Verwendung des Reflect-Pakets

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

Verwendung von Type-Switch

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

Jede Methode hat einen anderen besten Anwendungsfall:

• String-Formatierung - kurz und wenig ressourcenintensiv (es ist nicht notwendig, das Reflect-Paket zu importieren)

• Reflect-Paket - wenn mehr Details über den Typ benötigt werden, haben wir Zugriff auf alle Reflektionsfunktionen

• Type-Switch - ermöglicht das Gruppieren von Typen, z.B. Erkennen aller int32, int64, uint32, uint64 Typen als "int"

Answer 3

Verwenden Sie das reflect Paket:

Package reflect implementiert Laufzeitreflexion, was einem Programm ermöglicht, Objekte mit beliebigen Typen zu manipulieren. Der typische Gebrauch ist, einen Wert mit statischem Typ interface{} zu nehmen und seine dynamische Typinformation zu extrahieren, indem man TypeOf aufruft, was 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))
}

Erzeugt:

bool
string
int
float64
[]string

Spielplatz

Beispiel für die Verwendung von 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()) // Für Slices und Strings
}

Erzeugt:

bool
string
int
float64
string

Spielplatz

Answer 4

Um eine Zeichenfolgenrepräsentation zu erhalten:

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

%T eine Go-Syntax-Repräsentation des Typs des Werts

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

Ausgaben:

string
int
float64
bool

Answer 5

Ich würde mich von dem reflect-Paket fernhalten. 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)
 }