Modul 6: Structs & Methoden
Structs & Methoden in Go: Definition, Literale und Vergleichbarkeit, Value- vs. Pointer-Receiver, Embedding statt Vererbung, Konstruktions-Patterns wie NewX und functional options sowie JSON-Tags für saubere Datenmodelle.
Structs: Definition, Literale & Vergleichbarkeit
Lektion 26 von 100
Vom Datenhaufen zum eigenen Typ
Wir bauen die Schnittstelle für eine Paketverfolgung: Jede Sendung hat eine ID, eine Zielstadt, ein Gewicht und ein Fragile-Flag. Ohne eigenen Typ schleppt man vier lose Variablen durch jede Funktion — und nichts hält zusammen, was zusammengehört. Genau dafür gibt es Structs: Sie bündeln verwandte Daten unter einem eigenen, benannten Typ.
In Go ist fast alles, was wir täglich anfassen — API-Payloads, Konfiguration, Datenbankzeilen — im Kern ein Struct. Wer Structs sauber modelliert, modelliert die Daten der ganzen Anwendung. Dieses Modul legt das Fundament: erst die Werte selbst, dann Methoden darauf, dann Komposition, Konstruktion und zuletzt der JSON-Draht nach draußen.
package main
import "fmt"
// Package bündelt alle Daten einer Sendung
type Package struct {
ID string
City string
Weight float64
Fragile bool
}
func main() {
// Keyed Literal: Feldnamen explizit, Reihenfolge egal — die Go-Idiom
p1 := Package{ID: "DE-104", City: "Berlin", Weight: 2.4, Fragile: true}
// Unkeyed Literal: positionsabhängig — bricht still, wenn jemand Felder umsortiert
p2 := Package{"DE-207", "Hamburg", 0.8, false}
fmt.Printf("%s geht nach %s (%.1f kg)\n", p1.ID, p1.City, p1.Weight)
fmt.Println(p2.Fragile)
}
// → DE-104 geht nach Berlin (2.4 kg)
// → false
Der Zero Value ist sofort benutzbar
var p Package ist kein Fehlerzustand: Jedes Feld startet mit seinem Zero Value — "" für Strings, 0 für Zahlen, false für Bools. Ein frisch deklariertes Struct ist ohne Konstruktor gültig. Nur Felder vom Typ Slice, Map oder Pointer brauchen vor der ersten Nutzung eine Initialisierung.
Structs vergleichen — Feld für Feld, mit Fallstricken
Zwei Struct-Werte dürfen mit == verglichen werden, und zwar Feld für Feld — nicht per Referenz. Die Regel dabei: Das funktioniert nur, solange jedes Feld comparable ist. Strings, Zahlen, Bools und Pointer sind es; Slices, Maps und Funktionen sind es nicht.
func main() {
var p Package
fmt.Printf("%q %.1f %v\n", p.ID, p.Weight, p.Fragile)
// → "" 0.0 false
a := Package{ID: "DE-104", City: "Berlin"}
b := Package{ID: "DE-104", City: "Berlin"}
fmt.Println(a == b)
// → true (Feld-für-Feld-Vergleich, nicht Speicheradresse)
type Batch struct {
Tags []string // Slices sind nicht comparable
}
x := Batch{Tags: []string{"express"}}
y := Batch{Tags: []string{"express"}}
fmt.Println(x.Tags, y.Tags)
// → [express] [express]
// fmt.Println(x == y)
// → compile error: invalid operation: x == y (struct containing []string cannot be compared)
}
Inhaltlich gleiche Batch-Werte lassen sich mit == also gar nicht prüfen. Die Ausweichroute für Tests ist reflect.DeepEqual(x, y) — sie arbeitet über Reflection, ist langsam und im Produktionscode meist die falsche Wahl. Besser: gezielt die identitätsstiftenden Felder vergleichen, etwa x.ID == y.ID.
⚠ Häufiger Fehler:
==-Vergleiche funktionieren prächtig — bis jemand dem Struct ein Slice- oder Map-Feld hinzufügt. Ab dann kompiliert jede dieser Vergleichsstellen nicht mehr, oft an ganz anderen Stellen im Paket. Structs, die als Werte verglichen werden sollen, bewusst comparable halten — oder von Anfang an über ein eindeutiges Feld wie dieIDidentifizieren.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Methoden: Value- vs. Pointer-Receiver richtig wählen
Lektion 27 von 100
Die Buchung, die niemand gespeichert hat
Ein Klassiker aus dem Code-Review: Ein Team baut eine Kontoverwaltung, die Deposit-Methode kompiliert, alle Tests sind grün — nur das Guthaben bleibt ausgerechnet gleich. Der Bug ist unsichtbar, weil er kein Fehler im klassischen Sinn ist, sondern eine Semantik-Frage: Value- oder Pointer-Receiver?
Methoden in Go sind Funktionen mit einem Receiver als erstem Parameter: func (a Account) Deposit(amount int) ist im Kern Deposit(a Account, amount int). Und Parameter in Go werden kopiert. Diese eine Zeile Fachwissen erklärt fast alles, was in dieser Lektion folgt.
package main
import "fmt"
type Account struct {
Owner string
Balance int // in Cent
}
// Value-Receiver: Deposit arbeitet auf einer Kopie von Account
func (a Account) Deposit(amount int) {
a.Balance += amount // die Erhöhung verpufft in der Kopie
}
func main() {
acc := Account{Owner: "Mara", Balance: 100}
acc.Deposit(50)
fmt.Println(acc.Balance)
// → 100 — die 50 sind still verschenkt, der Compiler warnt nicht
}
Der Receiver ist ein Parameter
func (a Account) Deposit(...) übergibt das Struct als Wert — die Methode sieht eine Kopie. func (a *Account) Deposit(...) übergibt einen Pointer — die Methode arbeitet auf dem Original. Diese Entscheidung fällt pro Typ bewusst, nicht pro Methode nach Laune.
Die Wahl richtig treffen: Mutation, Größe, Konsistenz
Die Regeln lassen sich semantisch denken statt auswendig lernen:
- Pointer-Receiver, wenn die Methode den Zustand des Aufrufers ändert — oder das Struct so groß ist, dass jede Kopie spürbar kostet.
- Value-Receiver, wenn die Methode nur liest und das Struct klein und billig kopierbar ist — ein paar skalare Felder, fertig.
- Konsistenz: Sobald eine Methode des Typs einen Pointer-Receiver braucht, bekommen alle Methoden des Typs Pointer-Receiver. Gemischte Receiver verwirren jede Leserschaft.
// Pointer-Receiver: Deposit ändert das Original
func (a *Account) Deposit(amount int) {
a.Balance += amount
}
// Value-Receiver: liest nur, die Kopie ist hier billig
func (a Account) Describe() string {
return fmt.Sprintf("%s: %d Cent", a.Owner, a.Balance)
}
func main() {
acc := Account{Owner: "Mara", Balance: 100}
acc.Deposit(50) // Go übergibt automatisch &acc, weil acc addressable ist
fmt.Println(acc.Describe())
// → Mara: 150 Cent
}
Ein Blick nach vorn: Methoden mit Pointer-Receiver liegen im Method-Set von *Account, nicht von Account. Spätestens wenn Interfaces ins Spiel kommen, entscheidet das, ob ein Wert den Vertrag erfüllt — deshalb von Anfang an konsequent wählen.
⚠ Häufiger Fehler:
Depositmit Value-Receiver kompiliert makellos, erhöht aber nur eine Kopie — die Einzahlung verschwindet ohne jede Warnung. Sobald eine Methode eines Typs mutiert (oder das Struct groß ist): Pointer-Receiver für alle Methoden des Typs, nicht nur für die schreibenden.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Embedding & Komposition statt Vererbung
Lektion 28 von 100
Drei Services, ein Logger
Das Team wächst: UserService, OrderService und ShipmentService — alle brauchen Logging. Der OO-Reflex sagt: gemeinsame Basisklasse, alle erben Log. Go kennt keine Vererbung, und das ist eine bewusste Design-Entscheidung. Die Antwort heißt Komposition: Ein Typ bettet einen anderen ein (Embedding) und bekommt dessen Felder und Methoden "nach oben gereicht" (Promotion).
Embedding ist dabei nichts Exotisches: Ein Feld ohne Namen, dessen Typname zum Feldnamen wird. Alles, was wir in den letzten beiden Lektionen über Structs und Methoden gelernt haben, gilt weiterhin — nur der Zugriff wird kürzer.
package main
import "fmt"
type Logger struct {
Prefix string
}
func (l Logger) Log(msg string) {
fmt.Printf("[%s] %s\n", l.Prefix, msg)
}
// UserService bettet Logger ein — das Feld heißt schlicht Logger
type UserService struct {
Logger
Users map[string]int
}
func main() {
svc := UserService{Logger: Logger{Prefix: "user-svc"}}
svc.Log("gestartet")
// → [user-svc] gestartet
fmt.Println(svc.Prefix)
// → user-svc (promoted: svc.Prefix ist svc.Logger.Prefix)
}
Promotion ist Zucker, keine Vererbung
svc.Log("x") ist eine Abkürzung für svc.Logger.Log("x") — der Compiler reichert das äußere Struct nur um die Felder und Methoden des eingebetteten Typs an. Es gibt keinen dynamischen Dispatch und keine Rückkopplung: Das eingebettete Logger weiß nichts von seinem Wirt.
Verdecken statt Überschreiben
Definiert der äußere Typ eine Methode mit gleichem Namen, verdeckt sie die promoted Methode — analog zum Variablen-Shadowing aus Modul 2. Für den eingebetteten Typ bleibt alles beim Alten; wer die ursprüngliche Variante will, ruft sie explizit auf.
type OrderService struct {
Logger
}
// Log verdeckt die promoted Methode von Logger
func (o OrderService) Log(msg string) {
o.Logger.Log("BESTELLUNG: " + msg)
}
func main() {
orders := OrderService{Logger: Logger{Prefix: "order-svc"}}
orders.Log("Neue Bestellung 104")
// → [order-svc] BESTELLUNG: Neue Bestellung 104
orders.Logger.Log("Direktaufruf bleibt möglich")
// → [order-svc] Direktaufruf bleibt möglich
}
Wem das zu statisch klingt, hat richtig gehört — und genau das ist der Punkt: Go bevorzugt kleine, explizite Typen mit klarer Zuständigkeit ("hat einen Logger") statt tiefer "ist ein"-Hierarchien. Wer Verhalten austauschbar braucht, erreicht das über Interfaces; Embedding ist reine Wiederverwendung von Struktur und Methoden.
⚠ Häufiger Fehler: Embedding ist keine Vererbung: Ruft eine Methode des eingebetteten Typs eine gleichnamige Methode auf, läuft immer die Version des eingebetteten Typs — der "Override" des äußeren Typs wird nie erreicht. Wer aus Java oder C# eine dynamische Aufrufkette erwartet, sucht diesen Bug endlos lange.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Konstruktions-Patterns: NewX & functional options
Lektion 29 von 100
Der Nil-Map-Panic um drei Uhr nachts
Unser Cache läuft stabil — bis eine neue Kollegin ihn deklariert, ohne unsere Initialisierungsregeln zu kennen: var c Cache, dann der erste Schreibzugriff, und die Produktion steht still mit panic: assignment to entry in nil map. Go hat keine Konstruktoren im Sprachkern — aber es hat eine Konvention, die genau diesen Unfall verhindert: die NewX-Funktion.
Sie ist eine ganz normale Funktion mit zwei Aufgaben: sinnvolle Defaults setzen und ungültige Zustände von Anfang an ablehnen. Dass sie dabei wie jeder Funktion Rückgabe prüfen und Fehler zurückgeben kann, macht sie stärker als Konstruktoren vieler anderer Sprachen.
package main
import (
"errors"
"fmt"
)
type Cache struct {
maxItems int
items map[string]string
}
// NewCache ist der idiomatische Konstruktor: Defaults setzen, gültige Zustände erzwingen
func NewCache(maxItems int) (*Cache, error) {
if maxItems < 1 {
return nil, errors.New("maxItems muss größer als 0 sein")
}
return &Cache{
maxItems: maxItems,
items: make(map[string]string),
}, nil
}
func main() {
if _, err := NewCache(-5); err != nil {
fmt.Println("Fehler:", err)
// → Fehler: maxItems muss größer als 0 sein
}
c, _ := NewCache(64)
fmt.Println("Cache bereit für", c.maxItems, "Einträge")
// → Cache bereit für 64 Einträge
}
NewX statt Konstruktoren
Die Standardbibliothek zeigt das Muster überall: errors.New, bytes.NewBuffer, time.NewTicker. Eine NewX-Funktion liefert einen Pointer auf einen fertig initialisierten Wert — und kann als normale Funktion Parameter validieren und Fehler zurückgeben.
Functional options: optionale Parameter ohne Signatur-Chaos
Unser Service bekommt immer mehr Knöpfe: Port, Timeout, Retry-Limit. Ein parameterloses NewServer() wäre zu starr, ein NewServer(host, port, timeout, retries) ist positionsabhängig unlesbar — und bei jeder Erweiterung brechen alle bestehenden Aufrufe. Die idiomatische Antwort: functional options. Jede Option ist eine Funktion, die den entstehenden Wert verändert; die Defaults gelten, wenn niemand eine Option schickt.
package main
import (
"fmt"
"time"
)
type Server struct {
host string
port int
timeout time.Duration
}
// Option ist eine Funktion, die den Server beim Bau verändert
type Option func(*Server)
func WithPort(port int) Option {
return func(s *Server) { s.port = port }
}
func WithTimeout(d time.Duration) Option {
return func(s *Server) { s.timeout = d }
}
// NewServer setzt Defaults und lässt Aufrufer gezielt abweichen
func NewServer(opts ...Option) *Server {
s := &Server{host: "localhost", port: 8080, timeout: 5 * time.Second}
for _, opt := range opts {
opt(s)
}
return s
}
func main() {
srv := NewServer(WithPort(9090), WithTimeout(time.Second))
fmt.Println(srv.host, srv.port, srv.timeout)
// → localhost 9090 1s
}
Ehrlich bleiben: Bei zwei, drei Parametern sind gewöhnliche Argumente oder ein Config-Struct lesbarer und ehrlicher. Functional options lohnen sich erst bei vielen, frei kombinierbaren Einstellungen — gRPC-Clients sind das bekannteste Beispiel aus der Praxis.
⚠ Häufiger Fehler:
var c CachestattNewCache:itemsist nil, und der erste Schreibzugriff stürzt mitpanic: assignment to entry in nil mapab. Exportierte Structs mit uninitialisierten Map-Feldern laden regelrecht dazu ein. Konvention im Team: Typen mit Initialisierungsbedarf bekommen unexportierte Felder und genau eineNewX-Funktion — dann führt der Compiler auf dem richtigen Weg.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
JSON-Tagging & struct-basierte Datenmodelle
Lektion 30 von 100
Der Struct als API-Vertrag
Unser Paketverfolgungs-Service geht in Produktion, und das Frontend-Team schaut zum ersten Mal auf die Schnittstelle. Ohne weiteres Zutun serialisiert Go die Feldnamen unverändert: Aus ID wird ID, aus WeightKg wird WeightKg. Go-Exportnamen sind PascalCase, APIs und Configs erwarten aber meist snake_case. Das JSON-Tag ist der eine Ort, an dem der Name nach außen verbindlich definiert wird — der Struct wird zum Vertrag.
package main
import (
"encoding/json"
"fmt"
)
type Shipment struct {
ID string `json:"id"`
City string `json:"city"`
WeightKg float64 `json:"weight_kg"`
Note string `json:"note,omitempty"` // leer? dann gar nicht im JSON
Internal string `json:"-"` // intern, nie serialisieren
}
func main() {
s := Shipment{ID: "DE-104", City: "Berlin", WeightKg: 2.4}
data, _ := json.Marshal(s)
fmt.Println(string(data))
// → {"id":"DE-104","city":"Berlin","weight_kg":2.4}
}
Tags definieren den Draht nach draußen
omitempty lässt Zero Values ganz verschwinden — der Trick, mit dem Note oben aus der Ausgabe bleibt. json:"-" nimmt Felder komplett aus der Serialisierung, etwa interne IDs oder Cache-Felder. Was kein Tag trägt, geht mit dem Go-Feldnamen auf die Reise.
Optionalität sauber modellieren: Pointer-Felder
Beim PATCH-Endpunkt gilt: Wurde ein Feld gar nicht geschickt, dürfen wir es nicht anfassen. Ein leerer String ist nämlich eine legitime Änderung — omitempty hilft hier nicht, denn das ist reine Marshalling-Logik. Die saubere Antwort sind Pointer-Felder: nil heißt "nicht gesendet", ein gesetzter Pointer heißt "ändere auf diesen Wert".
type PatchRequest struct {
City *string `json:"city"`
Fragile *bool `json:"fragile"`
}
func main() {
raw := []byte(`{"city":"Hamburg"}`)
var patch PatchRequest
if err := json.Unmarshal(raw, &patch); err != nil {
fmt.Println("Fehler:", err)
return
}
if patch.City != nil {
fmt.Println("neue Stadt:", *patch.City)
// → neue Stadt: Hamburg
}
if patch.Fragile == nil {
fmt.Println("Fragile bleibt unverändert")
// → Fragile bleibt unverändert
}
}
Zwei Alltags-Fakten zum Abschluss: json.Unmarshal matcht Schlüssel großzügig — "CITY" füllt ebenfalls das city-Feld. Und für lesbare Debug-Ausgaben gibt es json.MarshalIndent(v, "", " "), während im Betrieb das kompakte Marshal bleibt.
⚠ Häufiger Fehler:
omitemptyauf eintime.Time-Feld gelegt und gewundert, warum das leere Datum trotzdem serialisiert wird: Struct-Werte gelten nie als "leer" — nur echte Zero Values wie0,"",falseundnilverschwinden. Für "Feld manchmal ganz weglassen" braucht es einen Pointer wie*time.Time.
Modul-Zusammenfassung & Wochen-Check
Damit schließen wir Modul 6 ab — vom nackten Datenbündel bis zum API-fähigen Datenmodell.
Wochen-Check: Hast du folgende Punkte gemeistert?
- Kannst du begründen, wann
==für Structs kompiliert — und was Slices und Maps damit machen? - Wählst du Receiver-Typen semantisch (mutiert die Methode?) statt nach Bauchgefühl?
- Erklärst du den Unterschied zwischen Embedding-Promotion und Vererbung mit dynamischem Dispatch?
- Schützt du Typen mit Initialisierungsbedarf durch
NewXvor dem Zero-Value-Fehlgriff? - Setzt du ein JSON-Datenmodell mit Tags,
omitemptyund Pointer-Feldern sauber auf?
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren: