Inspección de campos y etiquetas de structs
Iteración de campos y lectura de etiquetas de structs
Inspección de campos y etiquetas de structs es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 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.
Tipo StructField
reflect.StructField describe un campo de una estructura: Name, Type, Tag, Index, Offset, Anonymous e IsExported.
Iteración de campos
Recorra en un bucle todos los campos de un tipo de estructura:
t := reflect.TypeOf(struct{ ID int; Name string }{})
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
fmt.Println(f.Name, f.Type, f.IsExported())
}Lectura de tags de estructuras
Se accede a los tags mediante StructField.Tag.Get("key"):
type User struct {
ID int `json:"id" db:"user_id"`
Name string `json:"name,omitempty"`
}
f, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(f.Tag.Get("json")) // "name,omitempty"Análisis de opciones de tags
Los tags pueden contener opciones separadas por comas. Analícelos con strings.Split:
tag := f.Tag.Get("json") // "name,omitempty"
parts := strings.Split(tag, ",")
name := parts[0] // "name"
omitempty := len(parts) > 1 && parts[1] == "omitempty"FieldByName y FieldByIndex
Busque un campo por nombre o índice. FieldByName busca campos exportados en la estructura y en las estructuras embebidas:
f, ok := reflect.TypeOf(User{}).FieldByName("Name")
if ok { fmt.Println(f.Tag.Get("json")) }Campos de estructuras embebidas
En las estructuras embebidas, Anonymous es true. Utilice Type.FieldByIndex([]int{0,1}) para acceder a campos anidados.
Campos no exportados
Los campos no exportados (en minúsculas) pueden inspeccionarse para consultar su tipo y tag, pero sus valores no se pueden leer ni asignar mediante reflexión; se produce un pánico.
Creación de una caché de campos
Analizar los tags de estructuras en cada llamada es costoso. Almacene el resultado en un sync.Map indexado por reflect.Type:
var fieldCache sync.Map
func getFields(t reflect.Type) []fieldInfo {
if v, ok := fieldCache.Load(t); ok { return v.([]fieldInfo) }
fields := parseFields(t)
fieldCache.Store(t, fields)
return fields
}Caso de uso: ORM sencillo
Recorra todos los campos con un tag "db" para construir dinámicamente una lista de columnas INSERT:
t := reflect.TypeOf(u)
v := reflect.ValueOf(u)
for i := 0; i < t.NumField(); i++ {
col := t.Field(i).Tag.Get("db")
val := v.Field(i).Interface()
// build query...
}Caso de uso: cargador de configuración
Recorra los campos de la estructura que tengan un tag "env" y asígneles valores de las variables de entorno:
if env := f.Tag.Get("env"); env != "" {
if val := os.Getenv(env); val != "" {
v.Field(i).SetString(val)
}
}StructTag.Lookup
Tag.Lookup("key") devuelve el valor del tag y un booleano que indica si la clave estaba presente, a diferencia de Get, que devuelve "" cuando faltan claves.
val, ok := f.Tag.Lookup("json")
if !ok { /* no json tag */ }Comprobación rápida
¿Cómo se lee el valor del tag de estructura "json" de un reflect.StructField?
Resumen: campos y tags de estructuras
Puntos clave:
- reflect.TypeOf → .NumField(), .Field(i) para obtener metadatos de campos
- StructField.Tag.Get("key") para leer valores de tags
- Almacenar los metadatos de campos en sync.Map para evitar análisis repetidos
- Utilizar Tag.Lookup cuando sea importante distinguir entre un tag ausente y una cadena vacía
Preguntas frecuentes
¿La lección «Inspección de campos y etiquetas de structs» es gratis?
Sí — el texto completo de «Inspección de campos y etiquetas de structs» 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 «Inspección de campos y etiquetas de structs»?
Iteración de campos y lectura de etiquetas de structs 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 2 de 4.
¿Cuánto tiempo toma la lección «Inspección de campos y etiquetas de structs»?
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
- reflect.Type y reflect.Value
- Inspección de campos y etiquetas de structs
- Llamadas dinámicas a funciones
- Reflection práctica: serializadores