Definiowanie i używanie struktur

struct grupuje nazwane pola w jeden typ. To sposób Go budowania „obiektów” — bardziej dosłownego i bezpośredniego niż klasy, za pomocą bez dziedziczenia i bez wbudowanych konstruktorów.

Deklaracja

type Person struct {
    Name string
    Age  int
}

type wprowadza nowy nazwany typ. Pola są zapisywane po jednym linia, name type. Kolejne pola tego samego typu mogą współdzielić deklaracja: X, Y int.

Tworzenie

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

Dostęp do pola

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

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

Na wskaźniku ptr.Name działa bezpośrednio: Go wykonuje ukryte odniesienie. Brak -> jak w C.

Widoczność: zasada wielkich liter

Pola z inicjałem wielkimi literami są eksportowane (widoczne z innych pakiety); małe litery = prywatny do bieżącego pakietu.

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

Ta sama zasada dotyczy każdego identyfikatora w Go: typy, funkcje, zmienne, pola.

Struktury anonimowe i zagnieżdżone

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

Porównywalność

Dwie struktury są porównywalne z ==, jeśli WSZYSTKIE ich pola są takie porównywalne (bez plasterków/map/funkcji w środku):

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

Dzięki temu możesz ich także używać jako kluczy mapy.

Spróbuj

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

Podsumowanie

• type Name struct { ... }: nowy nazwany typ z nazwanymi polami.
• Konstrukcja: T{Field: value, ...} (zalecana) lub pozycyjna.
• Wartość zerowa: każde pole ma zero swojego typu.
• &T{...} i new(T) dla wskaźnika; ukryte dereferencje (p.Field na *T).
• Wielkie litery = eksportowane; małe litery = prywatny do pakietu.
• Struktury są porównywalne z ==, jeśli wszystkie pola są takie; przydatne jako klucze do map.