Go Academy · Lektion

reflect.Type und reflect.Value

TypeOf, ValueOf, Kind und Elem

reflect.Type und reflect.Value ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Übersicht über das reflect-Paket

Das Paket reflect ermöglicht Go-Programmen, Typen und Werte zur Laufzeit zu untersuchen. Es bildet die Grundlage für Encoding-Bibliotheken, ORMs und Dependency-Injection-Frameworks.

reflect.TypeOf

reflect.TypeOf(x) gibt den reflect.Type des Werts von x zurück:

t := reflect.TypeOf(42)
fmt.Println(t.Name())    // "int"
fmt.Println(t.Kind())    // "int"
fmt.Println(t.String())  // "int"

reflect.ValueOf

reflect.ValueOf(x) gibt einen reflect.Value zurück, der x enthält. Sie können den Wert mit den für den jeweiligen Kind passenden Methoden lesen:

v := reflect.ValueOf(42)
fmt.Println(v.Kind())    // "int"
fmt.Println(v.Int())     // 42

Type.Kind vs Type.Name

Kind bezeichnet die zugrunde liegende Go-Kategorie (int, struct, ptr, slice, ...). Name bezeichnet den deklarierten Typnamen ("MyStruct"). Interfaces haben Kind == Interface, aber keinen Name.

Struct-Felder

Untersuchen Sie Struct-Felder mit Type.NumField() und Type.Field(i), das ein reflect.StructField zurückgibt:

t := reflect.TypeOf(User{})
for i := 0; i < t.NumField(); i++ {
    f := t.Field(i)
    fmt.Printf("Field: %s Type: %s Tag: %s\n", f.Name, f.Type, f.Tag.Get("json"))
}

Werte von Struct-Feldern lesen

Verwenden Sie Value.FieldByName oder Value.Field(i), um Feldwerte zur Laufzeit zu lesen:

v := reflect.ValueOf(user)
nameField := v.FieldByName("Name")
fmt.Println(nameField.String()) // "Alice"

Werte von Struct-Feldern setzen

Zum Setzen eines Feldes muss der Wert adressierbar sein (als Pointer übergeben werden):

v := reflect.ValueOf(&user).Elem()
v.FieldByName("Name").SetString("Bob")

Pointer-Dereferenzierung

Wenn ein Wert ein Pointer ist, rufen Sie v.Elem() auf, um den referenzierten Wert zu erhalten. Prüfen Sie zuerst v.Kind() == reflect.Ptr.

if v.Kind() == reflect.Ptr {
    v = v.Elem()
}

reflect.New

Einen neuen Nullwert eines Typs erstellen und einen Pointer darauf erhalten:

t := reflect.TypeOf(User{})
ptr := reflect.New(t) // *User
user := ptr.Interface().(*User)

Methoden aufrufen

Eine Methode anhand ihres Namens auf einem reflektierten Wert aufrufen:

v := reflect.ValueOf(user)
m := v.MethodByName("Greet")
results := m.Call(nil)
fmt.Println(results[0].String())

Performance

Reflection ist 5- bis 10-mal langsamer als direkter Code. Cachen Sie reflect.Type- und reflect.Value-Abfragen außerhalb zeitkritischer Schleifen. Verwenden Sie Codegenerierung, wenn Performance entscheidend ist.

Kurzer Check

Was ist der Unterschied zwischen reflect.Type.Kind() und reflect.Type.Name()?

Zusammenfassung: reflect.Type und reflect.Value

Wichtige Punkte:

reflect.TypeOf/ValueOf zur Untersuchung von Typen zur Laufzeit
Kind: zugrunde liegende Kategorie; Name: deklarierter Name
Value.FieldByName + SetXxx zur Bearbeitung von Struct-Feldern
Pointer übergeben und Elem() aufrufen, damit Werte gesetzt werden können

Häufig gestellte Fragen

Ist die Lektion „reflect.Type und reflect.Value“ kostenlos?

Ja — der vollständige Text von „reflect.Type und reflect.Value“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „reflect.Type und reflect.Value“?

TypeOf, ValueOf, Kind und Elem Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „reflect.Type und reflect.Value“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy