GolangError指南(一) ne peut pas être attribué à la liste de champs struct["fruit"].Nom dans la carte

GolangError指南(一) ne peut pas être attribué à la liste de champs struct["fruit"].Nom dans la carte

GolangError Anti-stepping pit, ne peut pas être attribué au nom du champ de structure dans la carte

---

---

Erreur Golang ?

Depuis sa sortie, le langage Go est connu pour ses hautes performances et sa grande simultanéité. Cependant, tout a deux faces. Un langage, avec ses fiers avantages, doit aussi avoir des erreurs de compilation.

• Le mot panique a le sens de panique, panique et ainsi de suite en anglais. Dans le langage Go, cela représente également un problème extrêmement grave, ce qui signifie la fin du programme et la sortie.

Le mot-clé panique dans le langage Go est principalement utilisé pour lancer activement des exceptions.

• Le mot recovery, en anglais, a le sens de recovery, recovery et ainsi de suite. En langage Go, représente la restauration de l'état du programme d'une erreur à un état normal.

Le mot-clé de récupération dans le langage Go est principalement utilisé pour intercepter les exceptions et ramener le programme à un état normal.

Deuxièmement, la raison de l'erreur

structure initiale
type Fruit struct { Name string }

1. Code d'erreur

La valeur de map[string]Fruit est un Fruit, et list["fruit"] est une référence de valeur et est en lecture seule. Ainsi, la modification de list["fruit"].Name = "banana" n'est pas autorisée. :

	// error
	list = make(map[string]Fruit)
	fruit := Fruit{
    
    "apple"}
	list["fruit"] = fruit
	//map[string]Fruit 的value是一个Fruit
	//而list["fruit"] 是值引用，是只读的。
	//所以对list["fruit"].Name = "banana"的修改是不允许的。
	list["fruit"].Name = "banana"
	fmt.Println(list["fruit"])

2. Mauvais code

Étant donné que la référence de valeur est en lecture seule, nous devons ignorer la référence pour la modifier. Nous pouvons d'abord copier une valeur, créer un tmp, puis modifier tmp.Name = "banane". À ce stade, le tmp a été modifié, puis directement La valeur de la valeur de map[string]Fruit est remplacée par tmp, et une autre copie de la valeur se produit à ce moment, list["fruit"] = tmp, bien que l'objectif soit atteint, cela provoquera 2 copies de la valeur de la structure dans le processus global. Les performances sont médiocres. :

	// bad
	list := make(map[string]Fruit)
	fruit := Fruit{
    
    "apple"}
	list["fruit"] = fruit
	//由于值引用是只读的，我们需要绕过引用才可以进行修改
	//先做一次值拷贝，做出一个 tmp ,然后修改 tmp.Name = "banana" ，
	//此时 tmp 内已经修改，那么直接将 map[string]Fruit 的value 的值替换为 tmp 
	//此时再发生一次值拷贝，list["fruit"] = tmp,
	//尽管达成目的，但是这种会在整体过程中发生2次结构体值拷贝，性能很差。
	tmp := list["fruit"]
	tmp.Name = "banana"
	list["fruit"] = tmp
	fmt.Println(list["fruit"])

3. Bon code

Nous transformons map[string]Fruit en map[string]*Fruit qui fait référence au pointeur, de sorte que nous modifions en fait l'espace Fruit pointé par le pointeur à chaque fois, bien que le pointeur lui-même soit un pointeur constant et ne puisse pas être modifié, il est un attribut en lecture seule, mais chaque fois que nous le modifions, ce n'est pas pour modifier le pointeur, mais pour modifier le fruit pointé par le pointeur, qui peut être modifié à volonté, et la modification ne nécessite pas de copie de valeur. :

	// perfect
	list := make(map[string]*Fruit)
	fruit := Fruit{
    
    "apple"}
	list["fruit"] = &fruit
	// 我们将 map[string]Fruit 变成引用指针的 map[string]*Fruit
	// 这样，我们实际上每次修改的都是指针所指向的Fruit空间，
	// 尽管指针本身是常指针，不能修改，是只读属性，
	// 但是我们的每次修改并不是修改指针，
	// 而是修改指针指向的Fruit，而这是可以随便修改的，修改也不需要值拷贝。
	list["fruit"].Name = "banana"
	fmt.Println(list["fruit"])

---

Résumer

Golang utilise des opérations de pointeur pour simplifier nos habitudes d'utilisation et l'utilisation de la mémoire. Lorsque nous constatons que nous ne pouvons pas modifier la valeur ou que nous devons modifier le même champ plusieurs fois, nous pouvons tout aussi bien nous demander si le pointeur peut répondre à nos besoins.

En espérant que ce blog vous sera utile. Je suis le Roi de la Lumière et je parle pour moi-même.