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

¿Cómo encuentro el tipo de objeto en Go? En Python, solo uso typeofpara buscar el tipo de objeto. De manera similar, en Go, ¿hay alguna forma 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

consulte: 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 el paquete reflect

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

Usando 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: tamaño corto y bajo (no es necesario para importar el paquete reflect)

• Reflect package: cuando necesitemos 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"

Utilice la reflejan paquete:

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 interfaz de tipo estático {} y extraer su información de tipo dinámico llamando a TypeOf, que devuelve 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))
}

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 una 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 utilizar 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 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 estructura

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

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

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

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