una - ¿Cómo encontrar un tipo de objeto en Go?
reconocer font (12)
¿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.
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
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
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"
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
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)
}
Para obtener una representación de cadena:
% 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
Para ser breve, utilice fmt.Println("%T", var1) o sus otras variantes en el paquete fmt.
Puede usar el método fmt package fmt.Printf (), más información: https://golang.org/pkg/fmt/
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)
}
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
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
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)