En langage Go, new et make sont deux fonctions intégrées permettant de créer des objets. Bien qu'ils soient tous deux utilisés pour allouer de la mémoire, il existe des différences importantes dans leur utilisation. Cet article présentera en détail la différence entre new et make, et vous aidera à comprendre leurs scénarios d'utilisation à travers divers aspects de l'analyse et des exemples de code.
1. Introduction
Dans le langage Go, new et make sont deux fonctions intégrées utilisées pour créer des objets, et elles sont utilisées de différentes manières et fonctions. Une bonne compréhension de la différence entre new et make est très importante pour écrire un code Go efficace. Ci-dessous, nous passons en revue les spécificités de new et make.
2. nouvelle fonction
2.1 Le rôle de la nouvelle fonction
La nouvelle fonction est utilisée pour créer un pointeur d'un type spécifié et l'initialiser à une valeur zéro. Il renvoie un pointeur vers l'adresse mémoire nouvellement allouée.
2.2 Syntaxe de la nouvelle fonction
La syntaxe de la nouvelle fonction est très simple, il suffit de suivre le mot-clé new avec le type.
func new(Type) *Type
复制代码Voici un exemple de code qui utilise la nouvelle fonction pour créer un objet de structure :
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p := new(Person)
fmt.Println(p)
}
复制代码Dans le code ci-dessus, nous utilisons la nouvelle fonction pour créer un pointeur p pointant vers le type Person et afficher sa valeur. Le résultat est &{0}, indiquant que p est un pointeur vers la valeur zéro du type Person.
3. faire fonctionner
3.1 La fonction de la fonction make
La fonction make est utilisée pour créer des objets de types intégrés tels que des tranches, des cartes et des canaux, et elle renvoie un objet initialisé (valeur non nulle).
3.2 Syntaxe de la fonction make
La syntaxe de la fonction make est différente de la nouvelle fonction, elle doit spécifier le type et quelques paramètres supplémentaires.
func make(Type, size IntegerType) Type
复制代码Voici un exemple de code qui utilise la fonction make pour créer des tranches, des cartes et des canaux :
package main
import "fmt"
func main() {
// 创建一个长度为5，容量为10的整型切片
s := make([]int, 5, 10)
fmt.Println(s)
// 创建一个键为string，值为int的映射
m := make(map[string]int)
m["a"] = 1
m["b"] = 2
fmt.Println(m)
// 创建一个字符串通道
c := make(chan string)
fmt.Println(c)
}
复制代码Dans le code ci-dessus, nous utilisons la fonction make pour créer une tranche entière s avec une longueur de 5 et une capacité de 10, une carte m avec une clé de chaîne et une valeur de int, et un canal de chaîne c. Les résultats courants sont [0 0 0 0 0], map[a:1 b:2] et 0xc0000460c0 respectivement, indiquant que ces objets sont tous initialisés à des valeurs non nulles.
4. Différence et comparaison
4.1 Types de missions
- La nouvelle fonction est utilisée pour l'allocation de n'importe quel type et renvoie un pointeur vers ce type.
- make 函数只用于分配切片、映射和通道，并返回初始化后的切片、映射或通道对象。
4.2 返回值类型
- new 函数返回指向分配类型的指针。
- make 返回分配类型的初始化后的非零值。
4.3 使用场景
-
new 函数主要用于创建值类型的实例。值类型包括基本类型（如整型、浮点型、布尔型等）以及结构体。new 函数返回一个指向新分配内存的指针，可以方便地对该实例进行操作和修改。
package main import "fmt" type Point struct { X, Y int } func main() { p := new(Point) p.X = 10 p.Y = 20 fmt.Println(p) // 输出：&{10 20} } 复制代码
-
make 函数主要用于创建引用类型的对象。引用类型包括切片、映射和通道。由于引用类型需要在使用之前进行初始化，make 函数返回的是初始化后的非零值对象，而不是指针。
package main import "fmt" func main() { // 创建一个长度为5，容量为10的整型切片 s := make([]int, 5, 10) fmt.Println(s) // 输出：[0 0 0 0 0] // 创建一个键为string，值为int的映射 m := make(map[string]int) m["a"] = 1 m["b"] = 2 fmt.Println(m) // 输出：map[a:1 b:2] // 创建一个字符串通道 c := make(chan string) fmt.Println(c) // 输出：0xc0000460c0 } 复制代码
4.4 示例代码对比
通过下面的示例代码对比，我们可以更清楚地理解 new 和 make 之间的区别：
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
// 使用new创建Person类型的指针
p1 := new(Person)
p1.Name = "Alice"
p1.Age = 25
fmt.Println(p1) // 输出：&{Alice 25}
// 使用make创建切片
s1 := make([]int, 5, 10)
s1[0] = 1
s1[1] = 2
fmt.Println(s1) // 输出：[1 2 0 0 0]
}
复制代码从示例代码可以看出，使用 new 创建的是指针类型，而使用 make 创建的是初始化后的非零值对象。
5. 总结
在本文中，我们详细介绍了 Golang 中 new 和 make 的区别及使用场景。通过对两者的语法和示例代码进行分析，我们得出以下结论：
- new 用于任何类型的分配，并返回指向该类型的指针，主要用于创建值类型的实例。
- make 用于分配切片、映射和通道，并返回初始化后的非零值对象，主要用于创建引用类型的对象。
正确理解 new 和 make 的区别对于编写高效、规范的 Go 代码至关重要。在选择使用 new 还是 make 时，要根据具体的需求和对象类型进行判断。希望本文对大家有所帮助，能够更加深入地理解和应用 new 和 make 函数。感谢阅读！