首页>内容详情

Go语言中make和new有什么区别？

大熊•2023-08-18 23:39:35•

分配内存 - new

官方定义：new是一个分配内存的内置函数，第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。

func new(Type) *Type

我们平常在使用指针的时候是需要分配内存空间的，未分配内存空间的指针直接使用会使程序崩溃，比如这样：


var a *int64
*a = 10

我们声明了一个指针变量，直接就去使用它，就会使用程序触发panic，因为现在这个指针变量a在内存中没有块地址属于它，就无法直接使用该指针变量，所以new函数的作用就出现了，通过new来分配一下内存，就没有问题了：

var a *int64 = new(int64)
*a = 10

上面的例子，我们是针对普通类型int64进行new处理的，如果是复合类型，使用new会是什么样呢？来看一个示例：

func main() {
   // 数组
   array := new([5]int64)
   fmt.Printf("array: %p %#v \n", &array, array) // array: 0xc0000ae018 &[5]int64{0, 0, 0, 0, 0}
   (*array)[0] = 1
   fmt.Printf("array: %p %#v \n", &array, array) // array: 0xc0000ae018 &[5]int64{1, 0, 0, 0, 0}

   // 切片
   slice := new([]int64)
   fmt.Printf("slice: %p %#v \n", &slice, slice) // slice: 0xc0000ae028 &[]int64(nil)
   (*slice)[0] = 1
   fmt.Printf("slice: %p %#v \n", &slice, slice) // panic: runtime error: index out of range [0] with length 0

   // map
   map1 := new(map[string]string)
   fmt.Printf("map1: %p %#v \n", &map1, map1) // map1: 0xc00000e038 &map[string]string(nil)
   (*map1)["key"] = "value"
   fmt.Printf("map1: %p %#v \n", &map1, map1) // panic: assignment to entry in nil map

   // channel
   channel := new(chan string)
   fmt.Printf("channel: %p %#v \n", &channel, channel) // channel: 0xc0000ae028 (*chan string)(0xc0000ae030)
   channel <- "123"                                    // Invalid operation: channel <- "123" (send to non-chan type *chan string)
}

从运行结果可以看出，我们使用new函数分配内存后，只有数组在初始化后可以直接使用，slice、map、chan初始化后还是不能使用，会触发panic，这是因为slice、map、chan基本数据结构是一个struct，也就是说他里面的成员变量仍未进行初始化，所以他们初始化要使用make来进行，make会初始化他们的内部结构，我们下面一节细说。还是回到struct初始化的问题上，先看一个例子：

type test struct {
   A *int64
}

func main() {
   t := new(test)
   *t.A = 10 // panic: runtime error: invalid memory address or nil pointer dereference
   // [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x10a89fd]
   fmt.Println(t.A)
}

从运行结果得出使用new()函数初始化结构体时，我们只是初始化了struct这个类型的，而它的成员变量是没有初始化的，所以初始化结构体不建议使用new函数，使用键值对进行初始化效果更佳。

其实 new 函数在日常工程代码中是比较少见的，因为它是可以被代替，使用T{}方式更加便捷方便。

初始化内置结构 - make

在上一节我们说到了，make函数是专门支持 slice、map、channel 三种数据类型的内存创建，其官方定义如下：

func make(t Type, size ...IntegerType) Type

大概翻译最上面一段：make内置函数分配并初始化一个slice、map或chan类型的对象。像new函数一样，第一个参数是类型，而不是值。与new不同，make的返回类型与其参数的类型相同，而不是指向它的指针。结果的取决于传入的类型。

不同的类型初始化可以使用不同的姿势，主要区别主要是长度（len）和容量（cap）的指定，有的类型是没有容量这一说法，因此自然也就无法指定。如果确定长度和容量大小，能很好节省内存空间。

func main(){
    slice := make([]int64, 3, 5)
    fmt.Println(slice) // [0 0 0]
    map1 := make(map[int64]bool, 5)
    fmt.Println(map1) // map[]
    channel := make(chan int, 1)
    fmt.Println(channel) // 0xc000066070
}

