本文主要是介绍Golan中 new() 、 make() 和简短声明符的区别和使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
《Golan中new()、make()和简短声明符的区别和使用》Go语言中的new()、make()和简短声明符的区别和使用,new()用于分配内存并返回指针,make()用于初始化切片、映射...
详细介绍golang的new() 、 make() 和简短声明符的区别和使用。
文章目录 `new()` 函数`make()` 函数对于不同类型的说明 简短声明 `:=``new()`、`make()` 和 `:=` 的比较总结补充普通变量声明并后续初始化初始化切片初始化映射初始化通道
在 Go 语言中， new() 和 make() 都是用来分配内存的内建函数，但是有很大区别。
new() 函数
new() 函数用于 分配内存并返回一个指向类型的指针。它会根据类型分配零值并返回该类型的地址。
源码：
// The new built-in function allocates memory. The firstandroid argument is a type, // not a value, and the value returned is a pointer to a newly // allocated zero value of that type. func new(Type) *Type
Type：可以是任何类型（包括基础类型、结构体、数组等）。
返回值：
new()返回一个指向类型的指针。该类型的值会被初始化为其 零值（例如，整数为 0，布尔值为false，指针为nil，字符串为空字符串等）。
示例：
package main
import "fmt"
func main() {
// 使用 new 创建一个 int 类型的指针
p := new(int)
// new 返回的是指向 int 的指针，指针的初始值是零值，即 0
fmt.Println(*p) // 输出: 0
*p = 42 // 修改 p 指向的值
fmt.Println(*p) // 输出: 42
}make() 函数
make() 函数用于 初始化切片（slice）、映射（map）和通道（channel），并返回一个已经初始化的（且可以使用的）对象。
make()的android作用不仅仅是分配内存，它还会 初始化数据结构的内部状态（比如切片的长度、容量，映射的哈希表等）。make()只能用于 切片、映射和通道，而不能用于其他类型（比如结构体或数组）。
源码：
// The make built-in function allocates and initializes an object of type // slice, map, or chan (only). Like new, the first argument 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: // // Slice: The size specifies the length. The capacity of the slice is // equal to its length. A second integer argument may be provided to // specify a different capacity; it must be no smaller than the // length. For example, make([]int, 0, 10) allocates an underlying array // of size 10 and returns a slice of length 0 and capacity 10 that is // backe编程d by this underlying array. // Map: An empty map is allocated with enough space to hold the // specified number of elements. The size may be omitted, in which case // a small starting size is allocated. // Channel: The channel's buffer is initializeAGuvkzkGuLd with the specified // buffer capacity. If zero, or the size is omitted, the channel is // unbuffered. func make(t Type, size ...IntegerType) Type
Type：要创建的类型，可以是slice、map或channel。size：对于切片和通道，这是它的长度；对于映射，这是它的初始大小（内部哈希表的大小）。capacity：对于切片，这个参数是可选的，用来指定切片的容量。如果不指定容量，容量将等于长度。Map和Channel没有这个参数。
对于不同类型的说明
切片（Slice）：
- 长度：
size参数指定切片的长度，必传。 - 容量：可选参数，切片的容量等于它的长度。如果指定了第二个参数
capacity，则表示切片的容量。capacity必须大于或等于size。
为了避免意外修改原切片数据，可以通过切片的第三个索引限制容量，从而在扩容时强制触发新底层数组的创建。
映射（Map）：
size参数可选。make 为映射分配内存，并根据指定的 元素数量 初始化映射。可以提供一个整数参数来指定映射的初始容量。如果没有指定容量，Go 会为映射分配一个小的默认容量。
通道（Channel）：
size参数可选。make用于创建一个 带缓冲区的通道，size参数指定通道的 缓冲区容量。- 如果没有指定
size或指定为0，则创建一个 无缓冲通道，即通道会阻塞直到接收方接收数据。
同时，在使用 len() 和 cap() 时候注意：
- 切片（slice）：
len返回元素的数量，cap返回底层数组的容量。 - 映射（map）：
len返回键值对的数量，但没有cap函数。 - 通道（channel）：
len返回通道中的元素数量，cap返回通道的缓冲区容量。
返回值：
make()返回的是已经初始化的对象（切片、映射或通道本身），并且可以直接使用。
示例：
package main
import "fmt"
func main() {
// 创建一个长度为 5 的整数切片
slice := make([]int, 5)
fmt.Println(slice) // 输出: [0 0 0 0 0]
// 创建一个长度为 3，容量为 5 的切片
slice2 := make([]int, 3, 5)
fmt.Println(slice2) // 输出: [0 0 0]
// 创建一个容量为 10 的整数通道
ch := make(chan int, 10)
ch <- 42 // 向通道中发送数据
fmt.Println(<-ch) // 输出: 42
// 创建一个具有初始大小的映射
m := make(map[string]int)
m["key"] = 10
fmt.Println(m) // 输出: map[key:10]
}简短声明 :=
- 使用 Go 中的简短声明符
:=时，可以同时声明和初始化这些类型。不需要手动声明变量类型javascript，Go 会自动推导出变量的类型，并给它赋予一个初始值。 :=可以与 make() 和 new() 结合使用，简化变量声明和初始化过程，上面make()和new()的示例中已有展示结合使用，当然也可以不与make()和new()结合使用。如下，直接进行变量声明。
示例：
package main
import "fmt"
func main() {
// 使用 := 创建并初始化一个 map
m := map[string]int{
"apple": 5,
"banana": 3,
"orange": 2,
}
// 输出 map 中的元素
fmt.Println(m) // 输出: map[apple:5 banana:3 orange:2]
}这里，p := 0 创建了一个类型为 int 的变量 p，并将其初始化为 0，而不是指向 0 的指针。p 本身是一个值，而不是一个指针。
new()、make() 和 := 的比较
| 特性 | new() | make() | := |
|---|---|---|---|
| 用法 | 用于任何类型（包括基础类型、结构体、数组等） | 仅用于 slice、map 和 channel 类型 | 用于声明变量并初始化为零值或指定值 |
| 返回值 | 返回类型的指针，指向零值 | 返回初始化后的对象，已经可以使用 | 返回值，而非指针 |
| 初始化内容 | 只会分配内存并初始化为零值 | 根据类型进行初始化（例如，初始化切片的长度和容量，初始化映射的哈希表） | 直接创建变量并赋初值（默认为零值） |
| 支持类型 | 所有类型 | slice、map、channel | 所有类型（包括切片、映射、通道、基础类型） |
| 返回类型 | 类型的指针（例如 *int，*struct 等） | 对象本身（例如切片、映射、通道） | 变量本身（值类型或引用类型） |
| 内存分配 | 分配零值内存并返回指针 | 分配并初始化内存，返回已初始化的对象 | 分配并初始化变量 |
| 适用场景 | 创建指向零值的指针，通常用于结构体或基本类型 | 用于切片、映射、通道的内存分配和初始化 | 用于直接创建并初始化变量，不涉及指针 |
总结
new()用于为任意类型分配内存并返回该类型的指针，默认值为零值。make()用于初始化切片、映射和通道，并返回已初始化的对象。它不仅分配内存，还为这些类型做了额外的初始化工作。:=可以 make() 和 new() 结合使用，简化变量声明和初始化过程。
补充
上面主要讲的是 new() 、 make() 函数的区别，也讲了一点简短声明符 := （这算Go所特有的）。当然，也可以进行不使用new() 、 make() 和 := ，而是使用var先声明，再进行初始化（slice，map，channle必须初始化，不能直接赋值，声明后未初始化会导致 panic）。
- 使用
var声明时，slice、map和channel的零值是nil，它们必须经过初始化才能使用。 - 初始化方法：
- 使用
make()：最常见的初始化方式，适用于slice、map和channel。 - 使用字面量语法（s := []int{1, 2, 3} // 切片字面量）：对于
slice和map，可以使用字面量语法进行初始化。
- 使用
- 未初始化的
nil类型不能直接使用，否则会导致panic。
普通变量声明并后续初始化
package main
import "fmt"
func main() {
var x int // 声明一个变量 x，类型是 int，零值是 0
fmt.Println(x) // 输出 0
// 后续赋值
x = 10
fmt.Println(x) // 输出 10
}初始化切片
package main
import "fmt"
func main() {
var s []int // 声明一个切片，零值是 nil
fmt.Println(s) // 输出: []
// 后续使用 append 或其他方式进行初始化
s = append(s, 1, 2, 3)
fmt.Println(s) // 输出: [1 2 3]
}初始化映射
package main
import "fmt"
func main() {
var m map[string]int // 声明一个映射，零值是 nil
fmt.Println(m) // 输出: map[]
// 后续初始化映射
m = make(map[string]int)
m["apple"] = 5
m["banana"] = 3
fmt.Println(m) // 输出: map[apple:5 banana:3]
}初始化通道
package main
import "fmt"
func main() {
var ch chan int // 声明一个通道，零值是 nil
fmt.Println(ch) // 输出: <nil>
// 后续初始化通道
ch = make(chan int, 3)
ch <- 1
fmt.Println(<-ch) // 输出: 1
}到此这篇关于Golan中 new() 、 make() 和简短声明符的文章就介绍到这了,更多相关go new()和make()声明符内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！
这篇关于Golan中 new() 、 make() 和简短声明符的区别和使用的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
