Was ist der Unterschied zwischen Arrays und Slices?

Question

Accepted Answer

Ein **Array** hat eine feste Größe, die Teil seines Typs ist; ein **Slice** ist eine flexible, dynamisch große Ansicht in ein zugrunde liegendes Array. In der Praxis verwendest du fast immer **Slices** — Arrays sind im alltäglichen Go selten.

## Arrays — feste Größe

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

Array-Größen sind zur Compile-Zeit festgelegt und Teil ihres Typs (`[5]int` ≠ `[3]int`). Arrays sind auch **Value Types** — das Zuweisen oder Übergeben kopiert das ganze Array. Diese Rigidität ist der Grund, warum sie selten direkt verwendet werden.

## Slices — dynamisch und flexibel

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

Ein Slice hat keine feste Größe — du vergrößerst es mit `append`. Es ist die Standard-Datenstruktur für dynamische Sequenzen.

## Wie Slices unter der Haube funktionieren

```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 erstellt eine Ansicht (gemeinsames Backing Array — eine Fallstricke)

```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]`) kopiert nicht — es erstellt einen neuen Slice-Header, der auf das **gleiche** zugrunde liegende Array zeigt. Modifizierungen an einem können den anderen beeinflussen — eine häufige Quelle subtiler Bugs. Verwende `copy()` für eine unabhängige Kopie.

## append's Reallokations-Überraschung

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

## Warum es wichtig ist

Slices sind eines der am häufigsten verwendeten und am meisten missverstandenen Features in Go.

Zu verstehen, dass Arrays fest große Value Types sind (werden selten direkt verwendet), während **Slices** flexible, referenzähnliche Ansichten in ein Backing Array sind (das alltägliche Werkzeug), ist fundamental.

Kritisch ist das Verständnis des **gemeinsamen Backing-Array-Verhaltens** — dass Slicing eine Ansicht, keine Kopie erstellt, sodass Modifizierungen andere Slices beeinflussen können, und dass `append` möglicherweise realloziiert oder nicht — dies verhindert eine Klasse subtiler, schwer zu debuggender Aliasing-Bugs, die sogar erfahrene Entwickler fangen.

Slices zu beherrschen (len vs cap, append, copy, die Sharing-Fallstricke) ist essentielles alltägliches Go-Wissen und ein häufiges Interview-Thema, da fast alle Collection-Arbeiten diese verwenden.