这里有一个需要注意的点，就是slice在进行初始化时，默认会给零值，在开发中要注意这个问题，我就犯过这个错误，导致数据不一致。

new和make区别总结

new函数主要是为类型申请一片内存空间，返回执行内存的指针
make函数能够分配并初始化类型所需的内存空间和结构，返回复合类型的本身。
make函数仅支持channel、map、slice 三种类型，其他类型不可以使用使用make。
new函数在日常开发中使用是比较少的，可以被替代。
make函数初始化slice会初始化零值，日常开发要注意这个问题。

二者都在堆上分配内存，但是它们的行为不同，适用于不同的类型。

new(T) 为每个新的类型T分配一片内存，初始化为 0 并且返回类型为*T的内存地址：这种方法返回一个指向类型为 T，值为 0 的地址的指针，它适用于值类型如数组和结构体；它相当于 &T{}。
make(T) 返回一个类型为 T 的初始值，它只适用于3种内建的引用类型：切片、map 和 channel

换言之，new 函数分配内存，make 函数初始化。

我的理解，new返回一个变量的指针，但是这个指针指向空，你不可以直接对该指针进行操作，否则会报错，除非你将该指针指向一个该类型变量的地址。 make返回一个该类型的变量，以切片变量为例，上面提到，make适用于创建切片、map和channel,但new也可以创建。

new与make函数初始化

先看个图来直观区分下二者区别

通过下面代码，可以看出来new 和 make创建变量时的差别

package main

import "fmt"

func main() {
   //使用make创建切片，返回的是变量本身
   s1 := make([]int, 5, 10)
   fmt.Printf("use make create slise type %T value %v \n", s1, s1) //use make create slise type []int value [0 0 0 0 0]
   s1[0] = 123
   s1[4] = 321
   fmt.Printf("make s1 type %T value %v \n", s1, s1) //make s1 type []int value [123 0 0 0 321]

   //# 使用new 创建切片,返回的是切片变量的指针
   s2 := new([]int)
   fmt.Printf("use new create slise type %T value %v \n", s2, s2) //use new create slise type *[]int value &[]
   fmt.Printf("new s2 type %T value %v \n", *s2, *s2)             //new s2 type []int value []

   // 想要赋值的话需要使用*解引用
   // 这里虽然不报语法错误，但是如果尝试直接使用(*s2)[0] = 123的话会有运行时错误， 【并没有给给结构体内容赋空间】
   // panic: runtime error: index out of range

   s2 = &s1 //需要将变量指针指向一个该类型变量的地址
   (*s2)[0] = 123
   (*s2)[4] = 3211
   fmt.Printf("new s2 type %T value %v \n", s2, s2) //new s2 type *[]int value &[123 0 0 0 3211]
   //s2的修改也会影响s1
   fmt.Printf("s1 type %T value %v \n", s1, s1) //s1 type []int value [123 0 0 0 3211]

   m1 := make(map[string]string)
   m1["name"] = "yangyanxing"
   m1["age"] = "30"
   fmt.Printf("m1 use make create type:%T value %v \n", m1, m1) //m1 use make create type:map[string]string value map[age:30 name:yangyanxing]

   m2 := new(map[string]string)
   fmt.Printf("m2 use new create type:%T value %v \n", m2, m2) //m2 use new create type:*map[string]string value &map[]
   //直接赋值会报 panic: assignment to entry in nil map

   m2 = &m1
   (*m2)["name"] = "fan"
   //对m2的修改也会影响到m1
   fmt.Printf("after m2 change m1 value is %v", m1) //after m2 change m1 value is map[age:30 name:fan]
}

map的初始化

map有以下两种初始化方法

使用make函数
直接使用map初始化

package main

import "fmt"

