Go Academy · Lección

Análisis personalizado de etiquetas

Lea etiquetas mediante reflection

Análisis personalizado de etiquetas es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 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.

Leer las etiquetas directamente

Puede definir sus propias claves de etiqueta y leerlas en tiempo de ejecución con el paquete reflect. Esto permite crear comportamientos personalizados controlados por metadatos.

reflect.TypeOf

reflect.TypeOf devuelve un Type que describe un valor. A partir del Type de una estructura puede inspeccionar sus campos.

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string
}

func main() {
	t := reflect.TypeOf(User{})
	fmt.Println(t.Kind(), t.NumField())
}

Recorrer campos

NumField y Field(i) permiten recorrer todos los campos de un tipo de estructura.

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string
	Age  int
}

func main() {
	t := reflect.TypeOf(User{})
	for i := 0; i < t.NumField(); i++ {
		fmt.Println(t.Field(i).Name)
	}
}

Acceder a la etiqueta de un campo

Cada campo tiene un Tag de tipo reflect.StructTag. Llame a .Get(key) para leer el valor de una etiqueta específica.

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string "label:\"Full Name\""
}

func main() {
	f := reflect.TypeOf(User{}).Field(0)
	fmt.Println(f.Tag.Get("label"))
}

Definir una etiqueta personalizada

Puede inventar cualquier clave de etiqueta. Aquí, una etiqueta personalizada label describe un nombre legible para cada campo.

package main

import (
	"fmt"
	"reflect"
)

type Form struct {
	Email string "label:\"Email Address\""
	City  string "label:\"City\""
}

func main() {
	t := reflect.TypeOf(Form{})
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		fmt.Println(f.Name, "->", f.Tag.Get("label"))
	}
}

Tag.Lookup para etiquetas opcionales

Tag.Lookup(key) devuelve el valor y un booleano. Úselo para gestionar campos que quizá no tengan su etiqueta.

package main

import (
	"fmt"
	"reflect"
)

type Form struct {
	Email string "label:\"Email\""
	Token string
}

func main() {
	t := reflect.TypeOf(Form{})
	for i := 0; i < t.NumField(); i++ {
		v, ok := t.Field(i).Tag.Lookup("label")
		fmt.Println(t.Field(i).Name, v, ok)
	}
}

Leer también los valores de los campos

Combine reflect.ValueOf con el tipo para leer tanto la etiqueta como el valor actual de cada campo.

package main

import (
	"fmt"
	"reflect"
)

type Form struct {
	Email string "label:\"Email\""
}

func main() {
	f := Form{Email: "a@b.com"}
	t := reflect.TypeOf(f)
	v := reflect.ValueOf(f)
	fmt.Println(t.Field(0).Tag.Get("label"), "=", v.Field(0))
}

Analizar opciones de etiquetas

Si el valor de su etiqueta contiene varias opciones (como name,opt), sepárelas usted mismo con strings.Split usando la coma.

package main

import (
	"fmt"
	"strings"
)

func main() {
	tag := "name,omitempty"
	parts := strings.Split(tag, ",")
	fmt.Println("name:", parts[0], "opts:", parts[1:])
}

Un caso de uso pequeño

Al combinar estos conceptos, puede crear un mapa sencillo de etiquetas a partir de una estructura, que una capa de interfaz de usuario podría utilizar para mostrar las etiquetas de un formulario.

package main

import (
	"fmt"
	"reflect"
)

type Profile struct {
	Name string "label:\"Your Name\""
	Bio  string "label:\"About You\""
}

func main() {
	t := reflect.TypeOf(Profile{})
	labels := map[string]string{}
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		labels[f.Name] = f.Tag.Get("label")
	}
	fmt.Println(labels)
}

Costes de la reflexión

La reflexión es potente, pero más lenta que el código directo y omite las comprobaciones en tiempo de compilación. Úsela para funcionalidades propias de frameworks, no en bucles críticos.

Punteros y reflect

Si tiene un puntero, llame a reflect.TypeOf(v).Elem() para acceder al tipo de estructura subyacente antes de inspeccionar los campos.

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string "label:\"Name\""
}

func main() {
	u := &User{}
	t := reflect.TypeOf(u).Elem()
	fmt.Println(t.Field(0).Tag.Get("label"))
}

Comprobación rápida

¿Qué método permite leer el valor de una clave de etiqueta personalizada de un campo de estructura obtenido mediante reflexión?

Repaso

Análisis de etiquetas personalizadas:

Use reflect.TypeOf y recorra los campos
field.Tag.Get / Lookup leen los valores de las etiquetas
Separe los valores para analizar las opciones
Es potente, pero más lento; úselo para funcionalidades de frameworks

Preguntas frecuentes

¿La lección «Análisis personalizado de etiquetas» es gratis?

Sí — el texto completo de «Análisis personalizado de etiquetas» 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 «Análisis personalizado de etiquetas»?

Lea etiquetas mediante reflection 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 4 de 4.

¿Cuánto tiempo toma la lección «Análisis personalizado de etiquetas»?

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

← Volver a Go Academy