Apa perbedaan antara array dan slice?

Question

Accepted Answer

**Array** memiliki ukuran tetap yang merupakan bagian dari tipenya; **slice** adalah tampilan yang fleksibel dan berukuran dinamis ke array yang mendasarinya. Dalam praktik Anda hampir selalu menggunakan **slice** — array jarang digunakan dalam Go sehari-hari.

## Array — ukuran tetap

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

Ukuran array ditetapkan pada waktu kompilasi dan merupakan bagian dari tipenya (`[5]int` ≠ `[3]int`). Array juga merupakan **tipe nilai** — menetapkan atau melewatkan array akan menyalin seluruh array. Kekakuan inilah mengapa mereka jarang digunakan secara langsung.

## Slice — dinamis dan fleksibel

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

Slice tidak memiliki ukuran tetap — Anda menumbuhkannya dengan `append`. Ini adalah alat standar untuk urutan dinamis.

## Cara slice bekerja di balik layar

```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 membuat tampilan (array dasar bersama — jebakan)

```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]`) tidak menyalin — membuat header slice baru yang menunjuk ke **array dasar yang sama**. Memodifikasi satu dapat mempengaruhi yang lain — sumber umum bug yang halus. Gunakan `copy()` untuk salinan independen.

## kejutan realokasi 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)
```

## Mengapa ini penting

Slice adalah salah satu fitur Go yang paling banyak digunakan dan paling disalahpahami.

Memahami bahwa array adalah tipe nilai dengan ukuran tetap (jarang digunakan secara langsung) sementara **slice** adalah tampilan yang fleksibel, mirip referensi ke array dasar (alat sehari-hari) adalah fundamental.

Secara krusial, mengetahui **perilaku array dasar bersama** — bahwa slicing membuat tampilan, bukan salinan, sehingga modifikasi dapat mempengaruhi slice lain, dan bahwa `append` mungkin atau mungkin tidak mengalokasikan ulang — mencegah kelas bug aliasing yang halus dan sulit di-debug yang menangkap bahkan pengembang berpengalaman.

Menguasai slice (len vs cap, append, copy, jebakan berbagi) adalah pengetahuan Go sehari-hari yang penting dan topik wawancara yang sering, karena hampir semua pekerjaan koleksi menggunakannya.