Golang – 陣列、切片與映射

單元：切片的底層實現（len、cap、make）

---

簡介

在 Go 語言中，**切片（slice）**是最常使用的動態資料結構。它比陣列更彈性，同時又保留了陣列的高效存取特性。了解切片的底層實作，尤其是 len、cap 與 make 的行為，對於寫出效能可預測、記憶體安全的程式至關重要。

本篇文章將從概念、實作細節、常見陷阱與最佳實踐，逐層剖析切片的內部結構，並提供 實務範例，幫助初學者與中階開發者在日常開發中更得心應手。

---

核心概念

1. 切片的三個核心屬性

屬性	說明	與陣列的關係
指標（ptr）	指向底層陣列的第一個元素（或是切片的起始位置）	共享同一塊記憶體
長度（len）	切片中目前可存取的元素個數	只能存取 0 <= i < len 的索引
容量（cap）	從切片起始位置到底層陣列結尾的元素總數	cap >= len，決定了自動擴容的上限

重點：len 只描述「可見」的範圍，而 cap 描述「可擴展」的上限。兩者皆是 int 型別，與平台位元寬度相同。

---

2. make：建立切片的唯一官方方式

// 建立一個長度為 3、容量為 5 的 int 切片
s := make([]int, 3, 5)

• make([]T, length) → capacity == length
• make([]T, length, capacity) → 明確指定容量

make 會在底層呼叫 runtime.mallocgc 分配一段連續記憶體，然後回傳一個 slice header（ptr、len、cap）。若未指定 capacity，Go 會自動把 capacity 設為 length。

---

3. len 與 cap 的內建函式

fmt.Println(len(s)) // 3
fmt.Println(cap(s)) // 5

這兩個函式只是 讀取 slice header 中的值，沒有額外的計算成本。即使切片是 nil，len(nil) 與 cap(nil) 都會回傳 0，不會觸發 panic。

---

4. 切片的自動擴容機制

當使用 append 超過 cap 時，runtime 會：

1. 計算新容量：通常是舊容量的兩倍（或更大），具體規則見下表。
2. 分配新陣列，把舊資料複製過去。
3. 回傳指向新陣列的切片。

舊容量 (cap)	新容量 (newCap)
≤ 1024	2 * oldCap
> 1024	oldCap + oldCap/2

注意：擴容會產生 新指標，原本的切片仍指向舊陣列。若有其他變數同時引用舊切片，會導致 資料不一致。

---

程式碼範例

範例 1：使用 make 建立不同容量的切片

package main

import "fmt"

func main() {
    // 長度與容量相同
    a := make([]int, 4)          // cap = 4
    // 明確指定容量
    b := make([]int, 2, 6)       // len = 2, cap = 6

    fmt.Printf("a: len=%d cap=%d %v\n", len(a), cap(a), a)
    fmt.Printf("b: len=%d cap=%d %v\n", len(b), cap(b), b)
}

make 只負責分配底層陣列，元素會以零值初始化。

---

範例 2：觀察 append 的自動擴容

package main

import "fmt"

func main() {
    s := make([]int, 0, 2) // 初始 cap = 2
    fmt.Printf("start: len=%d cap=%d %v\n", len(s), cap(s), s)

    for i := 1; i <= 5; i++ {
        s = append(s, i) // 可能觸發擴容
        fmt.Printf("after %d: len=%d cap=%d %v\n", i, len(s), cap(s), s)
    }
}

執行結果會顯示 容量從 2 → 4 → 8 的變化，說明擴容的倍增策略。

---

範例 3：切片共享底層陣列

package main

import "fmt"

func main() {
    data := []int{10, 20, 30, 40, 50}
    s1 := data[1:4] // len=3 cap=4
    s2 := s1[:2]    // 只取前兩個

    fmt.Println("s1:", s1) // [20 30 40]
    fmt.Println("s2:", s2) // [20 30]

    // 修改 s2 會影響 s1 與 data
    s2[0] = 99
    fmt.Println("修改後 s1:", s1)   // [99 30 40]
    fmt.Println("修改後 data:", data) // [10 99 30 40 50]
}

因為 s1、s2 與 data 共用同一塊底層陣列，對任一切片的寫入都會同步反映。

---

範例 4：nil 切片與空切片的差異

