Go new 与 make：别只背“一个返回指针，一个负责初始化”

假设要创建一个计数器。只要有一个整数变量，并把初始值设为 0，它就能工作：

count := new(int)
fmt.Println(*count) // 0
*count = 1

但 Map 不只是“若干个零值字段”。它还需要运行时建立可写的数据结构；Channel 也需要通信队列和同步状态。只给它们一个 nil（空引用，表示还没有连接到实际对象）的零值，读取或比较也许可以，完整功能却没有准备好。

T 代表某个具体类型，例如 int 或 User。*T 叫作“指向 T 的指针”，它保存的不是 T 的内容本身，而是这个变量所在的地址。

零值是一个类型在没有显式赋值时的默认值：整数是 0，布尔值是 false，字符串是空字符串，结构体的每个字段也各自取零值。

type User struct {
    Name   string
    Active bool
}

p := new(User)
fmt.Printf("%T %#v\n", p, *p)
// *main.User main.User{Name:"", Active:false}

new(User) 的结果是 *User，所以变量 p 保存地址。*p 是解引用，也就是沿着地址取出真正的 User 值。

Go 1.26+：new 也能接收表达式

表达式是能够计算出一个值的代码，例如 18、user.Name 或函数调用 yearsSince(born)。从 Go 1.26 起，new(x) 会先计算 x，再创建同类型变量，把 x 的值放进去，最后返回指针。

zero := new(int) // *int，指向 0；所有 Go 版本都支持
age  := new(18)  // *int，指向 18；需要 Go 1.26+
name := new("Ada") // *string，指向 "Ada"；需要 Go 1.26+

无类型常量会先转成默认类型，例如 new(18) 得到 *int。new(nil) 不合法，因为单独的 nil 没有可确定的具体类型。

new 不是构造函数

构造函数通常会检查参数、设置业务默认值或维护约束。new(T) 只采用 T 的零值，new(x) 只采用表达式 x 算出的值；它们都不会自动调用名为 NewUser 的函数，也不会理解“新用户默认应该启用”这样的业务规则。

func NewUser(name string) *User {
    return &User{Name: name, Active: true}
}

make 的第一个参数始终是类型，而且只允许前文介绍的 Slice、Map 和 Channel。Channel 让 goroutine（Go 运行时调度的轻量并发任务）之间传递数据。make 返回的类型与传入类型相同，不额外加星号。

scores := make(map[string]int)
scores["Go"] = 100 // 可以直接写入

jobs := make(chan string, 1)
jobs <- "build"       // 缓冲区已准备好

items := make([]int, 0, 8)
items = append(items, 10)

这三种类型的变量都像一张“小说明书”或一个入口，完整工作还依赖运行时维护的其他数据。只把变量本身清零，会得到 nil；nil 值仍有各自有限的合法行为，但 make 能根据参数继续建立指定长度或容量、可写映射和可通信通道等底层状态。Slice 与 Map 也能通过字面量等方式创建，并不是只能使用 make。

三个参数不要混成一种含义

如果想进一步理解底层行为，可继续阅读 Slice 扩容专题、当前 Map 实现专题和 Channel 缓冲与关闭专题。

下面只改变创建方式，观察同一种类型的结果。nil 不等于“对象内容为空”，它表示当前变量没有连接到实际对象。

Slice：nil Slice 仍然可以 append，但多了一层指针

p := new([]int)
fmt.Println(*p == nil) // true
*p = append(*p, 1)

s := make([]int, 0)
fmt.Println(s == nil) // false
s = append(s, 1)

Map：nil Map 可读，但不能写

这里的 panic 是运行时错误：当前正常执行流程会被中断，并开始执行延迟清理与错误传播。

p := new(map[string]int)
fmt.Println((*p)["Go"]) // 0：读取 nil Map 安全
(*p)["Go"] = 100       // panic：assignment to entry in nil map

要让它可写，必须再赋入一个 make 的结果：*p = make(map[string]int)。这也说明直接写 m := make(map[string]int) 更自然。

Channel：nil Channel 不会自动变成无缓冲 Channel

p := new(chan int)
*p <- 1 // 永久阻塞；若主程序因此无法继续，运行时可能报告死锁

ch := make(chan int)
go func() { ch <- 1 }()
fmt.Println(<-ch) // 1：有发送方和接收方配对

Heap（堆）是适合保存生命周期跨越当前函数的数据区域；Stack（栈）是函数调用期间常用、退出时容易回收的数据区域。初学资料常把 new 说成“在堆上分配”，这不是 Go 语言层面的保证。

