本文 AI 產出，尚未審核

Golang – 指標與記憶體管理

主題：new 與 make 的差異

簡介

在 Go 語言中，記憶體的配置與指標的使用是每位開發者必須掌握的基礎。雖然 Go 內建了自動垃圾回收（GC），但在實作效能敏感的程式時，了解何時使用 new、何時使用 make 仍能帶來顯著的差異。

new 與 make 看似相似，都是用來分配記憶體的內建函式；然而它們的目的、返回值以及適用的資料型別卻大不相同。若混用不當，常會導致nil 指標錯誤、不必要的記憶體浪費，甚至影響程式的可讀性。

本篇文章將從概念、語法、實作範例到常見陷阱與最佳實踐，完整說明 new 與 make 的差異，並提供實務上常見的應用情境，幫助讀者在開發過程中做出正確的選擇。

核心概念

1. new：分配零值記憶體，返回指標

  • 語法：ptr := new(T)
  • 作用：在堆上（或逃逸到堆）分配一塊大小足以容納類型 T 的記憶體，並將該記憶體初始化為 零值（zero value）。
  • 返回值：*T（指向 T 的指標）。

重點：new 只負責 分配 與 零值初始化，不會對內建容器（slice、map、channel）進行額外的內部結構設定。

範例 1：使用 new 建立結構體指標

type Person struct {
    Name string
    Age  int
}

func main() {
    // 使用 new 分配記憶體，得到 *Person
    p := new(Person)

    // 此時 p 指向的結構體已是零值
    fmt.Printf("%+v\n", p) // &{Name: Age:0}

    // 可以直接透過指標修改欄位
    p.Name = "Alice"
    p.Age = 30
    fmt.Println(p.Name, p.Age) // Alice 30
}

2. make：專為內建容器設計的初始化函式

  • 語法：
    • s := make([]T, length, capacity)
    • m := make(map[K]V, hint)
    • c := make(chan T, buffer)
  • 作用：分配底層陣列（slice）、哈希表（map）或通道結構（channel）的記憶體，並同時完成內部資料結構的初始化。
  • 返回值：已初始化好的容器值（不是指標）。

重點：make 只能用於 slice、map、channel，若對其他類型使用會編譯錯誤。

範例 2：使用 make 建立 slice

func main() {
    // 建立長度為 3、容量為 5 的 int slice
    s := make([]int, 3, 5)

    // 預設值為 0，已可直接使用
    fmt.Println(s) // [0 0 0]

    // 追加元素，容量會自動擴增
    s = append(s, 1, 2)
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
    // len=5 cap=5 [0 0 0 1 2]
}

範例 3：使用 make 建立 map

func main() {
    // 建立一個字串鍵、整數值的 map，hint 為 10（預估容量）
    m := make(map[string]int, 10)

    // 直接寫入鍵值對
    m["golang"] = 1
    m["python"] = 2

    fmt.Println(m) // map[golang:1 python:2]
}

範例 4：使用 make 建立 channel

func main() {
    // 建立緩衝區大小為 2 的 int channel
    ch := make(chan int, 2)

    // 直接寫入兩個值，不會阻塞
    ch <- 10
    ch <- 20

    fmt.Println(<-ch) // 10
    fmt.Println(<-ch) // 20
}

3. new vs make：對比表

項目 new make
可用類型 任意類型（struct、array、int…） 只能是 slice、map、channel
返回值 指標 *T 已初始化的容器值（非指標）
是否初始化內部結構 只零值，不會建立底層結構 同時分配底層結構（陣列、哈希表、緩衝）
常見用途 需要指標或手動操作記憶體的情況 建立可直接使用的容器
是否需要 * 取值 必須使用 *ptr 或 ptr.Field 直接使用容器本身

程式碼範例（實務應用）

範例 5：new 與 make 混用的正確寫法

type Config struct {
    Options map[string]string
    Values  []int
}

func NewConfig() *Config {
    // 使用 new 產生 Config 的指標
    cfg := new(Config)

    // 必須使用 make 初始化內建容器
    cfg.Options = make(map[string]string, 5)
    cfg.Values = make([]int, 0, 10)

    return cfg
}

說明：new(Config) 只會把 Config 的欄位設為 nil，若不使用 make 初始化 Options 與 Values，隨後的寫入操作會觸發 runtime panic: assignment to entry in nil map。

範例 6：使用 new 產生指向 slice 的指標（不建議）

