Strukturen definieren und verwenden

Ein struct gruppiert benannte Felder in einem einzigen Typ. Es ist Gos Weg des Aufbaus von „Objekten“ – wörtlicher und unmittelbarer als Klassen, mit keine Vererbung und keine eingebauten Konstruktoren.

Erklärung

type Person struct {
    Name string
    Age  int
}

type führt einen neuen benannten Typ ein. Felder werden einzeln geschrieben Zeile, name type. Aufeinanderfolgende Felder desselben Typs können das gemeinsam nutzen Deklaration: X, Y int.

Schöpfung

// with named fields (recommended: robust to reordering)
p := Person{Name: "Ada", Age: 36}

// positional (fragile: depends on declaration order)
q := Person{"Ada", 36}

// zero value: every field at its zero value
var r Person          // r = {Name: "", Age: 0}

// pointer: allocate with & or new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person to a zero-value struct

Feldzugriff

p := Person{Name: "Ada", Age: 36}
fmt.Println(p.Name, p.Age)

p.Age = 37            // mutation (if p is a variable)

Auf einen Zeiger wirkt ptr.Name direkt: Go führt das aus implizite Dereferenzierung. Kein -> wie in C.

Sichtbarkeit: die Großbuchstabenregel

Felder mit einem Großbuchstaben-Anfangszeichen werden exportiert (von anderen sichtbar). Pakete); Kleinbuchstaben = privat für das aktuelle Paket.

type User struct {
    Name   string  // exported
    salt   []byte  // private to the package
}

Die gleiche Regel gilt für jeden Bezeichner in Go: Typen, Funktionen, Variablen, Felder.

Anonyme und verschachtelte Strukturen

// anonymous (handy for ad-hoc data)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

// nested
type Address struct {
    Street string
    City   string
}
type Customer struct {
    Name    string
    Address Address
}

Vergleichbarkeit

Zwei Strukturen sind mit == vergleichbar, wenn ALLE ihre Felder es sind vergleichbar (keine Slices/Maps/Funktionen darin):

a := Person{Name: "Ada", Age: 36}
b := Person{Name: "Ada", Age: 36}
fmt.Println(a == b)   // true

Dadurch können Sie sie auch als Kartenschlüssel verwenden.

Probieren Sie es aus

// in package other
type X struct {
    name string
}

Zusammenfassung

• type Name struct { ... }: neuer benannter Typ mit benannten Feldern.
• Konstruktion: T{Field: value, ...} (empfohlen) oder positionell.
• Nullwert: Jedes Feld hat den Nullwert seines Typs.
• &T{...} und new(T) für einen Zeiger; implizite Dereferenzierung (p.Field auf *T).
• Großbuchstaben = exportiert; Kleinbuchstaben = privat für das Paket.
• Strukturen sind mit == vergleichbar, wenn alle Felder es sind; als Kartenschlüssel verwendbar.