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蜻底，是經(jīng)過初始化之后的 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 內(nèi)容被類型 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 的函數(shù)默認都是按值穿參，即通過函數(shù)傳遞的參數(shù)是值的副本谁尸，在函數(shù)內(nèi)部對值修改不影響值的本身舅踪，但是 make(T, args) 返回的值通過函數(shù)傳遞參數(shù)之后可以直接修改，即 map良蛮，slice抽碌，channel 通過函數(shù)穿參之后在函數(shù)內(nèi)部修改將影響函數(shù)外部的值。
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) 返回的是引用類型，在函數(shù)內(nèi)部可以直接更改原始值货徙，對 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
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)
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)
foo4 := new(Foo)
fmt.Printf("foo4 --> %#v\n ", foo4) //&main.Foo{age:0, name:""}
foo4.age = 4
fmt.Println(foo4.age)
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 聲明赏迟，F(xiàn)oo 的 filed 自動初始化為每個類型的零值，foo2 是通過字面量的完成初始化蠢棱。
foo3锌杀，foo4 和 foo5 是一樣的類型，都是 Foo 的指針 *Foo泻仙。
但是所有 foo 都可以直接使用 Foo 的 filed糕再，讀取或修改，為什么玉转？
如果 x 是可尋址的突想，&x 的 filed 集合包含 m，x.m 和 (&x).m 是等同的究抓，go 自動做轉(zhuǎn)換蒿柳，也就是 foo1.age 和 foo3.age 調(diào)用是等價的，go 在下面自動做了轉(zhuǎn)換漩蟆。
因而可以直接使用 struct literal 的方式創(chuàng)建對象，能達到和 new 創(chuàng)建是一樣的效果而不需要再使用 new妓蛮。
小結(jié)
new(T) 返回 T 的指針 *T 并指向 T 的零值怠李，make(T) 返回的初始化的 T，只能用于 slice蛤克，map捺癞，channel。
