Sự khác biệt giữa array và slice là gì?

Question

Accepted Answer

Một **array** có kích thước cố định là một phần của kiểu của nó; một **slice** là một khung nhìn (view) linh hoạt, có kích thước động vào một array bên dưới. Trong thực tế bạn gần như luôn dùng **slice** — array hiếm khi xuất hiện trong Go hàng ngày.

## Array — kích thước cố định

```go
var arr [5]int               // một array gồm đúng 5 int (kích thước là một phần của kiểu)
arr[0] = 10
fmt.Println(len(arr))        // 5 — kích thước cố định mãi mãi

// [3]int và [5]int là các kiểu KHÁC NHAU — không thể gán cái này cho cái kia
```

Kích thước array được cố định tại thời điểm biên dịch và là một phần của kiểu của nó (`[5]int` ≠ `[3]int`). Array cũng là **kiểu giá trị (value type)** — gán hoặc truyền một array sẽ sao chép toàn bộ array. Sự cứng nhắc này là lý do chúng ít khi được dùng trực tiếp.

## Slice — động và linh hoạt

```go
s := []int{1, 2, 3}          // một slice (không có kích thước trong ngoặc)
s = append(s, 4)             // mở rộng — append trả về một slice mới
fmt.Println(len(s), cap(s))  // length và capacity

nums := make([]int, 0, 10)   // tạo slice: length 0, capacity 10 (đã cấp phát trước)
```

Một slice không có kích thước cố định — bạn mở rộng nó với `append`. Đây là chuỗi động được dùng mặc định.

## Slice hoạt động như thế nào bên dưới

```text
Một slice là một struct nhỏ: { con trỏ tới array bên dưới, length, capacity }
  - len = số phần tử hiện có trong slice
  - cap = kích thước của array bên dưới tính từ điểm bắt đầu của slice
append: nếu len < cap, tái sử dụng array; nếu len == cap, cấp phát array LỚN HƠN & sao chép
```

## Việc cắt (slicing) tạo ra một view (chung backing array — một cạm bẫy)

```go
original := []int{1, 2, 3, 4, 5}
sub := original[1:3]         // [2, 3] — một VIEW vào cùng backing array
sub[0] = 99                  // ⚠️ cũng thay đổi original[1] → [1, 99, 3, 4, 5]!
```

Việc cắt (`s[low:high]`) không sao chép — nó tạo ra một slice header mới trỏ tới **cùng** array bên dưới. Sửa đổi cái này có thể ảnh hưởng cái kia — một nguồn lỗi tinh vi phổ biến. Dùng `copy()` để có một bản sao độc lập.

## Bất ngờ tái cấp phát của append

```go
a := []int{1, 2, 3}
b := append(a, 4)            // có thể chung hoặc không chung array của a, tùy capacity
// pattern an toàn: luôn dùng slice ĐƯỢC TRẢ VỀ từ append
a = append(a, 4)
```

## Tại sao điều này quan trọng

Slice là một trong những tính năng được dùng nhiều nhất và bị hiểu lầm nhiều nhất của Go.

Hiểu rằng array là kiểu giá trị có kích thước cố định (hiếm khi dùng trực tiếp) trong khi **slice** là các view linh hoạt, giống tham chiếu vào một backing array (công cụ hàng ngày) là điều nền tảng.

Quan trọng nhất, biết **hành vi chung-backing-array** — rằng việc cắt tạo ra một view, không phải bản sao, nên các sửa đổi có thể ảnh hưởng các slice khác, và rằng `append` có thể tái cấp phát hoặc không — giúp ngăn chặn một lớp các lỗi aliasing tinh vi, khó debug, vốn khiến cả những lập trình viên dày dạn cũng mắc.

Thành thạo slice (len vs cap, append, copy, các cạm bẫy chia sẻ) là kiến thức Go hàng ngày thiết yếu và là một chủ đề phỏng vấn thường gặp, vì gần như mọi công việc với collection đều dùng chúng.