Cosa sono gli struct in Go?

Question

Accepted Answer

Uno **struct** è un tipo composito che raggruppa campi correlati insieme — il modo di Go per definire tipi di dati personalizzati e modellare entità. Poiché Go non ha classi, gli struct (più i metodi) sono il modo in cui si fa programmazione nello stile orientato agli oggetti.

## Definire e usare uno struct

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## Visibilità dei campi tramite capitalizzazione

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go usa la capitalizzazione, non parole chiave, per la visibilità — una convenzione distintiva.

## Metodi su struct (OOP di Go)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

I metodi allegano comportamento agli struct tramite un *receiver*. I receiver puntatore (`*Person`) permettono ai metodi di modificare lo struct; i receiver valore ottengono una copia.

## Gli struct sono tipi valore

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

L'assegnazione o il passaggio di uno struct **lo copia** (semantica valore) — per condividere o modificare, usa un puntatore.

## Struct tag (metadati)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

I tag allegano metadati (usati da JSON, DB, librerie di validazione) letti tramite reflection.

## Perché è importante

Gli struct sono il modo fondamentale per modellare dati e costruire tipi personalizzati in Go — e combinati con i metodi, sono il modo in cui Go fa programmazione nello stile orientato agli oggetti (non ha classi).

Comprendere la definizione dello struct, la convenzione di visibilità **basata sulla capitalizzazione** (unica di Go), la **semantica valore** (l'assegnazione copia — quindi usa puntatori per condividere/modificare, un errore comune), i metodi con receiver valore vs puntatore, e i struct tag (per il mapping JSON/DB) è fondamentale per quasi tutto il codice Go.

Gli struct compaiono ovunque — modelli di dominio, configurazione, payload API, strutture dati — rendendoli conoscenze essenziali e quotidiane per lavorare efficacemente in Go.