func main() {
    // 錯誤做法：使用 new 產生 []int 的指標
    p := new([]int) // p 為 *([]int)，底層 slice 為 nil

    // 若直接 append，會 panic
    // *p = append(*p, 1) // panic: runtime error: invalid memory address or nil pointer dereference

    // 正確做法：使用 make 產生 slice，然後取指標（若真的需要指標）
    s := make([]int, 0, 5)
    p2 := &s
    *p2 = append(*p2, 1)
    fmt.Println(*p2) // [1]
}

重點：new([]int) 只分配指標，底層 slice 為 nil，必須再手動 make 才能安全使用。大多數情況下直接使用 make 產生 slice 更直觀。

範例 7：make 內建容量提示的效益

func benchmarkMakeMap() {
    const N = 1000000
    // 提前 hint 容量，可減少 rehash 次數
    m := make(map[int]int, N)

    for i := 0; i < N; i++ {
        m[i] = i * 2
    }
    fmt.Println("size:", len(m))
}

說明：若不提供容量提示，map 會在插入過程中自動擴充，可能導致多次 rehash，影響效能。使用 make(map[K]V, hint) 可以提前分配足夠的桶（bucket），提升大資料量寫入的效能。

常見陷阱與最佳實踐

陷阱 說明 解決方式
將 new 用於 slice、map、channel 只會得到 nil 容器，後續操作會 panic。 永遠使用 make 來建立這類容器；若真的需要指標，先 make 再取址 &。
忘記初始化 map 的值 var m map[string]int 為 nil，寫入會 panic。 使用 m := make(map[string]int) 或在 new 後立即 make。
誤以為 new 會自動分配容量 new([]int, 10) 會編譯錯誤，且 new([]int) 只得到 nil slice。 以 make([]int, length, capacity) 指定長度與容量。
指標逃逸導致不必要的 heap 分配 new 產生的指標若在函式外使用，編譯器會把它逃逸到 heap，增加 GC 壓力。 若不需要指標，直接使用值；若需要指標，考慮是否真的需要 new，或改用 &value。
在高併發環境頻繁使用 make 產生大容量容器 大量分配會造成 GC 壓力，甚至 OOM。 盡量 重用 已分配的容器（例如 buf := make([]byte, 0, 1024)，之後 buf = buf[:0] 重置），或使用 sync.Pool。

最佳實踐總結

  1. 只在需要指標的情況下使用 new（如傳遞大型結構體、需要 *T 作為方法接收者）。
  2. 建立 slice、map、channel 時必定使用 make，並根據預估大小提供容量提示。
  3. 盡量避免在熱路徑中頻繁分配，使用緩衝池（sync.Pool）或容器重用技術。
  4. 使用 go vet 或 IDE 靜態分析，可快速捕捉 nil map、nil slice 等問題。

實際應用場景

1. 建構服務端的請求上下文（Context）

type RequestContext struct {
    Params map[string]string
    Data   []byte
}

// 建立新請求時使用 make 初始化容器
func NewRequestContext() *RequestContext {
    rc := &RequestContext{
        Params: make(map[string]string, 8), // 預估 8 個參數
        Data:   make([]byte, 0, 1024),      // 預留 1KB 緩衝
    }
    return rc
}

2. 高效能資料批次寫入（Batch Write）

func BatchInsert(db *sql.DB, rows [][]interface{}) error {
    // 事先分配足夠容量的 slice，減少 re‑allocation
    batch := make([][]interface{}, 0, len(rows))

    for _, r := range rows {
        batch = append(batch, r)
    }

    // 假設有一個執行批次插入的函式
    return execBatch(db, batch)
}

3. 並行工作者池（Worker Pool）

func startWorkerPool(num int) []chan<- int {
    workers := make([]chan<- int, num)
    for i := 0; i < num; i++ {
        ch := make(chan int, 100) // 每個 worker 有自己的緩衝
        workers[i] = ch
        go worker(i, ch)
    }
    return workers
}

在以上案例中，make 的容量提示直接影響系統的記憶體使用與吞吐量；而 new 僅在需要傳遞結構指標時才被使用，避免不必要的指標層級。

總結

  • new 只負責分配零值記憶體，返回指標，適用於任意類型但不會初始化內建容器。
  • make 專為 slice、map、channel 設計，不僅分配底層記憶體，還會完成容器的內部結構初始化，返回已就緒的容器值。
  • 正確區分兩者能避免 nil panic、記憶體浪費與效能瓶頸。
  • 在實務開發中，以 make 建立容器、以 new（或 &value）建立需要指標的結構，再搭配容量提示與容器重用，可寫出既安全又高效的 Go 程式。

掌握 new 與 make 的差異，將為你在 Go 專案中進一步優化記憶體管理與程式效能奠定堅實基礎。祝開發順利！ 🚀