new 和 make 都可以用来分配空间，初始化类型，但是它们确有不同。
函数原型
- new 是内建函数，函数原型为:
func new(Type) *Type - make 也是内建函数，它的函数原型 比 new 多了一个（长度）参数，返回值也不同:
func make(Type, size IntegerType) Type
- 第一个参数是一个类型，第二个参数是长度
- 返回值是一个类型
new 函数
官方文档描述为：
The new build-in function allocates memory（仅仅分配空间）. The first argument is a type, not a value, and the value returned is a pointer to a newly allocated zero value of that type.
翻译如下：
内置函数
new分配空间。传递给new函数的是一个类型，不是一个值。返回值是 指向这个新分配的零值的指针。
new(T) 为一个 T 类型新值分配空间并将此空间初始化为 T 的零值，返回的是新值的地址，也就是 T 类型的指针 *T，该指针指向 T 的新分配的零值。
p1 := new(int)
fmt.Printf("p1 --> %#v \n ", p1)
fmt.Printf("p1 point to --> %#v \n ", *p1) //0
var p2 *int
i := 0
p2 = &i
fmt.Printf("p2 --> %#v \n ", p2)
fmt.Printf("p2 point to --> %#v \n ", *p2) //0
输出：
p1 --> (*int)(0xc000062080)
p1 point to --> 0
p2 --> (*int)(0xc0000620b0)
p2 point to --> 0
上面的代码是等价的，new(int) 将分配的空间初始化为 int 的零值，也就是 0，并返回 int 的指针，这和直接声明指针并初始化的效果是相同的。
make 函数
官方描述为：
The make built-in function allocates and initializes an object（分配空间 + 初始化）of type slice, map or chan(only). Like new , the first arguement is a type, not a value. Unlike new, make’s return type is the same as the type of its argument, not a pointer to it. The specification of the result depends on the type.
翻译为：
内建函数
make分配并且初始化 一个 slice, 或者 map 或者 chan 对象。 并且只能是这三种对象。 和new一样，第一个参数是 类型，不是一个值。 但是make的返回值就是这个类型（即使一个引用类型），而不是指针。 具体的返回值，依赖具体传入的类型。
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, 0)
if s2 == nil {
fmt.Printf("s2 is nil --> %#v \n ", s2)
} else {
fmt.Printf("s2 is not nill --> %#v \n ", s2)// []int{}
}
s3 := make([]int, 3)
if s3 == nil {
fmt.Printf("s3 is nil --> %#v \n ", s3)
} else {
fmt.Printf("s3 is not nill --> %#v \n ", s3)// []int{0, 0, 0}
}
输出
s1 is nil --> []int(nil)
s2 is not nill --> []int{}
s3 is not nill --> []int{0, 0, 0}
slice 的零值是 nil，使用 make 之后 slice 是一个初始化的 slice，即 slice 的长度、容量、底层指向的 array 都被 make 完成初始化，此时 slice 内容被类型 int 的零值填充，形式是 [0 0 0]，map 和 channel 也是类似的。
var m1 = new(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{}
}
输出：
m1 is nil --> &map[int]string(nil)
m2 is not nill --> map[int]string{}
make 参数说明
Slice : 第二个参数 size 指定了它的长度，此时它的容量和长度相同。
你可以传入第三个参数 来指定不同的容量值，但是必须不能比长度值小。
比如: make([]int, 0, 10)
Map: 根据size 大小来初始化分配内存，不过分配后的 map 长度为0。 如果 size 被忽略了，那么会在初始化分配内存的时候 分配一个小尺寸的内存。
Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者被 忽略，管道是没有缓冲区的。
make(T, args) 返回的是 T 的 引用
如果不特殊声明，go 的函数默认都是按值穿参，即通过函数传递的参数是值的副本，在函数内部对值修改不影响值的本身，但是 make(T, args) 返回的值通过函数传递参数之后可以直接修改，即 map，slice，channel 通过函数穿参之后在函数内部修改将影响函数外部的值。
func modifySlice(s []int) {
s[0] = 1
}
func main() {
s2 := make([]int, 3)
fmt.Println( s2) //[]int{0, 0, 0}
modifySlice(s2)
fmt.Println( s2) //[]int{1, 0, 0}
}
输出：
[0 0 0]
[1 0 0]
很少需要使用 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 --> main.Foo{name:"", age:0}
1
foo2 --> main.Foo{name:"", age:0}
2
foo3 --> &main.Foo{name:"", age:0}
3
foo4 --> &main.Foo{name:"", age:0}
4
foo5 --> &main.Foo{name:"", age:0}
5
如果 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。
声明：sunansheng 发表于 2019-04-25 10:04:00 ，共计878字。