Pourquoi le déplacement d'éléments dans une Go Slice entraîne-t-il des résultats inattendus ?

Déplacement d'éléments au sein d'une tranche

Dans Go, manipuler des tranches implique souvent d'ajuster leur contenu. Une opération courante consiste à déplacer un élément d'une position à une autre dans une tranche. Cependant, une approche simple peut conduire à des résultats inattendus.

Examinons un exemple typique dans lequel nous tentons de déplacer un élément de la position indexToRemove vers indexWhereToInsert :

<code class="go">indexToRemove := 1
indexWhereToInsert := 4

slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

slice = append(slice[:indexToRemove], slice[indexToRemove+1:]...)
fmt.Println("slice:", slice)

newSlice := append(slice[:indexWhereToInsert], 1)
fmt.Println("newSlice:", newSlice)

slice = append(newSlice, slice[indexWhereToInsert:]...)
fmt.Println("slice:", slice)</code>

Ce code produit le résultat :

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 1 6 7 8 9]

Cependant, nous attendons le résultat suivant :

slice: [0 2 3 4 5 6 7 8 9]
newSlice: [0 2 3 4 1]
slice: [0 2 3 4 1 5 6 7 8 9]

Identifier le problème

Le problème découle de la façon dont nous décalons les éléments. Dans l'exemple, nous supprimons d'abord l'élément à indexToRemove, puis nous l'insérons à indexWhereToInsert. Cependant, la deuxième opération modifie les indices des éléments après indexWhereToInsert. Par conséquent, l'élément initialement situé à indexWhereToInsert est inséré après l'élément supprimé.

Fonctions personnalisées pour le déplacement d'éléments

Pour résoudre ce problème, nous pouvons créer des fonctions personnalisées pour supprimer et insérer des éléments dans un tranche. Ces fonctions gèrent les ajustements d'index en interne :

<code class="go">func insertInt(array []int, value int, index int) []int {
    return append(array[:index], append([]int{value}, array[index:]...)...)
}

func removeInt(array []int, index int) []int {
    return append(array[:index], array[index+1:]...)
}

func moveInt(array []int, srcIndex int, dstIndex int) []int {
    value := array[srcIndex]
    return insertInt(removeInt(array, srcIndex), value, dstIndex)
}</code>

Exemple d'utilisation :

<code class="go">func main() {
    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    fmt.Println("slice: ", slice)

    slice = insertInt(slice, 2, 5)
    fmt.Println("slice: ", slice)

    slice = removeInt(slice, 5)
    fmt.Println("slice: ", slice)

    slice = moveInt(slice, 1, 4)
    fmt.Println("slice: ", slice)
}</code>

Sortie :

slice:  [0 1 2 3 4 5 6 7 8 9]
slice:  [0 1 2 3 4 2 5 6 7 8 9]
slice:  [0 1 2 3 4 5 6 7 8 9]
slice:  [0 2 3 4 1 5 6 7 8 9]

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!