Pourquoi `append(x, x...)` copie-t-il la tranche dans un nouveau tableau de support dans Go ?

l'éditeur php Youzi répondra à une question courante pour tout le monde : Pourquoi `append(x, x...)` copie-t-il la tranche dans le nouveau tableau de support dans Go ? Dans le langage de programmation Go, la fonction « append » est utilisée pour ajouter des éléments à une tranche. Lorsque nous utilisons la fonction `append`, si la capacité de la tranche est insuffisante, Go créera un nouveau tableau sous-jacent et copiera les éléments de la tranche d'origine dans le nouveau tableau sous-jacent. En effet, dans Go, une tranche est une référence à un tableau dynamique. Lorsque la capacité de la tranche n'est pas suffisante, un nouveau tableau doit être créé pour accueillir plus d'éléments. Ce mécanisme assure la continuité et l'évolutivité des tranches, mais entraîne également quelques pertes de performances.

Contenu de la question

Dans les bibliothèques wiki et go de conseils de découpage de go (comme cet exemple), vous verrez parfois du code comme celui-ci pour copier une tranche dans un nouveau tableau de support.

// In a library at the end of a function perhaps...
return append(whateverSlice[:0:0], whateverSlice...)

// In an assignment, as in the wiki example...
b = append(a[:0:0], a...)

Voici ce que je pense comprendre :

• Tous les éléments de la tranche donnée comme deuxième argument de append seront copiés dans le nouveau tableau de support.
• Dans le premier paramètre de append 的第一个参数中，代码使用完整切片表达式。 （我们可以将第一个参数重写为 a[0:0:0]，但如果省略，将提供第一个 0, le code utilise une expression de tranche complète. (Nous pourrions réécrire le premier argument sous la forme a[0:0:0], mais s'il est omis, le premier
sera fourni. Je ne pense pas que cela soit pertinent pour le sens plus large ici.)
Selon les spécifications, la tranche générée doit être du même type que la tranche d'origine et doit avoir une longueur et une capacité nulles.
• copy 代替 append (Encore une fois, pas directement lié, mais je sais que vous pouvez utiliser copy au lieu de
et cela est plus clair.)

append(someslice[:0:0], someslice...) 创建一个新的支持数组。我最初也很困惑为什么 appendCependant, je ne comprends toujours pas pourquoi la syntaxe append(someslice[:0:0], someslice...) crée un nouveau tableau de sauvegarde. Au début, je ne comprenais pas non plus pourquoi l'opération

n'avait pas gâché (ou tronqué) la tranche d'origine.

Maintenant, je suppose :

• newslice := oldsliceJe suppose que tous ces éléments sont nécessaires et utiles, car si vous attribuez simplement
, les modifications apportées à l'un seront reflétées dans l'autre. Normalement, vous ne voulez pas ça.
• appendParce que nous n'attribuons pas le résultat de
à la tranche d'origine (ce qui est normal en cours d'exécution), rien n'arrive à la tranche d'origine. Il n’est en aucun cas tronqué ou modifié.
• anyslice[:0:0] 的长度和容量均为零，因此如果 go 要将 anyslicePuisque les éléments de sont affectés au résultat, un nouveau tableau de support doit être créé. Est-ce la raison
de créer un nouveau tableau de support ?
• anyslice... 没有元素会发生什么？ go playground 上的一个片段表明，如果您在空切片上使用此附加技巧，则副本和原始副本最初具有相同的支持数组。 （编辑：正如评论者所解释的，我误解了这个片段。该片段显示这两个项目最初是相同的，但是都没有支持数组。它们都指向最初为通用零值。）由于两个切片的长度和容量都为零，因此当您向其中一个切片添加任何内容时，该切片将获得一个新的后备数组。所以我猜，效果还是一样的。即appendQue se passe-t-il si anyslice... n'a aucun élément ? Un extrait sur le terrain de jeu en déplacement montre que si vous utilisez cette astuce supplémentaire sur une tranche vide, la copie et l'original ont initialement le même tableau de support. (Modifier : comme l'a expliqué un commentateur, j'ai mal compris cet extrait. L'extrait montre que les deux projets étaient à l'origine identiques, mais ni ne prend en charge les tableaux. Ils pointent tous les deux vers un générique. valeur nulle initialement.) Étant donné que les deux tranches ont une longueur et une capacité nulles, lorsque vous ajoutez quelque chose à l'une des tranches, cette tranche obtient un nouveau tableau de support. Donc je suppose que l'effet est toujours le même. Autrement dit, les deux tranches ne peuvent pas s'influencer après la copie.
• Cet autre extrait de terrain de jeu montre que si la tranche contient plus de zéro élément, la méthode append copy génère immédiatement un nouveau tableau de support. Dans ce cas, les deux tranches résultantes sont pour ainsi dire immédiatement séparées.

Je suis probablement trop inquiet à ce sujet, mais j'aimerais avoir une explication plus approfondie de la raison pour laquelle append(a[:0:0], a...) l'astuce fonctionne comme ça.

Solution de contournement

Étant donné que anySlice[:0:0] a une longueur et une capacité nulles, Go doit créer un nouveau tableau de sauvegarde s'il souhaite attribuer les éléments de anySlice au résultat. Est-ce pour cela que le nouveau tableau de sauvegarde a été créé ?

Parce que la capacité est de 0, oui.

https://pkg.go.dev/[email protected]#append

Si la capacité est suffisante, la cible est retranchée pour accueillir les nouveaux éléments. Sinon, un nouveau tableau sous-jacent sera alloué.

• cap=0 Pas suffisant pour les tranches non vides, il faut allouer un nouveau tableau.

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!