Was sind Structs in Go?

Question

Accepted Answer

Ein **struct** ist ein zusammengesetzter Typ, der verwandte Felder zusammenfasst — Gos Art, benutzerdefinierte Datentypen zu definieren und Entitäten zu modellieren. Da Go keine Klassen hat, sind Structs (plus Methoden) der Weg, um objektorientierten Programmier-Stil zu implementieren.

## Definition und Verwendung eines Structs

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## Feldvisibilität durch Großschreibung

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go verwendet Großschreibung, nicht Schlüsselwörter, für Visibilität — eine charakteristische Konvention.

## Methoden auf Structs (Gos OOP)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

Methoden verknüpfen Verhalten mit Structs über einen *Receiver*. Pointer Receiver (`*Person`) ermöglichen Methoden, den Struct zu ändern; Value Receiver erhalten eine Kopie.

## Structs sind Value Types

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

Das Zuweisen oder Übergeben eines Structs **kopiert** ihn (Value Semantics) — zum Teilen oder Ändern verwenden Sie einen Pointer.

## Struct Tags (Metadaten)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

Tags verknüpfen Metadaten (verwendet von JSON, DB, Validierungsbibliotheken), die über Reflection gelesen werden.

## Warum es wichtig ist

Structs sind der zentrale Weg, Daten zu modellieren und benutzerdefinierte Typen in Go zu erstellen — und kombiniert mit Methoden, so funktioniert objektorientierten Programmier-Stil in Go (es hat keine Klassen).

Das Verständnis von Struct-Definition, der **Großschreibungs-basierten Sichtbarkeits**konvention (einzigartig für Go), **Value Semantics** (Zuweisung kopiert — verwenden Sie also Pointer zum Teilen/Ändern, eine häufige Falle), Methoden mit Value vs Pointer Receiver und Struct Tags (für JSON/DB-Mapping) ist fundamental für fast allen Go-Code.

Structs erscheinen überall — Domänenmodelle, Konfiguration, API Payloads, Datenstrukturen — was sie zu wesentlichem, alltäglichem Wissen für effektives Arbeiten in Go macht.