อะไรคือความแตกต่างระหว่าง array กับ slice?

Question

Accepted Answer

**array** มีขนาดคงที่ซึ่งเป็นส่วนหนึ่งของชนิดของมัน ส่วน **slice** เป็นมุมมอง (view) ที่ยืดหยุ่นและปรับขนาดได้แบบไดนามิกไปยัง array ที่อยู่เบื้องหลัง ในทางปฏิบัติคุณแทบจะใช้ **slice** เสมอ — array นั้นพบได้น้อยในการใช้งาน Go ประจำวัน

## Array — ขนาดคงที่

```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 ถูกกำหนดตายตัวตอน compile time และเป็นส่วนหนึ่งของชนิดของมัน (`[5]int` ≠ `[3]int`) array ยังเป็น **value type** ด้วย — การกำหนดค่าหรือส่งผ่าน array จะคัดลอกทั้ง array ความเข้มงวดนี้คือเหตุผลที่ทำให้มันถูกใช้โดยตรงน้อยมาก

## Slice — ไดนามิกและยืดหยุ่น

```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 ไม่มีขนาดคงที่ — คุณขยายมันได้ด้วย `append` มันเป็นลำดับแบบไดนามิกที่เป็นตัวเลือกหลัก

## slice ทำงานอย่างไรเบื้องหลัง

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

## การ slice สร้างเป็นมุมมอง (ใช้ backing array ร่วมกัน — จุดที่ต้องระวัง)

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

การ slice (`s[low:high]`) ไม่ได้คัดลอก — มันสร้าง slice header ใหม่ที่ชี้ไปยัง array เบื้องหลัง **ตัวเดียวกัน** การแก้ไขตัวหนึ่งจึงอาจส่งผลต่ออีกตัวหนึ่ง — เป็นแหล่งของบั๊กที่ละเอียดอ่อนที่พบบ่อย ใช้ `copy()` เพื่อสร้างสำเนาที่เป็นอิสระ

## ความน่าประหลาดใจของการ reallocate ใน 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)
```

## ทำไมจึงสำคัญ

slice เป็นหนึ่งในคุณสมบัติที่ใช้มากที่สุดและเข้าใจผิดกันมากที่สุดของ Go

การเข้าใจว่า array เป็น value type ที่มีขนาดคงที่ (ใช้โดยตรงน้อยมาก) ในขณะที่ **slice** เป็นมุมมองแบบ reference-like ที่ยืดหยุ่นไปยัง backing array (เครื่องมือที่ใช้ทุกวัน) เป็นเรื่องพื้นฐาน

ที่สำคัญ การรู้ **พฤติกรรมการใช้ backing array ร่วมกัน** — ว่าการ slice สร้างเป็นมุมมอง ไม่ใช่สำเนา ดังนั้นการแก้ไขจึงอาจส่งผลต่อ slice อื่น และว่า `append` อาจ reallocate หรือไม่ก็ได้ — ช่วยป้องกันบั๊กแบบ aliasing ที่ละเอียดอ่อนและตามแก้ยากทั้งกลุ่มหนึ่ง ซึ่งดักแม้แต่นักพัฒนาที่มีประสบการณ์

การเชี่ยวชาญ slice (len เทียบกับ cap, append, copy และจุดที่ต้องระวังเรื่องการใช้ร่วมกัน) เป็นความรู้ Go ที่จำเป็นในการใช้งานประจำวันและเป็นหัวข้อสัมภาษณ์ที่พบบ่อย เนื่องจากงานเกี่ยวกับ collection เกือบทั้งหมดล้วนใช้มัน