Golang make和new的区别

new 和 make 均可以用来分配空间，初始化类型，可是它们确有不一样。 先上源码:

// $GOROOT/1.11.5/libexec/src/builtin/builtin.go
func make(t Type, size ...IntegerType) Type 复制代码

func new(Type) *Type 复制代码

由源码可知,new(T) 返回的是 T 的指针

new(T) 为一个 T 类型新值分配空间并将此空间初始化为 T 的零值，返回的是新值的地址，也就是 T 类型的指针 *T，该指针指向 T 的新分配的零值。

p1 := new(int)
fmt.Printf("p1 --> %#v \n ", p1) //(*int)(0xc42000e250) 
fmt.Printf("p1 point to --> %#v \n ", *p1) //0
var p2 *int
i := 0
p2 = &i
fmt.Printf("p2 --> %#v \n ", p2) //(*int)(0xc42000e278) 
fmt.Printf("p2 point to --> %#v \n ", *p2) //0
复制代码

上面的代码是等价的，new(int) 将分配的空间初始化为 int 的零值，也就是 0，并返回 int 的指针，这和直接声明指针并初始化的效果是相同的。

make 只能用于 slice,map,channel

make 只能用于 slice，map，channel 三种类型，make(T, args) 返回的是初始化以后的 T 类型的值，这个新值并非 T 类型的零值，也不是指针 *T，是通过初始化以后的 T 的引用。

var s1 []int
if s1 == nil {
    fmt.Printf("s1 is nil --> %#v \n ", s1) // []int(nil)
}
s2 := make([]int, 3)
if s2 == nil {
    fmt.Printf("s2 is nil --> %#v \n ", s2)
} else {
    fmt.Printf("s2 is not nill --> %#v \n ", s2)// []int{0, 0, 0}
}
复制代码

slice 的零值是 nil，使用 make 以后 slice 是一个初始化的 slice，即 slice 的长度、容量、底层指向的 array 都被 make 完成初始化，此时 slice 内容被类型 int 的零值填充，形式是 [0 0 0]，map 和 channel 也是相似的。

var m1 map[int]string
if m1 == nil {
    fmt.Printf("m1 is nil --> %#v \n ", m1) //map[int]string(nil)
}
m2 := make(map[int]string)
if m2 == nil {
    fmt.Printf("m2 is nil --> %#v \n ", m2)
} else {
    fmt.Printf("m2 is not nill --> %#v \n ", m2) map[int]string{} 
}
var c1 chan string
if c1 == nil {
    fmt.Printf("c1 is nil --> %#v \n ", c1) //(chan string)(nil)
}
c2 := make(chan string)
if c2 == nil {
    fmt.Printf("c2 is nil --> %#v \n ", c2)
} else {
    fmt.Printf("c2 is not nill --> %#v \n ", c2)//(chan string)(0xc420016120)
}
复制代码

make(T, args) 返回的是 T 的 引用

若是不特殊声明，go 的函数默认都是按值穿参，即经过函数传递的参数是值的副本，在函数内部对值修改不影响值的自己，可是 make(T, args) 返回的值经过函数传递参数以后能够直接修改，即 map，slice，channel 经过函数穿参以后在函数内部修改将影响函数外部的值。

func modifySlice(s []int) {
    s[0] = 1
}
s2 := make([]int, 3)
fmt.Printf("%#v", s2) //[]int{0, 0, 0}
modifySlice(s2)
fmt.Printf("%#v", s2) //[]int{1, 0, 0}
复制代码

这说明 make(T, args) 返回的是引用类型，在函数内部能够直接更改原始值，对 map 和 channel 也是如此。

func modifyMap(m map[int]string) {
    m[0] = "string"
}
func modifyChan(c chan string) {
    c <- "string"
}
m2 := make(map[int]string)
if m2 == nil {
    fmt.Printf("m2 is nil --> %#v \n ", m2) 
} else {
    fmt.Printf("m2 is not nill --> %#v \n ", m2) //map[int]string{}
}
modifyMap(m2)
fmt.Printf("m2 is not nill --> %#v \n ", m2) // map[int]string{0:"string"}
c2 := make(chan string)
if c2 == nil {
    fmt.Printf("c2 is nil --> %#v \n ", c2)
} else {
    fmt.Printf("c2 is not nill --> %#v \n ", c2)
}
go modifyChan(c2)
fmt.Printf("c2 is not nill --> %#v ", <-c2) //"string"
复制代码

不多须要使用 new

如下代码演示了 struct 初始化的过程，能够说明不使用 new 同样能够完成 struct 的初始化工做。

type Foo struct {
    name string
    age  int
}
//声明初始化
var foo1 Foo
fmt.Printf("foo1 --> %#v\n ", foo1) //main.Foo{age:0, name:""}
foo1.age = 1
fmt.Println(foo1.age)
//struct literal 初始化
foo2 := Foo{}
fmt.Printf("foo2 --> %#v\n ", foo2) //main.Foo{age:0, name:""}
foo2.age = 2
fmt.Println(foo2.age)
//指针初始化
foo3 := &Foo{}
fmt.Printf("foo3 --> %#v\n ", foo3) //&main.Foo{age:0, name:""}
foo3.age = 3
fmt.Println(foo3.age)
//new 初始化
foo4 := new(Foo)
fmt.Printf("foo4 --> %#v\n ", foo4) //&main.Foo{age:0, name:""}
foo4.age = 4
fmt.Println(foo4.age)
//声明指针并用 new 初始化
var foo5 *Foo = new(Foo)
fmt.Printf("foo5 --> %#v\n ", foo5) //&main.Foo{age:0, name:""}
foo5.age = 5
fmt.Println(foo5.age)
复制代码

foo1 和 foo2 是一样的类型，都是 Foo 类型的值，foo1 是经过 var 声明，Foo 的 filed 自动初始化为每一个类型的零值，foo2 是经过字面量的完成初始化。

foo3，foo4 和 foo5 是同样的类型，都是 Foo 的指针 *Foo。

可是全部 foo 均可以直接使用 Foo 的 filed，读取或修改，为何？

若是 x 是可寻址的，&x 的 filed 集合包含 m，x.m 和 (&x).m 是等同的，go 自动作转换，也就是 foo1.age 和 foo3.age 调用是等价的，go 在下面自动作了转换。

于是能够直接使用 struct literal 的方式建立对象，能达到和 new 建立是同样的状况而不须要使用 new。

小结

new(T) 返回 T 的指针 *T 并指向 T 的零值。 make(T) 返回的初始化的 T，只能用于 slice，map，channel。