Comment déplacer un élément dans un Go Slice : une solution robuste ?

Réorganisation des éléments de tranche : un guide complet

Déplacer des éléments dans une tranche est une opération courante dans Go, mais il peut être difficile de réussir. Cet article explique en détail comment déplacer un élément d'une position à une autre dans une tranche, en explorant les défis et en fournissant une solution robuste.

Énoncé du problème

Considérez l'extrait de code suivant :

<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 vise à déplacer l'élément de indexToRemove vers indexWhereToInsert dans la tranche. Cependant, le résultat attendu n’est pas atteint. Au lieu de déplacer l'élément vers la position souhaitée, il est incorrectement dupliqué dans la tranche.

Cause première

L'erreur réside dans l'approche utilisée pour supprimer l'élément à indexToRemove. En ajoutant slice[:indexToRemove] à slice[indexToRemove 1:], l'élément à indexToRemove est involontairement supprimé de la tranche.

Une solution robuste

Pour déplacer correctement un élément dans une tranche, une approche plus globale est nécessaire. Nous présentons une fonction personnalisée, moveInt, qui peut gérer cette tâche :

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

Cette fonction supprime d'abord l'élément de l'index source (srcIndex) à l'aide de la fonction removeInt. Il insère ensuite l'élément supprimé à l'index de destination (dstIndex) à l'aide de la fonction insertInt. RemoveInt et insertInt sont des fonctions d'assistance qui peuvent être implémentées comme suit :

<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:]...)
}</code>

Utilisation et résultat

Pour utiliser la fonction moveInt, nous pouvons modifier le code d'origine :

<code class="go">slice = moveInt(slice, 1, 5)</code>

Avec cet ajustement, le code déplace correctement l'élément à l'index 1 (contenant auparavant la valeur 2) vers l'index 5. La tranche résultante est comme prévu :

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

Cette solution fournit une solution robuste et moyen efficace de réorganiser les éléments dans une tranche dans Go. Il répond aux limites de l'approche initiale et garantit un mouvement précis des objets.

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!