package main

import "fmt"

func main() {
    var nilSlice []int          // nil
    emptySlice := []int{}       // 長度 0、容量 0，但非 nil

    fmt.Printf("nilSlice: %#v len=%d cap=%d\n", nilSlice, len(nilSlice), cap(nilSlice))
    fmt.Printf("emptySlice: %#v len=%d cap=%d\n", emptySlice, len(emptySlice), cap(emptySlice))

    // 判斷是否為 nil
    if nilSlice == nil {
        fmt.Println("nilSlice 為 nil")
    }
    if emptySlice == nil {
        fmt.Println("emptySlice 為 nil")
    } else {
        fmt.Println("emptySlice 不是 nil")
    }
}

nil 切片在序列化（如 JSON）時會被省略，而空切片會被序列化為 []，這在 API 設計上需要留意。

---

範例 5：手動控制容量以避免不必要的擴容

package main

import "fmt"

func main() {
    // 已知最終會有 1000 個元素
    s := make([]int, 0, 1000) // 直接預留足夠容量
    for i := 0; i < 1000; i++ {
        s = append(s, i)
    }
    fmt.Printf("final: len=%d cap=%d\n", len(s), cap(s))
}

一次性分配足夠的容量，可 避免在迴圈中多次觸發擴容，提升效能。

---

常見陷阱與最佳實踐

陷阱	說明	解決方案
切片共享底層陣列導致意外變更	多個切片指向同一陣列，寫入其中一個會影響其他	需要「深拷貝」時，使用 copy(newSlice, oldSlice) 或 append([]T(nil), oldSlice...)
忘記檢查 nil 切片	nil 切片與空切片在 JSON、SQL 等外部介面表現不同	在 API 輸出前統一轉為空切片：if slice == nil { slice = []T{} }
過度使用 append 產生大量暫時切片	每次 append 可能產生新陣列，導致 GC 壓力	事先估算容量，使用 make([]T, 0, expectedCap)
使用 append 時忘記回寫切片變數	append 可能返回新切片，若不賦值會失去擴容結果	正確寫法：s = append(s, v)
切片的容量誤判	直接使用 len 判斷是否可再寫入，忽略 cap	應該檢查 len < cap 或直接使用 append 讓 runtime 處理

最佳實踐

1. 預估容量：對於已知大小的集合，先 make 足夠的容量。
2. 避免共享：在需要獨立資料時，使用 copy 或 append 建立新切片。
3. 統一 nil 處理：在函式返回切片時，盡量返回空切片而非 nil，提升 API 可預測性。
4. 檢查返回值：所有 append、slice[:i] 等操作都應把結果賦回變數。
5. 使用 len 與 cap 監控：在效能敏感的程式中，適時打印 len、cap 以確認是否出現不必要的擴容。

---

實際應用場景

1. 批次資料處理

   • 讀取大量資料時，先 make([]Record, 0, batchSize)，避免在每筆資料 append 時觸發多次擴容。

2. 網路服務的 JSON 回傳

   • 為了讓前端收到 [] 而不是 null，在組裝回傳切片前確保 if slice == nil { slice = []T{} }。

3. 併發寫入的緩衝區

   • 使用 make([]byte, 0, 4<<10) 建立 4KB 緩衝，配合 sync.Pool 重複利用，降低 GC 次數。

4. 圖形或音訊處理的暫存

   • 需要頻繁調整長度的緩衝區，可透過 slice = slice[:newLen] 直接改變 len，而不必重新分配記憶體，只要 newLen <= cap(slice)。

5. 資料庫批次寫入

   • 收集多筆 INSERT 參數，當 len(buf) == cap(buf) 時一次性送出，確保批次大小固定且效能最佳。

---

總結

切片是 Go 語言中最核心、最彈性的資料結構之一。透過 make、len、cap 三個關鍵概念，我們可以：

• 精準掌握底層陣列的記憶體配置
• 有效避免不必要的自動擴容與 GC 負擔
• 正確處理 nil 與空切片的差異，提升 API 的一致性

在實務開發中，預估容量、避免共享、正確回寫 append 是提升效能與程式正確性的關鍵。只要熟悉這些底層機制，切片就能成為你在 Go 生態系統裡最得力的工具。祝你寫程式順利，玩轉 Go！