0Pricing
Go Academy · Lección

reflect.Type y reflect.Value

TypeOf, ValueOf, Kind y Elem

reflect.Type y reflect.Value es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Descripción general del paquete reflect

El paquete reflect permite a los programas Go inspeccionar tipos y valores en tiempo de ejecución. Es la base de las bibliotecas de codificación, los ORM y los frameworks de inyección de dependencias.

reflect.TypeOf

reflect.TypeOf(x) devuelve el reflect.Type del valor de x:

t := reflect.TypeOf(42)
fmt.Println(t.Name())    // "int"
fmt.Println(t.Kind())    // "int"
fmt.Println(t.String())  // "int"

reflect.ValueOf

reflect.ValueOf(x) devuelve un reflect.Value que contiene x. Puede leer el valor mediante métodos específicos de Kind:

v := reflect.ValueOf(42)
fmt.Println(v.Kind())    // "int"
fmt.Println(v.Int())     // 42

Type.Kind frente a Type.Name

Kind es la categoría subyacente de Go (int, struct, ptr, slice, ...). Name es el nombre del tipo declarado ("MyStruct"). Las interfaces tienen Kind == Interface, pero no tienen Name.

Campos de una estructura

Inspeccione los campos de una estructura mediante Type.NumField() y Type.Field(i), que devuelve un reflect.StructField:

t := reflect.TypeOf(User{})
for i := 0; i < t.NumField(); i++ {
    f := t.Field(i)
    fmt.Printf("Field: %s Type: %s Tag: %s\n", f.Name, f.Type, f.Tag.Get("json"))
}

Lectura de valores de campos de una estructura

Utilice Value.FieldByName o Value.Field(i) para leer valores de campos en tiempo de ejecución:

v := reflect.ValueOf(user)
nameField := v.FieldByName("Name")
fmt.Println(nameField.String()) // "Alice"

Asignación de valores a campos de una estructura

Para asignar un campo, el valor debe ser direccionable (debe pasarse como puntero):

v := reflect.ValueOf(&user).Elem()
v.FieldByName("Name").SetString("Bob")

Indirección de punteros

Si un valor es un puntero, llame a v.Elem() para obtener el valor apuntado. Compruebe primero v.Kind() == reflect.Ptr.

if v.Kind() == reflect.Ptr {
    v = v.Elem()
}

reflect.New

Cree un nuevo valor cero de un tipo y obtenga un puntero a él:

t := reflect.TypeOf(User{})
ptr := reflect.New(t) // *User
user := ptr.Interface().(*User)

Llamada a métodos

Llame a un método por nombre sobre un valor reflejado:

v := reflect.ValueOf(user)
m := v.MethodByName("Greet")
results := m.Call(nil)
fmt.Println(results[0].String())

Rendimiento

La reflexión es entre 5 y 10 veces más lenta que el código directo. Almacene en caché las búsquedas de reflect.Type y reflect.Value fuera de los bucles críticos. Utilice generación de código cuando el rendimiento sea esencial.

Comprobación rápida

¿Cuál es la diferencia entre reflect.Type.Kind() y reflect.Type.Name()?

Resumen: reflect.Type y reflect.Value

Puntos clave:

  • reflect.TypeOf/ValueOf para inspeccionar tipos en tiempo de ejecución
  • Kind: categoría subyacente; Name: nombre declarado
  • Value.FieldByName + SetXxx para manipular campos de estructuras
  • Pasar un puntero y llamar a Elem() para obtener valores asignables

Preguntas frecuentes

¿La lección «reflect.Type y reflect.Value» es gratis?

Sí — el texto completo de «reflect.Type y reflect.Value» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «reflect.Type y reflect.Value»?

TypeOf, ValueOf, Kind y Elem Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «reflect.Type y reflect.Value»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. reflect.Type y reflect.Value
  2. Inspección de campos y etiquetas de structs
  3. Llamadas dinámicas a funciones
  4. Reflection práctica: serializadores
← Volver a Go Academy