你能用它做的事情用其他方法做不到:

创建通道 创建一个预分配空间的映射 创建一个预先分配空间的切片，或者使用len != cap

要证明新的合理性有点难。它简化的主要事情是创建指向非复合类型的指针。 下面两个函数是等价的。一个更简洁一点:

func newInt1() *int { return new(int) }

func newInt2() *int {
    var i int
    return &i
}

Go有多种内存分配和值初始化的方式:

科技{…}， &someLocalVar, new, make

在创建复合字面量时也可以进行分配。

New可用于分配整数等值，&int是非法的:

new(Point)
&Point{}      // OK
&Point{2, 3}  // Combines allocation and initialization

new(int)
&int          // Illegal

// Works, but it is less convenient to write than new(int)
var i int
&i

new和make的区别可以从下面的例子中看出:

p := new(chan int)   // p has type: *chan int
c := make(chan int)  // c has type: chan int

假设Go没有new和make，但它有内置函数new。然后示例代码看起来像这样:

p := NEW(*chan int)  // * is mandatory
c := NEW(chan int)

*是强制性的，所以:

new(int)        -->  NEW(*int)
new(Point)      -->  NEW(*Point)
new(chan int)   -->  NEW(*chan int)
make([]int, 10) -->  NEW([]int, 10)

make(Point)  // Illegal
make(int)    // Illegal

是的，可以将new和make合并为一个内置函数。然而，一个内置函数可能比两个内置函数更容易让新程序员感到困惑。

考虑到以上几点，new和make保持分离似乎更合适。

您需要make()来创建通道和映射(以及切片，但这些也可以从数组创建)。没有其他方法来创建这些，所以不能从词典中删除make()。

至于new()，当可以使用结构语法时，我不知道为什么还需要它。但它确实有一个独特的语义含义，即“创建并返回一个将所有字段初始化为零值的结构体”，这很有用。

new()和make()的区别:

new(T)为一个类型为T的新项分配零存储，并返回它的地址，一个类型为*T的值:它返回一个指向新分配的类型为T的零值的指针，准备使用;它适用于数组和结构等值类型;它是 等价于&T{} make(T)返回一个初始化的T类型值;它只适用于3种内置的引用类型:切片、映射和通道。

换句话说，新的分配;使初始化;

var p *[]int = new([]int)
or
// *p == nil; with len and cap 0
p := new([]int)

这很少有用。

p := make([]int, 0)

我们的切片已经初始化，但这里指向一个空数组。

这两种说法都不是很有用，下面是:

var v []int = make([]int, 10, 50)
// Or
v := make([]int, 10, 50)

这将分配一个50个整型数组，然后创建一个长度为10，容量为50的切片v，指向数组的前10个元素。

找出make()和new()的一些规则:

对于切片、映射和通道:使用make 对于数组、结构和所有值类型:使用new

package main
type Foo map[string]string
type Bar struct {
         s string
         i int
}
func main() {
         // OK:
         y := new(Bar)
         (*y).s = "hello"
         (*y).i = 1

         // NOT OK:
         z := make(Bar) // compile error: cannot make type Bar
         z.s = "hello"
         z.i = 1

         // OK:
         x := make(Foo)
         x["x"] = "goodbye"
         x["y"] = "world"

         // NOT OK:
         u := new(Foo)
         (*u)["x"] = "goodbye" // !!panic!!: runtime error: 
                   // assignment to entry in nil map
         (*u)["y"] = "world"
}

渠道:

func main() {
    // OK:
    ch := make(chan string)
    go sendData(ch)
    go getData(ch)
    time.Sleep(1e9)

    // NOT OK:
    ch := new(chan string)
    go sendData(ch) // cannot use ch (variable of type *chan string) 
                   // as chan string value in argument to sendData
    go getData(ch)
    time.Sleep(1e9)
}

func sendData(ch chan string) {
    ch <- "Washington"
    ch <- "Tripoli"
    ch <- "London"
    ch <- "Beijing"
    ch <- "Tokio"
}

func getData(ch chan string) {
    var input string
    for {
        input = <-ch
        fmt.Printf("%s ", input)

    }
}

new(T):它返回一个指向类型T的指针，一个类型为*T的值，它分配并归零内存。new(T)等价于&T{}。

make(T):返回类型为T的初始化值，分配并初始化内存。它用于切片，映射和通道。

除了在Effective Go中解释的所有内容外，new(T)和&T{}之间的主要区别是后者显式执行堆分配。但是，应该注意的是，这取决于实现，因此可能会发生变化。

比较make和new没有什么意义，因为两者执行完全不同的功能。但这在链接的文章中有详细的解释。