Definire e usare uno struct

Una struct raggruppa campi nominati in un unico tipo. È il modo Go di costruire "oggetti" — più letterali e immediati delle classi, senza ereditarietà né costruttori built-in.

Dichiarazione

type Person struct {
    Name string
    Age  int
}

type introduce un nuovo tipo nominato. I campi sono scritti uno per riga, nome tipo. Campi consecutivi dello stesso tipo possono condividere la dichiarazione: X, Y int.

Creazione

// con campi nominati (raccomandato: robusto al riordino)
p := Person{Name: "Ada", Age: 36}

// posizionale (fragile: dipende dall'ordine di dichiarazione)
q := Person{"Ada", 36}

// zero value: tutti i campi al loro zero value
var r Person          // r = {Name: "", Age: 0}

// puntatore: alloca con & o new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person verso struct zero-value

Accesso ai campi

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

p.Age = 37            // mutazione (se p è una variabile)

Su un puntatore, ptr.Name funziona direttamente: Go fa il dereference implicito. Niente -> come in C.

Visibilità: il caso della maiuscola

I campi con iniziale maiuscola sono esportati (visibili da altri package); minuscola = privati al package corrente.

type User struct {
    Name   string  // esportato
    salt   []byte  // privato al package
}

Questa stessa regola vale per tutti gli identificatori in Go: tipi, funzioni, variabili, campi.

Struct anonime e nidificate

// anonima (utile per dati ad-hoc)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

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

Comparabilità

Due struct sono comparabili con == se TUTTI i loro campi sono comparabili (no slice/map/func al loro interno):

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

Questo permette anche di usarle come chiavi di map.

Prova tu

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

Recap

• type Nome struct { ... }: nuovo tipo nominato con campi nominati.
• Costruzione: T{Campo: valore, ...} (raccomandata) o posizionale.
• Zero value: tutti i campi allo zero del loro tipo.
• &T{...} e new(T) per puntatore; dereference implicito (p.Campo su *T).
• Maiuscola = esportato; minuscola = privato al package.
• Struct comparabili con == se tutti i campi lo sono; usabili come chiavi map.