编译器会做 escape analysis：如果一个变量的地址没有逃出当前函数，并且大小等条件允许，它可能留在栈上；如果地址需要在函数返回后继续使用，它通常需要逃逸到堆上。代码仍然只应依赖语言语义，不应依赖这次编译恰好选择的位置。

func local() int {
    p := new(int)
    *p = 7
    return *p // p 没有返回，编译器可能把对象放在栈上或直接优化掉
}

func escape() *int {
    p := new(int)
    *p = 7
    return p // 地址离开函数，通常会逃逸
}

可用 go build -gcflags=-m 查看当前编译器的逃逸判断；输出属于特定 Go 版本和具体代码的优化结果，不是语言永久规则。

下面会用到复合字面量：它是在代码中直接写出结构体、数组、Slice 或 Map 初始内容的语法，例如 User{Name: "Ada"}。

new(T) 与 &T{} 的最小对照

a := new(User) // *User，字段全是零值
b := &User{}    // *User，字段全是零值
c := &User{Name: "Ada"} // *User，同时设置字段

&T{} 叫复合字面量取地址：先用字面量描述一个 T 值，再用 & 取得它的地址。它只适用于能写复合字面量的类型；new(int) 则能自然表达“需要一个 int 指针”。

1. 把 make 的 Slice 长度误当成预留容量

s := make([]int, 3)
s = append(s, 9)
fmt.Println(s) // [0 0 0 9]，不是 [9]

若要“当前为空，但提前预留 3 个位置”，应写 make([]int, 0, 3)。

2. new Map 后直接写入

p := new(map[string]int)
(*p)["x"] = 1 // panic

直接使用 m := make(map[string]int)；若确实需要指针，则先执行 *p = make(map[string]int)。

3. 把 nil Channel 当成无缓冲 Channel

var ch chan int 的 ch 是 nil，收发都会一直阻塞；make(chan int) 才是已初始化的无缓冲 Channel，它可以在发送方与接收方同时就绪时完成数据交接。

4. 为了“性能”到处使用 new

指针不天然更快。它可能增加间接访问、别名关系和堆分配压力，也会让所有权更难读。先按语义选择值或指针，再用基准测试与编译器报告验证热点，不要把 new 当作性能开关。

这段程序刻意避开会 panic 或永久阻塞的操作，只打印关键差异；复制到 main.go 后执行 go run main.go 即可验证。为了也能在 Go 1.25 及更早环境运行，示例主体使用 new(T)；前文的 new(18) 需要 Go 1.26+。

package main

import "fmt"

type User struct {
    Name string
}

func main() {
    p := new(User)
    fmt.Printf("new(User): type=%T value=%#v\n", p, *p)

    slicePointer := new([]int)
    readySlice := make([]int, 0, 3)
    fmt.Printf("new slice: type=%T nil=%v\n", slicePointer, *slicePointer == nil)
    fmt.Printf("make slice: type=%T nil=%v len=%d cap=%d\n",
        readySlice, readySlice == nil, len(readySlice), cap(readySlice))

    mapPointer := new(map[string]int)
    readyMap := make(map[string]int)
    readyMap["Go"] = 100
    fmt.Printf("new map: type=%T nil=%v\n", mapPointer, *mapPointer == nil)
    fmt.Printf("make map: type=%T value=%v\n", readyMap, readyMap)

    readyChannel := make(chan int, 1)
    readyChannel <- 7
    fmt.Printf("make channel: type=%T value=%d\n", readyChannel, <-readyChannel)
}

预期输出中的地址格式可能不同，但类型关系稳定：new(User) 是 *main.User，new([]int) 是 *[]int，而三次 make 都直接返回原类型。

面试时可以这样答：

“new(T) 适用于任意类型，它创建 T 的零值变量并返回 *T；Go 1.26 起也可写 new(x)，用表达式值初始化变量，但结果仍是指针。make 只用于 Slice、Map 和 Channel，负责按各自规则建立可用的内部状态，返回值仍是 T。比如 new(map[string]int) 得到的是指向 nil Map 的指针，不能直接写；make(map[string]int) 得到的是可写 Map。另外，new 不代表一定在堆上，实际内存位置由编译器逃逸分析决定。”

• Go Language Specification：Allocation：规定当前 new(T) 与 new(x) 的初始化及指针返回语义。
• Go 1.26 Release Notes：Changes to the language：记录 new 从 Go 1.26 起允许接收表达式。
• Go builtin package：make：说明 make 只接受 Slice、Map、Channel，以及三类参数的含义。
• Go builtin package：new：说明当前 new 可接收类型或表达式，并返回新变量的指针。
• Go FAQ：How do I know whether a variable is allocated on the heap or the stack?：解释内存位置由编译器决定，而不是由 new 语法固定决定。