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字。