Apakah perbezaan antara tatasusunan dan hirisan?

Question

Accepted Answer

**Tatasusunan** mempunyai saiz tetap yang merupakan bahagian daripada jenisnya; **hirisan** ialah pandangan yang fleksibel dan dinamis ke dalam tatasusunan asas. Dalam praktik, anda hampir selalu menggunakan **hirisan** — tatasusunan jarang digunakan dalam Go sehari-hari.

## Tatasusunan — saiz 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
```

Saiz tatasusunan tetap pada masa kompilasi dan merupakan bahagian daripada jenisnya (`[5]int` ≠ `[3]int`). Tatasusunan juga **jenis nilai** — menetapkan atau melewati satu menyalin seluruh tatasusunan. Keketatan ini adalah sebab mengapa mereka jarang digunakan secara langsung.

## Hirisan — dinamik 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)
```

Hirisan tidak mempunyai saiz tetap — anda menumbuhkannya dengan `append`. Ia adalah jujukan dinamik yang perlu digunakan.

## Bagaimana hirisan berfungsi di bawah tudung

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

## Hirisan mencipta pandangan (tatasusunan asas berkongsi — jerat)

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

Hirisan (`s[low:high]`) tidak menyalin — ia mencipta tajuk hirisan baharu yang menunjuk ke **tatasusunan asas yang sama**. Mengubah satu boleh menjejaskan yang lain — sumber umum bug halus. Gunakan `copy()` untuk salinan bebas.

## Kejutan peruntukan semula 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

Hirisan adalah salah satu ciri yang paling kerap digunakan dan paling disalahfahami dalam Go.

Memahami bahawa tatasusunan adalah jenis nilai bersaiz tetap (jarang digunakan secara langsung) sementara **hirisan** adalah pandangan yang fleksibel dan serupa rujukan ke tatasusunan asas (alat sehari-hari) adalah asas.

Yang penting, mengetahui **tingkah laku tatasusunan asas berkongsi** — bahawa hirisan mencipta pandangan, bukan salinan, jadi pengubahsuaian boleh menjejaskan hirisan lain, dan bahawa `append` mungkin atau tidak boleh memperuntukkan semula — mencegah kelas bug penjodoh yang halus dan sukar untuk debug yang menangkap malah pembangun berpengalaman.

Menguasai hirisan (len vs cap, append, copy, jerat berkongsi) adalah pengetahuan Go sehari-hari yang penting dan topik temu duga yang kerap, kerana hampir semua kerja koleksi menggunakannya.