Definirea și utilizarea unei structuri

A struct grupează câmpurile denumite într-un singur tip. Este calea lui Go de a construi „obiecte” — mai literal și mai imediat decât clasele, cu fără moștenire și fără constructori încorporați.

Declaraţie

type Person struct {
    Name string
    Age  int
}

type introduce un nou tip denumit. Câmpurile sunt scrise câte unul linie, name type. Câmpurile consecutive de același tip pot partaja declarație: X, Y int.

Creare

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

Acces pe teren

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

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

Pe un pointer, ptr.Name funcționează direct: Go efectuează dereferire implicită. Nu -> ca în C.

Vizibilitate: regula majuscule

Câmpurile cu inițiala majusculă sunt exportate (vizibile din alt pachete); minuscule = privat pentru pachetul curent.

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

Aceeași regulă se aplică fiecărui identificator din Go: tipuri, funcții, variabile, câmpuri.

Structuri anonime și imbricate

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

Comparabilitatea

Două structuri sunt comparabile cu == dacă TOATE câmpurile lor sunt comparabil (fără felii/hărți/funcții în interior):

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

Acest lucru vă permite, de asemenea, să le utilizați ca taste pentru hărți.

Încearcă

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

Recapitulare

• type Name struct { ... }: nou tip denumit cu câmpuri denumite.
• Construcție: T{Field: value, ...} (recomandat) sau pozițional.
• Valoare zero: fiecare câmp la tipul lui zero.
• &T{...} și new(T) pentru un pointer; dereferire implicită (p.Field pe *T).
• Majuscule = exportate; minuscule = privat la pachet.
• Structurile sunt comparabile cu == dacă toate câmpurile sunt; utilizabil ca taste pentru hartă.