Go Academy · Lekcja

Inspekcja pól i tagów struktur

Iterowanie po polach i odczytywanie tagów struktur

Inspekcja pól i tagów struktur to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Typ StructField

reflect.StructField opisuje jedno pole struktury: Name, Type, Tag, Index, Offset, Anonymous i IsExported.

Iterowanie po polach

Iterować po wszystkich polach typu struktury:

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

Odczytywanie tagów struktury

Do tagów uzyskuje się dostęp za pomocą 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"

Analizowanie opcji tagów

Tagi mogą zawierać opcje oddzielone przecinkami. Należy je analizować za pomocą 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 i FieldByIndex

Wyszukiwać pole po nazwie lub indeksie. FieldByName przeszukuje eksportowane pola struktury oraz struktur osadzonych:

f, ok := reflect.TypeOf(User{}).FieldByName("Name")
if ok { fmt.Println(f.Tag.Get("json")) }

Pola struktur osadzonych

W przypadku struktur osadzonych wartość Anonymous to true. Do uzyskiwania dostępu do pól zagnieżdżonych należy użyć Type.FieldByIndex([]int{0,1}).

Pola nieeksportowane

Nieeksportowane pola (pisane małą literą) można sprawdzać pod kątem ich typu i taga, ale ich wartości nie można odczytywać ani ustawiać za pomocą refleksji — powoduje to panikę.

Tworzenie pamięci podręcznej pól

Analizowanie tagów struktury przy każdym wywołaniu jest kosztowne. Należy buforować wynik w sync.Map indeksowanej kluczem 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
}

Przypadek użycia: prosty ORM

Należy przejść po wszystkich polach z tagiem "db", aby dynamicznie zbudować listę kolumn 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...
}

Przypadek użycia: moduł wczytujący konfigurację

Należy przejść po polach struktury z tagiem "env" i wypełnić je zmiennymi środowiskowymi:

if env := f.Tag.Get("env"); env != "" {
    if val := os.Getenv(env); val != "" {
        v.Field(i).SetString(val)
    }
}

StructTag.Lookup

Tag.Lookup("key") zwraca wartość taga oraz wartość logiczną wskazującą, czy dany klucz w ogóle występował (w przeciwieństwie do Get, które dla nieobecnych kluczy zwraca "").

val, ok := f.Tag.Lookup("json")
if !ok { /* no json tag */ }

Szybkie sprawdzenie

Jak odczytać wartość taga struktury "json" z reflect.StructField?

Podsumowanie: pola i tagi struktur

Najważniejsze informacje:

reflect.TypeOf → .NumField(), .Field(i) służą do uzyskiwania metadanych pól
StructField.Tag.Get("key") służy do odczytywania wartości tagów
Buforować metadane pól w sync.Map, aby uniknąć wielokrotnego analizowania
Używać Tag.Lookup, gdy istotne jest rozróżnienie między nieobecnym tagiem a pustym ciągiem

Często zadawane pytania

Czy lekcja „Inspekcja pól i tagów struktur” jest bezpłatna?

Tak — pełny tekst „Inspekcja pól i tagów struktur” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Inspekcja pól i tagów struktur”?

Iterowanie po polach i odczytywanie tagów struktur Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Inspekcja pól i tagów struktur”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy