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

reconocer font

Question

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

Aquí está el contenedor del cual 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.

Answer 1

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

Answer 2

El paquete Go Reflection tiene métodos para inspeccionar el tipo de variables.

El siguiente fragmento de código 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))

}

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

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

Answer 3

Encontré 3 formas de reconocer el tipo en tiempo de ejecución:

Usando el formato de cadena

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

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

• paquete reflectante: cuando necesite más detalles sobre el tipo, tenemos acceso a todas las capacidades de reflexión.

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

Answer 4

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

Answer 5

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

Answer 6

Para obtener una representación de cadena:

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

% T una representación de sintaxis de Go del tipo del 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

Answer 7

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

Answer 8

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

Answer 9

Puede verificar el tipo de cualquier variable / instancia en tiempo de ejecución utilizando la función TypeOf paquetes "reflejo" 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)
}

Answer 10

Utilice el paquete de reflejo :

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 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
cuerda
En t
flotar64
[]cuerda

Playground

Ejemplo utilizando 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
cuerda
En t
flotar64
cuerda

Playground

Answer 11

paquete reflect viene a rescatar:

reflect.TypeOf(obj).String()

Mira esta demo

Answer 12

puede utilizar reflect.TypeOf .

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