Koja je razlika između niza i dijelova?

Question

Accepted Answer

**Niz** ima fiksnu veličinu koja je dio njegove vrste; **dio** je fleksibilan, dinamički promijenljiv prikaz temeljnog niza. U praksi gotovo uvijek koristite **dijelove** — nizovi su rijetki u svakodnevnom Go-u.

## Nizovi — fiksna veličina

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

Veličina niza je fiksna pri kompilaciji i dio je njegove vrste (`[5]int` ≠ `[3]int`). Nizovi su također **vrste vrijednosti** — dodjela ili prosljeđivanje kopira cijeli niz. Ta krutost je razlog zašto se rijetko koriste izravno.

## Dijelovi — dinamični i fleksibilni

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

Dio nema fiksnu veličinu — povećavate ga sa `append`. To je standard dinamički slijed.

## Kako dijelovi funkcioniraju ispod poklopca

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

## Rezanje kreira prikaz (dijeljena temeljama niza — zamka)

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

Rezanje (`s[low:high]`) ne kopira — kreira novu glavu dijela koja pokazuje na **isti** temelji niz. Izmjena jednog može utjecati na drugi — česta izvor suptilnih grešaka. Koristite `copy()` za neovisnu kopiju.

## append je iznenađenje realokacije

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

## Zašto je to važno

Dijeli su jedan od najčešće korištenih i najveće krivo razumljenih značajki Go-a.

Razumijevanje da su nizovi vrste vrijednosti fiksne veličine (rijetko se koriste izravno) dok su **dijelovi** fleksibilni, referentni slični prikazi temeljnog niza (svakodnevni alat) temeljan je.

Uspješno, znanje o **ponašanju dijeljenog temeljnog niza** — da rezanje kreira prikaz, ne kopiju, tako da izmjene mogu utjecati na druge dijelove, i da `append` može ili ne može realocirati — zaustavlja klasu suptilnih, teško ispravljivih aliasing greške koje zarobljavaju čak i iskusne programere.

Savladavanje dijelova (len vs cap, append, copy, zamake dijeljenja) je bitno svakodnevno Go znanje i česta tema intervjua, jer gotovo svi rad sa zbirkama koristi ih.