Qual è la differenza tra array e slice?

Question

Accepted Answer

Un **array** ha una dimensione fissa che fa parte del suo tipo; uno **slice** è una vista flessibile e dinamica di un array sottostante. In pratica usi quasi sempre **slice** — gli array sono rari nel Go quotidiano.

## Array — dimensione fissa

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

La dimensione dell'array è fissa al momento della compilazione e fa parte del suo tipo (`[5]int` ≠ `[3]int`). Gli array sono anche **value type** — assegnarli o passarli copia l'intero array. Questa rigidità è il motivo per cui vengono usati raramente.

## Slice — dinamico e flessibile

```go
s := []int{1, 2, 3}          // a slice (no size in the brackets)
s = append(s, 4)             // grow it — append returns a new slice
fmt.Println(len(s), cap(s))  // length and capacity

nums := make([]int, 0, 10)   // make a slice: length 0, capacity 10 (pre-allocated)
```

Uno slice non ha una dimensione fissa — lo ingrandisci con `append`. È la sequenza dinamica da usare.

## Come funzionano gli slice internamente

```text
A slice is a small struct: { pointer to underlying array, length, capacity }
  - len = number of elements currently in the slice
  - cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
```

## Lo slicing crea una vista (array backing condiviso — una trappola)

```go
original := []int{1, 2, 3, 4, 5}
sub := original[1:3]         // [2, 3] — a VIEW into the same backing array
sub[0] = 99                  // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
```

Lo slicing (`s[low:high]`) non copia — crea un nuovo slice header che punta allo **stesso** array sottostante. Modificare uno può influenzare l'altro — una fonte comune di bug sottili. Usa `copy()` per una copia indipendente.

## La sorpresa della riallocazione di append

```go
a := []int{1, 2, 3}
b := append(a, 4)            // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
```

## Perché è importante

Gli slice sono una delle caratteristiche più usate e più fraintese di Go.

Capire che gli array sono value type a dimensione fissa (raramente usati direttamente) mentre **slice** sono viste flessibili e simili a riferimenti in un array backing (lo strumento quotidiano) è fondamentale.

Crucialmente, conoscere il **comportamento dell'array backing condiviso** — che lo slicing crea una vista, non una copia, quindi le modifiche possono influenzare altri slice, e che `append` potrebbe o meno riallocare — previene una classe di bug di aliasing sottili e difficili da debuggare che catturano anche sviluppatori esperti.

Padroneggiare gli slice (len vs cap, append, copy, le trappole di condivisione) è conoscenza Go essenziale quotidiana e un argomento frequente nei colloqui, poiché quasi tutto il lavoro con collezioni li utilizza.