Go Academy · Aula

Análise personalizada de tags

Leia tags por meio de reflexão

Análise personalizada de tags é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Lendo tags por conta própria

Você pode definir suas próprias chaves de tag e lê-las em tempo de execução com o pacote reflect. Isso permite criar comportamentos personalizados orientados por metadados.

reflect.TypeOf

reflect.TypeOf retorna um tipo que descreve um valor. A partir de um tipo de estrutura, você pode inspecionar seus campos.

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string
}

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

Percorrendo campos

NumField e Field(i) permitem percorrer todos os campos de um tipo de estrutura.

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)
	}
}

Acessando a tag de um campo

Cada campo tem uma Tag do tipo reflect.StructTag. Chame .Get(key) para ler o valor de uma tag 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"))
}

Definindo uma tag personalizada

Você pode inventar qualquer chave de tag. Aqui, uma tag personalizada label descreve um nome amigável 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 tags opcionais

Tag.Lookup(key) retorna o valor e um booleano. Use-o para lidar com campos que talvez não tenham sua tag.

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)
	}
}

Lendo também os valores dos campos

Combine reflect.ValueOf com o tipo para ler tanto a tag quanto o valor atual 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))
}

Analisando opções de tags

Se o valor da sua tag reunir opções (como name,opt), divida-o por conta própria com strings.Split usando a vírgula.

package main

import (
	"fmt"
	"strings"
)

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

Um pequeno caso de uso

Juntando tudo: crie um mapa simples de rótulos a partir de uma estrutura, que uma camada de interface poderia usar para renderizar rótulos de formulário.

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)
}

Custos da reflexão

A reflexão é poderosa, mas mais lenta que o código direto e ignora verificações em tempo de compilação. Use-a para recursos no estilo de estruturas de suporte, não em laços executados com frequência.

Ponteiros e reflect

Se você tiver um ponteiro, chame reflect.TypeOf(v).Elem() para acessar o tipo de estrutura subjacente antes de inspecionar os 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"))
}

Verificação rápida

Qual método lê o valor de uma chave de tag personalizada de um campo de estrutura obtido por reflexão?

Recapitulação

Análise de tags personalizadas:

Use reflect.TypeOf e percorra os campos
field.Tag.Get / Lookup leem os valores das tags
Divida os valores para analisar as opções
É poderoso, mas mais lento; use-o para recursos de estruturas de suporte

Perguntas Frequentes

A aula “Análise personalizada de tags” é grátis?

Sim — o texto completo de “Análise personalizada de tags” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Análise personalizada de tags”?

Leia tags por meio de reflexão Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Análise personalizada de tags”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy