Pourquoi l'ajout à une tranche Go n'affecte-t-il pas la tranche d'origine lorsqu'elles partagent le même tableau sous-jacent ?

Comprendre le comportement d'ajout sur les tranches

Dans Go, les tranches sont un moyen pratique de gérer des collections de données. Cependant, leur comportement peut parfois prêter à confusion, en particulier lors de l'exécution d'opérations telles que l'ajout d'éléments.

Considérez l'extrait de code suivant :

func main() {
    slice := make([]int, 10, 10)
    slice[0] = 0
    slice[1] = 1

    slice1 := slice
    slice1[0] = 10000
    fmt.Println(slice)

    slice1 = append(slice1, 100)
    slice1[0] = 20000

    fmt.Println(slice)
}

Le résultat attendu serait une liste d'éléments dans lesquels le la première tranche est passée à 10 000 après le premier ajout, puis à 20 000 après le deuxième ajout. De plus, nous nous attendons à ce que les éléments de slice reflètent également ces changements, puisque slice et slice1 pointent tous deux vers le même tableau sous-jacent.

Cependant, le résultat réel est surprenant :

[10000 1 0 0 0 0 0 0 0 0]
[10000 1 0 0 0 0 0 0 0 0]

La première sortie, comme prévu, montre que slice1 a réussi à changer la valeur du premier élément à 10 000. Cependant, la deuxième sortie révèle que l'opération d'ajout ultérieure et les modifications apportées à slice1 n'ont pas affecté slice. Pourquoi en est-il ainsi ?

Comprendre la sémantique des valeurs de Go

La clé pour comprendre ce comportement réside dans la sémantique des valeurs de Go. Dans Go, les variables sont transmises par valeur, ce qui signifie que lorsque vous affectez une variable à une autre variable, une copie de la valeur est effectuée. Cela s'applique également aux tranches.

Lorsque vous exécutez slice1 := slice, vous créez une copie de l'en-tête de la tranche. L'en-tête de tranche contient des informations sur la longueur, la capacité et le pointeur vers le tableau sous-jacent. Cependant, le tableau sous-jacent lui-même n'est pas copié.

Comportement d'ajout

Lorsque vous effectuez une opération d'ajout, un nouvel en-tête de tranche est créé et un nouveau tableau sous-jacent est alloué . Les éléments de la tranche d'origine sont copiés dans le nouveau tableau et le nouvel en-tête de tranche est renvoyé.

Dans notre exemple, lorsque vous exécutez slice1 = append(slice1, 100), un nouvel en-tête de tranche est créé et un nouveau tableau est alloué avec de l'espace pour les éléments existants ainsi que l'élément supplémentaire à ajouter. Les éléments de slice1 sont copiés dans le nouveau tableau et le nouvel en-tête de slice est attribué à slice1.

Il est important de noter que slice pointe toujours vers le tableau sous-jacent d'origine, c'est pourquoi les modifications apportées à slice1 ne sont pas reflétées dans slice.

Conclusion

Pour comprendre le comportement d'ajout sur les tranches, il est crucial de se rappeler que les tranches sont transmis par valeur. Lors de l'ajout d'éléments, un nouvel en-tête de tranche et un tableau sous-jacent sont créés, laissant la tranche d'origine inchangée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!