Cili është ndryshimi midis vargjeve dhe fetave?

Question

Accepted Answer

Një **varg** ka një madhësi fikse që është pjesë e llojit të tij; një **fetë** është një pamje fleksibile dhe dinamike e një vargu themelues. Në praktikë pothuajse gjithmonë përdorni **fetat** — varjet janë të rralla në Go-n e përditshëm.

## Varjet — madhësi fikse

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

Madhësia e vargjeve fiksohet në kohën e përpilimit dhe është pjesë e llojit të tij (`[5]int` ≠ `[3]int`). Varjet janë gjithashtu **lloje vlere** — caktimi ose kalimi i njërit kopjon të gjithë vargun. Kjo ngurtësi është arsyeja pse ato rrallë përdoren drejtpërdrejt.

## Fetat — dinamike dhe fleksibile

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

Një fetë nuk ka madhësi fikse — ju e rritni atë me `append`. Është sekuenca dinamike e përditshme.

## Si funksionojnë fetat nën kapuçin

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

## Fetimi krijon një pamje (varg themelues i përbashkët — një grackë)

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

Fetimi (`s[low:high]`) nuk kopjon — krijon një kokë fetë të re që tregon në **të njëjtin** varg themelues. Modifikimi i njërit mund të ndikojë në tjetrin — një burim i zakonshëm i gabimeve delikate. Përdorni `copy()` për një kopje të pavarur.

## Surpriza e rishpërndarjes së 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)
```

## Pse është i rëndësishëm

Fetat janë një nga veçoritë më të përdorura dhe më të keqkuptuara të Go-s.

Kuptimi se varjet janë lloje vlere me madhësi fikse (rrallë përdoret drejtpërdrejt) ndërsa **fetat** janë pamje fleksibile, të ngjashme me referencë në një varg themelues (mjeti i përditshëm) është themelor.

Më e rëndësishmja, të njohësh **sjelljen e vargjeve themelues të përbashkët** — se fetimi krijon një pamje, jo një kopje, kështu që modifizimet mund të ndikojnë në fetat e tjera, dhe se `append` mund ose nuk mund të bëjë rishpërndarje — parandalon një klasë gabimesh aliasimi delikate dhe të vështira për t'u debuguar që zënë edhe zhvillusesit me përvojë.

Mastering fetat (len vs cap, append, copy, grackat e ndarjes) është njohuri thelbësore e përditshme e Go-s dhe temë e shpeshtë e intervistës, pasi pothuajse të gjitha puna e koleksioneve përdorin ato.