func main() {
   //使用make初始化map
   mp2 := make(map[string]string)
   mp2["name"] = "yangyanxing"
   mp2["age"] = "18"
   fmt.Println("m2 address ", &mp2)

   // out:m2 address  &map[name:yangyanxing age:18]
   mp3 := map[string]int{} //这里要有{},花括号里如果没有内容则说明初始化了一个空字典
   mp3["yang"] = 18
   mp3["fan"] = 20
   fmt.Println(mp3)
   //out:map[yang:18 fan:20]

   mp4 := map[string]int{
      "yang": 20,
      "fan":  21, //即使是最后一个也要有逗号
   }
   fmt.Println(mp4)
   //out:map[yang:20 fan:21]
   mp5 := map[string]int{"yang": 30} //写在同一行则不用加逗号
   fmt.Println(mp5)
   //out: map[yang:30]

   mp6 := make(map[string]int, 1) //还可以给map加一个容量
   mp6["yang"] = 30
   fmt.Println("mp6 lens is ", len(mp6), "address:", &mp6)
   //out:mp6 lens is  1 address: &map[yang:30]

   mp6["fan"] = 31
   fmt.Println("mp6 lens is ", len(mp6), "address:", &mp6)
   //out:mp6 lens is  2 address: &map[yang:30 fan:31]
   //也可以使用new,但是不可以直接对其进行赋值,因为此时它返回的是一个空指针
   //需要指向一个该类型的变量地址以后才可以进行操作

   mp7 := new(map[string]int)
   fmt.Println(mp7)
   //out:&map[]
   //(*mp7)["yang"] = 100 //会报运行时错误
   mp7 = &mp6
   //mp7["fan"] = 1000 //也不可以直接使用mp7,需要使用* 先解引用
   (*mp7)["yang"] = 100 //这时就不会报运行时错误
   fmt.Println(mp7)
   //out:&map[yang:100 fan:31]
}

slice切片的初始化

同样可以通过make和切片本身进行初始化

package main

import "fmt"

func main() {
   //使用make初始化切片,需要传一个len长度,容量cap为可选
   //如果不传的话则长度和容量相同
   sls1 := make([]int, 5, 10)
   sls1[0] = 100
   //append 追加到尾部,这里有点意思
   sls1 = append(sls1, 200)
   // ... 三个点,go里的语法糖,展开前面的切片
   sls1 = append(sls1, []int{30, 40}...)
   fmt.Println(sls1, len(sls1), cap(sls1))
   //out: [100 0 0 0 0 200 30 40] 8 10
   sls1 = append(sls1, 3, 4, 6) //超过切片原有容量以后将会发生扩容
   fmt.Println(sls1, len(sls1), cap(sls1))
   //out: [100 0 0 0 0 200 30 40 3 4 6] 11 20
   sls2 := make([]int, 3)
   sls2[1] = 123
   fmt.Println(sls2, len(sls2), cap(sls2))
   //out: [0 123 0] 3 3
   //直接初始化
   sls3 := []int{}
   sls3 = append(sls3, 10, 20)
   fmt.Println(sls3, len(sls3), cap(sls3))
   //out: [10 20] 2 2
   sls4 := []int{1, 2, 3}
   sls5 := []int{
      1,
      2,
      5, //这里的逗号不能省
   }
   fmt.Println(sls4, sls5)
   //out: [1 2 3] [1 2 5]
   //使用new创建切片,和map一样,返回的也是指针,不能直接对其进行操作
   //需要先指向一个变量的地址
   sls6 := new([]int)
   fmt.Println(sls6) //out: &[]
   sls6 = &sls4
   fmt.Println(sls6) //out: &[1 2 3]

}

array数组的初始化

数组不能使用make初始化,但是可以使用new初始化

package main

import "fmt"

type person struct {
   name string
   age  int
}

