Heim >Backend-Entwicklung >Golang >Was ist der Unterschied zwischen make und new in der Go-Sprache?
Unterschied: In der Go-Sprache weisen make und new beide Speicher zu (auf dem Heap), aber make wird nur für die Initialisierung von Slice, Map und Channel (Werte ungleich Null) verwendet, während new für die Typspeicherzuweisung verwendet wird , und der Speicher wird auf Null gesetzt. make gibt den Referenztyp selbst zurück; new gibt einen Zeiger auf den Typ zurück.
Die Betriebsumgebung dieses Artikels: Windows 10-System, GO 1.11.2, Thinkpad T480-Computer.
Verwandte Empfehlungen: „go-Tutorial“
In der Go-Sprache sind new und make beide Grundelemente, die für die Speicherzuweisung verwendet werden (Zuweisungsgrundelemente). Einfach ausgedrückt: new weist nur Speicher zu und make wird für die Initialisierung von Slice, Map und Channel verwendet. Die Funktion
new(T) ist eine integrierte Funktion, die Speicher zuweist.
Wir alle wissen, dass für eine vorhandene Variable ihrem Zeiger ein Wert zugewiesen werden kann.
Beispiel
var p int var v *int v = &p *v = 11 fmt.Println(*v)
Und was ist, wenn es sich nicht um eine Variable handelt, die bereits existiert? Kann ihm direkt ein Wert zugewiesen werden?
Beispiel
var v *int *v = 8 fmt.Println(*v)
Das Ergebnis wird der folgende Fehler sein
Panik: Laufzeitfehler: ungültige Speicheradresse oder Nullzeiger-Dereferenzierung
[Signal 0xc0000005 Code=0x1 Addr=0x0 PC=0x48df66]
Wie löst man das Problem? Dies kann gelöst werden, indem Go new bereitstellt, um eine Adresse zu initialisieren.
var v *int v = new(int) *v = 8 fmt.Println(*v)
Dann analysieren wir
var v *int fmt.Println(*v) fmt.Println(v) //<nil> v = new(int) fmt.Println(*v)// fmt.Println(v)//0xc00004c088
Wir können sehen, dass bei der Initialisierung einer Zeigervariablen ihr Wert Null ist und der Wert Null nicht direkt zugewiesen werden kann. Durch new wird ein Zeiger auf einen neu zugewiesenen Typ int zurückgegeben. Der Zeigerwert ist 0xc00004c088. Der Wert des Inhalts, auf den dieser Zeiger zeigt, ist der Wert Null.
Gleichzeitig ist zu beachten, dass der Nullwert verschiedener Zeigertypen unterschiedlich ist.
Beispiel
type Name struct {
P string
}
var av *[5]int
var iv *int
var sv *string
var tv *Name
av = new([5]int)
fmt.Println(*av) //[0 0 0 0 0 0]
iv = new(int)
fmt.Println(*iv) // 0
sv = new(string)
fmt.Println(*sv) //
tv = new(Name)
fmt.Println(*tv) //{}
Oben wird beschrieben, wie Werte nach der Verarbeitung von new() für gewöhnliche Typen zugewiesen werden. Hier werden wir darüber sprechen, wie Werte nach der Verarbeitung von new() für zusammengesetzte Typen (Array, Slice, Map,) zugewiesen werden. Kanal usw.).
Array-Beispiel
var a [5]int
fmt.Printf("a: %p %#v \n", &a, a)//a: 0xc04200a180 [5]int{0, 0, 0, 0, 0}
av := new([5]int)
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000074018 &[5]int{0, 0, 0, 0, 0}
(*av)[1] = 8
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000006028 &[5]int{0, 8, 0, 0, 0}
silce-Beispiel
var a *[]int
fmt.Printf("a: %p %#v \n", &a, a) //a: 0xc042004028 (*[]int)(nil)
av := new([]int)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000074018 &[]int(nil)
(*av)[0] = 8
fmt.Printf("av: %p %#v \n", &av, av) //panic: runtime error: index out of range
map-Beispiel
var m map[string]string
fmt.Printf("m: %p %#v \n", &m, m)//m: 0xc042068018 map[string]string(nil)
mv := new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//这里会报错panic: assignment to entry in nil map
channel-Beispiel
cv := new(chan string)
fmt.Printf("cv: %p %#v \n", &cv, cv)//cv: 0xc000074018 (*chan string)(0xc000074020)
//cv <- "good" //会报 invalid operation: cv <- "good" (send to non-chan type *chan string)
Anhand des obigen Beispiels sehen wir, dass das Array durch new verarbeitet wird und das Array av mit dem Wert Null initialisiert wird. Obwohl das Array ist ein zusammengesetzter Typ und kein Referenztyp. Andere Silence-, Map- und Channel-Typen sind ebenfalls Referenztypen. Go initialisiert den Referenztyp auf Null und kann nicht direkt zugewiesen werden. Und Sie können new nicht zum Zuweisen von Speicher verwenden. Kann nicht direkt zugeordnet werden. Wie wäre es also, die Make-Funktion zu verwenden?
Beispiel
av := make([]int, 5)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{0, 0, 0, 0, 0}
av[0] = 1
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{1, 0, 0, 0, 0}
mv := make(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{}
mv["m"] = "m"
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{"m":"m"}
chv := make(chan string)
fmt.Printf("chv: %p %#v \n", &chv, chv) //chv: 0xc000074028 (chan string)(0xc00003e060)
go func(message string) {
chv <- message // 存消息
}("Ping!")
fmt.Println(<-chv) // 取消息 //"Ping!"
close(chv)
make kann nicht nur einen Speicher öffnen, sondern auch seinen Nullwert für den Typ dieses Speichers initialisieren.
Es kann auch zusammen mit new verwendet werden
Beispiel
var mv *map[string]string
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 (*map[string]string)(nil)
mv = new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv) = make(map[string]string)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 &map[string]string{"a":"a"}
Ordnen Sie der Zeigervariablen mv über new einen Speicher zu und weisen Sie ihr eine Speicheradresse zu. Map ist ein Referenztyp und sein Nullwert ist Null. Verwenden Sie make, um die Map zu initialisieren, und dann kann der Variablen mit * ein Wert der Zeigervariablen mv zugewiesen werden.
Weitere Kenntnisse zum Thema Programmierung finden Sie unter: Programmierunterricht! !
Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen make und new in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!