Skip to content

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.

Fortschritt0/5 Lektionen
26

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 die ID identifizieren.

✅ Wichtige Erkenntnisse

Haken setzen, um deinen Lernfortschritt zu markieren:

    27

    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:

    1. Pointer-Receiver, wenn die Methode den Zustand des Aufrufers ändert — oder das Struct so groß ist, dass jede Kopie spürbar kostet.
    2. Value-Receiver, wenn die Methode nur liest und das Struct klein und billig kopierbar ist — ein paar skalare Felder, fertig.
    3. 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: Deposit mit 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:

      28

      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:

        29

        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 Cache statt NewCache: items ist nil, und der erste Schreibzugriff stürzt mit panic: assignment to entry in nil map ab. Exportierte Structs mit uninitialisierten Map-Feldern laden regelrecht dazu ein. Konvention im Team: Typen mit Initialisierungsbedarf bekommen unexportierte Felder und genau eine NewX-Funktion — dann führt der Compiler auf dem richtigen Weg.

        ✅ Wichtige Erkenntnisse

        Haken setzen, um deinen Lernfortschritt zu markieren:

          30

          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: omitempty auf ein time.Time-Feld gelegt und gewundert, warum das leere Datum trotzdem serialisiert wird: Struct-Werte gelten nie als "leer" — nur echte Zero Values wie 0, "", false und nil verschwinden. 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?

          1. Kannst du begründen, wann == für Structs kompiliert — und was Slices und Maps damit machen?
          2. Wählst du Receiver-Typen semantisch (mutiert die Methode?) statt nach Bauchgefühl?
          3. Erklärst du den Unterschied zwischen Embedding-Promotion und Vererbung mit dynamischem Dispatch?
          4. Schützt du Typen mit Initialisierungsbedarf durch NewX vor dem Zero-Value-Fehlgriff?
          5. Setzt du ein JSON-Datenmodell mit Tags, omitempty und Pointer-Feldern sauber auf?

          ✅ Wichtige Erkenntnisse

          Haken setzen, um deinen Lernfortschritt zu markieren:

            This site uses essential cookies for Stripe payments. No tracking cookies.