Een structuur definiëren en gebruiken

Een struct groepeert benoemde velden in één type. Het is Go's manier van het bouwen van ‘objecten’ – letterlijker en directer dan klassen, met geen overerving en geen ingebouwde constructors.

Verklaring

type Person struct {
    Name string
    Age  int
}

type introduceert een nieuw benoemd type. Velden worden één per geschreven lijn, name type. Opeenvolgende velden van hetzelfde type kunnen de verklaring: X, Y int.

Creatie

// 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

Toegang tot het veld

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

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

Op een pointer werkt ptr.Name direct: Go voert de impliciete verwijzing. Geen -> zoals in C.

Zichtbaarheid: de hoofdletterregel

Velden met een hoofdletter initiaal worden geëxporteerd (zichtbaar vanuit andere pakketten); kleine letters = privé voor het huidige pakket.

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

Dezelfde regel is van toepassing op elke identificatie in Go: typen, functies, variabelen, velden.

Anonieme en geneste structuren

// 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
}

Vergelijkbaarheid

Twee structuren zijn vergelijkbaar met == als AL hun velden dat zijn vergelijkbaar (geen slice/maps/funcs erin):

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

Hierdoor kunt u ze ook gebruiken als kaartsleutels.

Probeer het

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

Samenvatten

• type Name struct { ... }: nieuw benoemd type met benoemde velden.
• Constructie: T{Field: value, ...} (aanbevolen) of positioneel.
• Nulwaarde: elk veld heeft de nulwaarde van het type.
• &T{...} en new(T) voor een aanwijzer; impliciete dereferentie (p.Field op *T).
• Hoofdletters = geëxporteerd; kleine letters = privé voor het pakket.
• Structuren zijn vergelijkbaar met == als alle velden dat zijn; bruikbaar als kaartsleutels.