X'inhu d-differenza bejn arrays u slices?

Question

Accepted Answer

**Array** għandu daqs fiss li huwa parti mit-tip tiegħu; **slice** hija vista flessibbli u dinamika f'array sottostanti. Fil-prattika titħaddem bejn wieħed u ieħor dejjem **slices** — arrays huma rari fil-Go ta' kuljum.

## Arrays — daqs fiss

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

Id-daqs tal-array huwa fiss fil-ħin tal-kompilazzjoni u huwa parti mit-tip tiegħu (`[5]int` ≠ `[3]int`). Arrays huma wkoll **value types** — l-assenjazzjoni jew il-passaġġ ta' wieħed jinqosu l-array kollu. Din ir-rigiditá hi għaliex rari jintuża direttament.

## Slices — dinamiku u flessibbli

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

Slice m'għandux daqs fiss — int it-tkabbar b'`append`. Hija s-sekwenza dinamika li tintuża.

## Kif jaħdmu slices taħt l-iskapell

```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 jinħoloq view (shared backing array — 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]!
```

Slicing (`s[low:high]`) m'għandux jikkonka — jinħoloq header slice ġdid li jipponta lejn l-**istess** array sottostanti. Il-modifika ta' waħda tista' taffettwa lil oħra — sors komuni ta' bugs subtili. Uża `copy()` għal kopja indipendenti.

## Is-sorpresa ta' re-allocation ta' 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)
```

## Għaliex hija importanti

Slices huma wieħed mill-aktar features użati u aktar misinterpretati ta' Go.

L-intellezzjoni li arrays huma value types ta' daqs fiss (rari jintuża direttament) filwaqt li **slices** huma views flessibbli u simili għar-referenzi f'array sottostanti (l-għodda ta' kuljum) hija fundamentali.

Krucjali, li tkun taf dwar il-**shared backing array behavior** — li l-slicing jinħoloq view, mhux kopja, għalhekk il-modifikazzjonijiet jistgħu jaffettwaw slices oħra, u li `append` jista' jew ma jistax jireallocate — tipprevjeni klassi ta' bugs ta' aliasing subtili u diffiċli biex debug-jawhom li jaqbu anke developers esperjenzati.

L-masterizzazzjoni ta' slices (len vs cap, append, copy, il-gotchas ta' sharing) hija għarifa essenzjali ta' Go ta' kuljum u suġġett ta' intervista frekwenti, billi bejn wieħed u ieħor kull xogħol tal-collections jagħti ħlas.