Déplacer un élément de tranche dans Go : comprendre les techniques correctes

Le déplacement de tranches dans Go implique souvent de réorganiser leurs éléments. Tenter de déplacer directement un élément d'une position à une autre peut entraîner des résultats inattendus, comme le démontre l'extrait de code fourni :

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

indexToRemove := 1
indexWhereToInsert := 4

slice = append(slice[:indexToRemove], slice[indexToRemove 1:]...)
newSlice := append(slice[:indexWhereToInsert], 1)
slice = append(newSlice, slice[indexWhereToInsert:]...)

Cette approche vise à déplacer l'élément de indexToRemove vers indexWhereToInsert, mais la sortie présente deux copies de l'élément déplacé. L'erreur réside dans la manière dont l'élément est supprimé et inséré. Explorons une approche alternative :

Utiliser des fonctions personnalisées pour la manipulation d'éléments

Au lieu de modifier manuellement la tranche, nous pouvons créer des fonctions dédiées pour l'insertion et la suppression :

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

Déplacer des éléments avec précision

Avec ces fonctions d'assistance, déplacer un élément est simple :

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

Exemple d'implémentation et de sortie

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

    fmt.Println("Original slice:", slice)

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

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

    slice = moveInt(slice, 1, 4)
    fmt.Println("After moving:", slice)
}

Sortie :

Original slice: [0 1 2 3 4 5 6 7 8 9]
After insertion: [0 1 2 3 4 2 5 6 7 8 9]
After removal: [0 1 2 3 4 5 6 7 8 9]
After moving: [0 2 1 3 4 5 6 7 8 9]

Cette approche déplace correctement l'élément de l'index 1 vers l'index 4, ce qui donne le résultat attendu.