func main() {
   fmt.Println("数组的初始化")
   //声明并初始化一个空数组,里面的元素值为类型的零值
   arr1 := [2]int{}
   fmt.Println(arr1) //out: [0 0]
   //初始化时将元素值写上
   arr2 := [2]int{1, 3}
   fmt.Println(arr2) //out: [1 3]
   //只写一个,不写的是零值
   arr3 := [2]int{1}
   fmt.Println(arr3) //out: [1 0]
   //arr4 := make([2]int) //数组不能使用make
   var arr5 [2]int
   arr5[0] = 100
   fmt.Println(arr5) //[100 0]
   //不指定数组大小,使用... 三点号让其自动展开计算
   arr6 := [...]int{2, 4, 6, 8}
   fmt.Println(arr6, len(arr6)) //out: [2 4 6 8] 4
   //使用new创建一个数组,得到的是一个指针
   arr7 := new([3]int)
   fmt.Println(arr7) //out: &[0 0 0]
   //可以直接对指针进行操作
   arr7[0] = 3
   //和使用*解引用作用一样
   (*arr7)[1] = 4
   fmt.Println(arr7) //out: &[3 4 0]
}

struct结构体的初始化

package main

import "fmt"

type person struct {
   name string
   age  int
}

func main() {
   fmt.Println("结构体的初始化")
   //使用new,返回结构体指针
   stru1 := new(person)
   fmt.Println(stru1) //out &{ 0} ,默认是字段的零值
   //可以直接使用这个指针来操作变量
   //和使用*解引用效果一样
   stru1.name = "yangyanxing"
   (*stru1).age = 18
   fmt.Println(stru1, *stru1) //&{yangyanxing 18} {yangyanxing 18}
   //只指定一个字段,没有指定的默认零值
   stru2 := person{name: "fan"}
   fmt.Println(stru2) //{fan 0}
   //全部指定,字段的顺序可以不按照定义时的顺序
   stru3 := person{age: 18, name: "yang"}
   fmt.Println(stru3) //{yang 18}
   //按照结构体顺序初始化,这时元素的值必须都写全了
   stru4 := person{"fan", 17}
   fmt.Println(stru4) //{fan 17}
}

为什么我们不能对任何事物都使用 make ？

看下面获得结构体的指针方法

s := &SomeStruct{}
v := SomeStruct{}
s := &v              // 相同
s := new(SomeStruct) // 也相同

由于 make 旨在创建这三种内置泛型类型，因此必须由运行时提供，因为无法在 Go 中直接表达 make 的功能签名。

尽管 make 创建了泛型切片，映射和通道值，但它们仍然只是常规值；make 不返回指针值。

如果为有利于 make 而删除 new，您将如何构造指向初始值的指针？

var x1 *int
var x2 = new(int)

x1 和 x2 具有相同的类型，*int，x2 指向初始化的内存，并且可以安全地取消引用，相同的是对于 x1 都不为 true。

为什么我们不能对任何事物都使用 new ？

尽管 new 很少使用，但其行为已经被很好地指定了。

new(T) 始终返回一个 * T 指向已初始化的 T。由于Go没有构造函数，因此该值将被初始化为 T 的零值。

使用 new 构造指向 slice，map 或 channel 的指针，目前可以使用并且与 new 的行为一致。

s := new([]string)
fmt.Println(len(*s))  // 0
fmt.Println(*s == nil) // true

m := new(map[string]int)
fmt.Println(m == nil) // false
fmt.Println(*m == nil) // true

c := new(chan int)
fmt.Println(c == nil) // false
fmt.Println(*c == nil) // true

Go中使用new创建对象和直接字面量创建对象的区别

使用new创建对象返回对象指针，而直接使用字面量创建对象返回对象本身。

package main

import "fmt"

type person struct {
   name string
   age  int
}

func main() {
   s1 := person{
      name: "xm",
      age:  11,
   }
   s2 := new(person)
   s2.name = "xh"
   s2.age = 12
   fmt.Printf("%T", s1)      // main.stu
   fmt.Printf("%s", s1.name) // xm
   fmt.Printf("%T", s2)      // *main.stu
   fmt.Printf("%s", s2.name) // xh

}

其他

本本参考

https://asong.cloud/make%E5%92%8Cnew%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB/

https://learnku.com/go/t/47215

上一篇：Go程序基础-高级数据结构

下一篇：Go语言几种标准库介绍