Je pense qu'il est important de souligner et de savoir que si la tranche de destination (la tranche à laquelle vous ajoutez) a une capacité suffisante, l'ajout se fera "sur place", en redécoupant la destination (en la redécoupant en augmentation de sa longueur afin de pouvoir accueillir les éléments annexables).
Cela signifie que si la destination a été créée en découpant un tableau plus grand ou une tranche qui comporte des éléments supplémentaires au-delà de la longueur de la tranche résultante, ceux-ci peuvent être écrasés.
Pour le démontrer, voyez cet exemple :
a := [10]int{1, 2}
fmt.Printf("a: %v\n", a)
x, y := a[:2], []int{3, 4}
fmt.Printf("x: %v, y: %v\n", x, y)
fmt.Printf("cap(x): %v\n", cap(x))
x = append(x, y...)
fmt.Printf("x: %v\n", x)
fmt.Printf("a: %v\n", a)
Sortie (essayez-la sur le Go Playground ) :
a: [1 2 0 0 0 0 0 0 0 0]
x: [1 2], y: [3 4]
cap(x): 10
x: [1 2 3 4]
a: [1 2 3 4 0 0 0 0 0 0]
Nous avons créé un tableau de "sauvegarde". a
avec la longueur 10
. Ensuite, nous créons le x
de destination en découpant cette a
le tableau, y
est créée en utilisant le littéral composite []int{3, 4}
. Maintenant, lorsque nous ajoutons y
à x
le résultat est celui attendu [1 2 3 4]
mais ce qui peut être surprenant, c'est que le réseau de soutien a
a également changé, car la capacité de x
est 10
ce qui est suffisant pour ajouter y
à elle, donc x
est redécoupé, ce qui utilisera également la même a
la matrice de sauvegarde, et append()
copiera les éléments de y
là-dedans.
Si vous souhaitez éviter cela, vous pouvez utiliser un fichier expression de la tranche complète qui a la forme
a[low : high : max]
qui construit une tranche et contrôle également la capacité de la tranche résultante en lui donnant la valeur suivante max - low
.
Voir l'exemple modifié (la seule différence est que nous créons x
comme ça : x = a[:2:2]
:
a := [10]int{1, 2}
fmt.Printf("a: %v\n", a)
x, y := a[:2:2], []int{3, 4}
fmt.Printf("x: %v, y: %v\n", x, y)
fmt.Printf("cap(x): %v\n", cap(x))
x = append(x, y...)
fmt.Printf("x: %v\n", x)
fmt.Printf("a: %v\n", a)
Sortie (essayez-la sur le Go Playground )
a: [1 2 0 0 0 0 0 0 0 0]
x: [1 2], y: [3 4]
cap(x): 2
x: [1 2 3 4]
a: [1 2 0 0 0 0 0 0 0 0]
Comme vous pouvez le voir, nous obtenons le même x
résultat mais le tableau de sauvegarde a
n'a pas changé, car la capacité de x
était "seulement" 2
(grâce à l'expression de la tranche complète a[:2:2]
). Ainsi, pour effectuer l'ajout, un nouveau tableau de sauvegarde est alloué et peut stocker les éléments des deux tableaux suivants x
et y
qui est distinct de a
.