Mi a különbség a tömbök és a szeletetek között?

Question

Accepted Answer

Egy **tömb** rögzített mérettel rendelkezik, amely a típusának része; egy **szelet** egy rugalmas, dinamikusan méretezett nézet az alapul szolgáló tömbre. A gyakorlatban szinte mindig **szeleteket** használ — a tömbök ritkák az érdeklődő Go kódban.

## Tömbök — rögzített méret

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

A tömb mérete fordítási időben van rögzítve és a típusa része (`[5]int` ≠ `[3]int`). A tömbök **érték típusok** is — egy hozzárendelése vagy átadása az egész tömböt másolja. Ez a merevség az oka annak, hogy ritkán használják közvetlenül.

## Szeletetek — dinamikus és rugalmas

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

Egy szeletnek nincs rögzített mérete — az `append` -pal növelheti. Ez a standard dinamikus sorozat.

## Hogyan működnek a szeletetek a motorháztető alatt

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

## A szeletelés egy nézetet hoz létre (megosztott támogatási tömb — csapda)

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

A szeletelés (`s[low:high]`) nem másolja — új szelethegyet hoz létre, amely az **azonos** alapul szolgáló tömbre mutat. Az egyik módosítása a másikat befolyásolhatja — a finom hibák gyakori forrása. Használja a `copy()` -t a független másolathoz.

## az append újrafoglalásának meglepetése

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

## Miért fontos ez

A szeletetek a Go egyik leggyakrabban használt és leggyakrabban félreértelmezett jellemzője.

Annak megértése, hogy a tömbök rögzített méretű érték típusok (ritkán közvetlenül használt), míg a **szeletetek** rugalmas, referencia-szerű nézetek az alapul szolgáló tömbre (a mindennapi eszköz) alapvető.

Fontos, hogy ismerjük a **megosztott biztonsági tömb viselkedést** — hogy a szeletelés egy nézetet, nem másolatot hoz létre, így a módosítások más szeleteket is érinthetnek, és hogy az `append` újrafoglalhat vagy sem — megakadályozza a finom, nehezen hibakereshető aliasing hibák egy osztályát, amely még a tapasztalt fejlesztőket is megfog.

A szeletetek (len vs cap, append, copy, megosztási csapdák) elsajátítása alapvetően szükséges mindennapi Go tudás és gyakori interjúkérdés, mivel szinte minden gyűjteményes munka felhasználja őket.