Ispezionare i campi e i tag delle struct
Iterare sui campi e leggere i tag delle struct
Ispezionare i campi e i tag delle struct è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Tipo StructField
reflect.StructField descrive un campo di una struct: Name, Type, Tag, Index, Offset, Anonymous e IsExported.
Iterazione sui campi
Scorra in ciclo tutti i campi di un tipo struct:
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())
}Lettura dei tag delle struct
È possibile accedere ai tag tramite 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"Analisi delle opzioni dei tag
I tag possono contenere opzioni separate da virgole. Le analizzi 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 e FieldByIndex
Cerchi un campo per nome o indice. FieldByName cerca i campi esportati nella struct e nelle struct incorporate:
f, ok := reflect.TypeOf(User{}).FieldByName("Name")
if ok { fmt.Println(f.Tag.Get("json")) }Campi delle struct incorporate
Per le struct incorporate, Anonymous è true. Utilizzi Type.FieldByIndex([]int{0,1}) per accedere ai campi annidati.
Campi non esportati
I campi non esportati (in minuscolo) possono essere ispezionati per determinarne il tipo e il tag, ma i loro valori non possono essere letti o impostati tramite reflection: si verifica un panic.
Creazione di una cache dei campi
Analizzare i tag delle struct a ogni chiamata è costoso. Memorizzi il risultato in una sync.Map indicizzata per 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 d'uso: ORM semplice
Scorra tutti i campi con un tag "db" per creare dinamicamente un elenco di colonne 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 d'uso: caricatore della configurazione
Scorra i campi della struct con un tag "env" e li valorizzi a partire dalle variabili d'ambiente:
if env := f.Tag.Get("env"); env != "" {
if val := os.Getenv(env); val != "" {
v.Field(i).SetString(val)
}
}StructTag.Lookup
Tag.Lookup("key") restituisce il valore del tag e un booleano che indica se la chiave era effettivamente presente (a differenza di Get, che restituisce "" per le chiavi assenti).
val, ok := f.Tag.Lookup("json")
if !ok { /* no json tag */ }Verifica rapida
Come si legge il valore del tag "json" di una struct da un reflect.StructField?
Riepilogo: campi e tag delle struct
Punti chiave:
- reflect.TypeOf → .NumField(), .Field(i) per i metadati dei campi
- StructField.Tag.Get("key") per leggere i valori dei tag
- Memorizzare nella cache i metadati dei campi in sync.Map per evitare analisi ripetute
- Utilizzare Tag.Lookup quando è importante distinguere tra un tag assente e una stringa vuota
Domande Frequenti
La lezione «Ispezionare i campi e i tag delle struct» è gratuita?
Sì — il testo completo di «Ispezionare i campi e i tag delle struct» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Ispezionare i campi e i tag delle struct»?
Iterare sui campi e leggere i tag delle struct Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Ispezionare i campi e i tag delle struct»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- reflect.Type e reflect.Value
- Ispezionare i campi e i tag delle struct
- Chiamate dinamiche di funzioni
- Reflection pratica: serializzatori