Care este diferența dintre tablouri și slice-uri?

Question

Accepted Answer

Un **tablou** are o dimensiune fixă care face parte din tipul său; un **slice** este o vizualizare flexibilă și dimensionată dinamic asupra unui tablou subiacent. În practică, aproape întotdeauna folosești **slice-uri** — tablourile sunt rare în Go-ul cotidian.

## Tablouri — dimensiune fixă

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

Dimensiunea tabloului este fixată la compile-time și face parte din tipul său (`[5]int` ≠ `[3]int`). Tablourile sunt, de asemenea, **tipuri valoare** — atribuirea sau transmiterea unui tablou copiază întregul tablou. Această rigiditate este motivul pentru care sunt rareori folosite direct.

## Slice-uri — dinamice și flexibile

```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)
```

Un slice nu are o dimensiune fixă — îl dezvolți cu `append`. Este secvența dinamică standard.

## Cum funcționează slice-urile în spatele scenei

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

## Slicing creează o vizualizare (tablou subiacent partajat — o capcană)

```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]!
```

Slicing-ul (`s[low:high]`) nu copiază — creează un nou header de slice care indică **acelaș** tablou subiacent. Modificarea unuia poate afecta pe celălalt — o sursă comună de erori subtile. Folosește `copy()` pentru o copie independentă.

## Surpriza realocării lui 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)
```

## De ce este important

Slice-urile sunt una dintre caracteristicile cel mai folosite și cel mai neînțelese din Go.

Înțelegerea că tablourile sunt tipuri valoare cu dimensiune fixă (rareori folosite direct) în timp ce **slice-urile** sunt vizualizări flexibile, asemănătoare referințelor, într-un tablou subiacent (instrumentul cotidian) este fundamentală.

Crucial, cunoașterea comportamentului **tabloului subiacent partajat** — că slicing creează o vizualizare, nu o copie, deci modificările pot afecta alte slice-uri, și că `append` poate sau nu realoca — previne o clasă de erori subtile de aliasing, greu de găsit, care chiar și dezvoltatorii experimentați sunt prinși.

Stăpânirea slice-urilor (len vs cap, append, copy, capcana partajării) este o cunoaștere esențială și cotidiană în Go și un subiect frecvent în interviuri, deoarece aproape toate lucrările cu colecții le folosesc.