new和make都可以用来分配空间和初始化类型，但是它们又有一些不同。
1. new(T)返回的是T的指针
new(T)为一个T类型新值分配空间并将此空间初始化为T的零值，返回的是新值的地址，也就是T类型的指针*T，该指针指向T的新分配的零值：
p1 := new(int)
fmt.Printf("%#v \n", p1) // print (*int)(0xc042060080)
fmt.Printf("%#v \n", *p1) // print 0
var p2 *int
fmt.Printf("%#v \n", p2) // print (*int)(nil)
i := 0
p2 = &i
fmt.Printf("%#v \n", p2) // print (*int)(0xc0420600a0)
fmt.Printf("%#v \n", *p2) // print 0上面这两部分的代码是等价的，new(int)将分配的空间初始化为int的零值，也就是0，并返回int的指针，这和直接声明指针并初始化的效果是相同的。
2. make只能用于slice, map, channel
make只能用于slice，map和channel三种类型，make(T, args)返回的是初始化之后的T类型的值，这个新值并不是T类型的零值，也不是指针*T，是经过初始化之后的T的引用：
var s1 []int
fmt.Printf("%#v \n", s1) // print []int(nil)
s2 := make([]int, 3)
fmt.Printf("%#v \n", s2) // print []int{0, 0, 0}slice的零值是nil，使用make之后slice是一个初始化的slice，即slice的长度、容量和底层指向的array都被make完成初始化，此时slice内容被类型int的零值填充，形式是[0,0,0]，map和channel也是类似的：
var m1 map[int]string
fmt.Printf("%#v \n", m1) // print map[int]string(nil)
m2 := make(map[int]string)
fmt.Printf("%#v \n", m2) // print map[int]string{}
var c1 chan string
fmt.Printf("%#v \n", c1) // print (chan string)(nil)
c2 := make(chan string)
fmt.Printf("%#v \n", c2) // print (chan string)(0xc0420520c0)3. make(T, args)返回的是T的引用
如果不特殊声明，go的函数默认都是按值传参，即通过函数传递的参数是值的副本，在函数内部对值修改不影响值的本身，但是make(T, args)返回的值通过函数传递参数之后可以直接修改，即map，slice，channel通过函数传参之后再函数内部修改影响函数外部的值：
func modifySlice(s []int) {
s[0] = 1
}
s3 := make([]int, 3)
fmt.Printf("%#v \n", s3) // print []int{0, 0, 0}
modifySlice(s3)
fmt.Printf("%#v \n", s3) // print []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"
}
m3 := make(map[int]string)
fmt.Printf("%#v \n", m3) // print map[int]string{}
modifyMap(m3)
fmt.Printf("%#v \n", m3) // print map[int]string{0:"string"}
c3 := make(chan string)
go modifyChan(c3)
fmt.Printf("%#v \n", <- c3) // print "string"4. 初始化struct的五种方式
下面的代码演示了初始化struct的物种方式，说明不使用new一样也可以完成struct的初始化操作：
type Foo struct {
name string
age int
}
// 1、声明初始化
var foo1 Foo
fmt.Printf("%#v \n", foo1) // print main.Foo{name:"", age:0}
foo1.age = 1
fmt.Printf("%#v \n", foo1) // print main.Foo{name:"", age:1}
// 2、字面值初始化
foo2 := Foo{}
fmt.Printf("%#v \n", foo2) // print main.Foo{name:"", age:0}
foo2.age = 2
fmt.Printf("%#v \n", foo2) // print main.Foo{name:"", age:2}
// 3、 指针初始化
foo3 := &Foo{}
fmt.Printf("%#v \n", foo3) // print &main.Foo{name:"", age:0}
foo3.age = 3
fmt.Printf("%#v \n", foo3) // print &main.Foo{name:"", age:3}
// 4、new初始化
foo4 := new(Foo)
fmt.Printf("%#v \n", foo4) // print &main.Foo{name:"", age:0}
foo4.age = 4
fmt.Printf("%#v \n", foo4) // print &main.Foo{name:"", age:4}
// 5、声明指针并用new初始化
var foo5 *Foo = new(Foo)
fmt.Printf("%#v \n", foo5) // print &main.Foo{name:"", age:0}
foo5.age = 5
fmt.Printf("%#v \n", foo5) // print &main.Foo{name:"", age:5}其中，foo1和foo2类型相同，都是Foo类型的值，foo1是通过var声明，Foo的字段自动初始化为每个类型的零值，而foo2是通过字面量完成的初始化。
foo3，foo4和foo5类型都是*Foo，即Foo的指针。由于go可以自动转换指针类型与可寻址类型，所以他们具有相同的效果。
