理解GO语言make 和 new 的区别

Posted 2022-08-01 sunansheng

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了理解GO语言make 和 new 的区别相关的知识，希望对你有一定的参考价值。

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)// []int0, 0, 0
    

输出
 s1 is nil --> []int(nil) 
 s2 is not nill --> []int 
 s3 is not nill --> []int0, 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) //[]int0, 0, 0
    modifySlice(s2)
    fmt.Println( s2) //[]int1, 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.Fooage:0, name:""
foo1.age = 1
fmt.Println(foo1.age)

//struct literal 初始化
foo2 := Foo
fmt.Printf("foo2 --> %#v\\n ", foo2) //main.Fooage:0, name:""
foo2.age = 2
fmt.Println(foo2.age)

//指针初始化
foo3 := &Foo
fmt.Printf("foo3 --> %#v\\n ", foo3) //&main.Fooage:0, name:""
foo3.age = 3
fmt.Println(foo3.age)

//new 初始化
foo4 := new(Foo)
fmt.Printf("foo4 --> %#v\\n ", foo4) //&main.Fooage:0, name:""
foo4.age = 4
fmt.Println(foo4.age)

//声明指针并用 new 初始化
var foo5 *Foo = new(Foo)
fmt.Printf("foo5 --> %#v\\n ", foo5) //&main.Fooage:0, name:""
foo5.age = 5
fmt.Println(foo5.age)

输出
foo1 --> main.Fooname:"", age:0
 1
foo2 --> main.Fooname:"", age:0
 2
foo3 --> &main.Fooname:"", age:0
 3
foo4 --> &main.Fooname:"", age:0
 4
foo5 --> &main.Fooname:"", age:0
 5

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

因而可以直接使用 struct literal 的方式创建对象，能达到和 new 创建是一样的情况而不需要使用 new。