¿Cómo encontrar el tipo de un objeto en Go?

¿Cómo encuentro el tipo de un objeto en Go? En Python, solo uso typeofpara buscar el tipo de objeto. Del mismo modo, en Go, ¿hay alguna manera de implementar lo mismo?

Aquí está el contenedor desde el que estoy iterando:

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

No puedo obtener el tipo de líneas de objeto en este caso, que es una matriz de cadenas.

El paquete de reflexión Go tiene métodos para inspeccionar el tipo de variables.

El siguiente fragmento imprimirá el tipo de reflexión de una cadena, entero y flotante.

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

}

Salida:

Hello, playground
string
int
float64

ver: http://play.golang.org/p/XQMcUVsOja para verlo en acción.

Más documentación aquí: http://golang.org/pkg/reflect/#Type

Encontré 3 formas de devolver el tipo de una variable en tiempo de ejecución:

Usar formato de cadena

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

Usando paquete de reflejo

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

Usar aserciones de tipo

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

Cada método tiene un mejor caso de uso diferente:

• formato de cadena: huella corta y baja (no es necesario para importar el paquete reflejado)

• paquete de reflexión: cuando se necesitan más detalles sobre el tipo, tenemos acceso a las capacidades de reflexión completa

• aserciones de tipo: permite agrupar tipos, por ejemplo, reconocer todos los tipos int32, int64, uint32, uint64 como "int"

Use el paquete de reflexión :

Package reflect implementa la reflexión en tiempo de ejecución, lo que permite que un programa manipule objetos con tipos arbitrarios. El uso típico es tomar un valor con la interfaz de tipo estático {} y extraer su información de tipo dinámico llamando a TypeOf, que devuelve un Tipo.

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

Produce:

bool
string
int
float64
[]string

Patio de recreo

Ejemplo usando 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
}

Produce:

bool
string
int
float64
string

Patio de recreo

Para obtener una representación de cadena:

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

% T a Representación de sintaxis Go del tipo de valor

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

Salidas:

string
int
float64
bool

Me mantendría alejado del reflejo. paquete. En su lugar, use% 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)
 }

La mejor manera es usar el concepto de reflexión en Google.
reflect.TypeOfda el tipo junto con el nombre del paquete
reflect.TypeOf().Kind()da el tipo de subrayado

Para ser breve, utilice fmt.Printf("%T", var1) o sus otras variantes en el paquete fmt.

Puede verificar el tipo de cualquier variable / instancia en tiempo de ejecución ya sea usando la TypeOffunción de paquetes "reflect" o usando 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)
}

Para obtener el tipo de campos en 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())
   }
}

Salida

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

Ver en IDE https://play.golang.org/p/bwIpYnBQiE

puedes usar reflect.TypeOf.

• tipo básico (por ejemplo: int, string): le proporcione su nombre (por ejemplo: int, string)
• struct: se volverá algo en el formato <package name>.<struct name>(por ejemplo: main.test)

Si tenemos estas variables:

var counter int = 5
var message string  = "Hello"
var factor float32 = 4.2
var enabled bool = false

1: formato fmt.Printf% T : para usar esta función, debe importar "fmt"

fmt.Printf("%T \n",factor )   // factor type: float32

2: función reflect.TypeOf : para utilizar esta función, debe importar "reflect"

fmt.Println(reflect.TypeOf(enabled)) // enabled type:  bool

3: reflect.ValueOf (X) .Kind () : para usar esta función, debe importar "reflect"

fmt.Println(reflect.ValueOf(counter).Kind()) // counter type:  int

Puedes usar: interface{}..(type)como en este patio de recreo

package main
import "fmt"
func main(){
    types := []interface{} {"a",6,6.0,true}
    for _,v := range types{
        fmt.Printf("%T\n",v)
        switch v.(type) {
        case int:
           fmt.Printf("Twice %v is %v\n", v, v.(int) * 2)
        case string:
           fmt.Printf("%q is %v bytes long\n", v, len(v.(string)))
       default:
          fmt.Printf("I don't know about type %T!\n", v)
      }
    }
}

el paquete reflect viene a rescatar:

reflect.TypeOf(obj).String()

Mira esta demo

Puede usar el método fmt package fmt.Printf (), más información: https://golang.org/pkg/fmt/

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