Jaký je rozdíl mezi poli (arrays) a řezy (slices)?

Question

Accepted Answer

**Pole** má pevnou velikost, která je součástí jeho typu; **řez** je flexibilní, dynamicky velký pohled na podkladové pole. V praxi téměř vždy používáte **řezy** — pole jsou vzácná v každodenním Go.

## Pole — pevná velikost

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

Velikost pole je pevně určena v čase kompilace a je součástí jeho typu (`[5]int` ≠ `[3]int`). Pole jsou také **hodnotové typy** — přiřazení nebo předání jednoho zkopíruje celé pole. Tato ztuhlost je důvod, proč se pole přímo používají zřídka.

## Řezy — dynamické a flexibilní

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

Řez nemá pevnou velikost — zvětšíte ho pomocí `append`. Jde o preferovanou dynamickou sekvenci.

## Jak řezy fungují interně

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

## Krájení vytváří pohled (sdílené podkladové pole — úskalí)

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

Krájení (`s[low:high]`) nekopíruje — vytváří nový header řezu odkazující na **stejné** podkladové pole. Úprava jednoho může ovlivnit druhého — běžný zdroj jemných chyb. Pro nezávislou kopii použijte `copy()`.

## Překvapení realokace v 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)
```

## Proč to má smysl

Řezy patří mezi nejčastěji používané a nejčastěji nepochopené funkce Go.

Pochopení, že pole jsou pevně velké hodnotové typy (zřídka se používají přímo), zatímco **řezy** jsou flexibilní, referencí podobné pohledy na podkladové pole (každodenní nástroj), je základní.

Zásadně je důležité znát chování **sdíleného podkladového pole** — že krájení vytváří pohled, ne kopii, takže úpravy mohou ovlivnit jiné řezy, a že `append` může nebo nemusí realokovat — což zabraňuje třídě jemných, těžko laditelných aliasovacích chyb, které chytají i zkušené vývojáře.

Ovládnutí řezů (len versus cap, append, copy, úskalí sdílení) je nezbytné každodenní Go znalosti a časté téma v rozhovorech, protože téměř veškerá práce s kolekcemi je používá.