Comment supprimer un élément d'une slice en Golang : guide complet avec exemples

Comment supprimer un élément d'une Slice en Golang : guide détaillé avec exemples

Travailler avec des slices en Go est une routine quotidienne pour chaque développeur. Mais une opération soulève des questions même chez les « gophers » expérimentés : la suppression d'un élément d'une slice. Quoi de plus simple, apparemment ? Cependant, Go n'a pas de méthode delete() intégrée pour les slices, contrairement aux maps. Il faut réinventer la roue.

Dans cet article, nous allons examiner toutes les méthodes pour supprimer un élément d'une slice en Golang : de la simple suppression par index aux astuces avancées avec conservation de l'ordre et optimisation de la mémoire. Vous apprendrez comment fonctionne la mécanique interne des slices, pourquoi une simple affectation ne fonctionne pas toujours, et comment éviter les erreurs typiques.

Pourquoi Go n'a-t-il pas de fonction intégrée pour supprimer d'une slice ?

Avant de plonger dans le code, comprenons la philosophie du langage. Une slice en Go est simplement une « fenêtre » sur un tableau sous-jacent. Elle ne possède pas les données, elle y fait seulement référence. Par conséquent, supprimer un élément n'est pas un effacement physique des données en mémoire (comme en C++), mais une restructuration de la « fenêtre » à l'aide d'opérations astucieuses d'append et de slicing.

Go vous laisse décider comment organiser la suppression : avec ou sans conservation de l'ordre, avec ou sans réduction de capacité. Cela offre de la flexibilité, mais nécessite de la compréhension.

Méthode 1 : Suppression par index (avec conservation de l'ordre)

C'est le cas le plus courant. Vous avez une slice et vous voulez retirer l'élément à la position i, tout en conservant l'ordre relatif des autres éléments.

package main\n\nimport "fmt"\n\nfunc removeIndex(s []int, index int) []int {\n    // On concatène la partie avant l'index et la partie après l'index\n    return append(s[:index], s[index+1:]...)\n}\n\nfunc main() {\n    slice := []int{1, 2, 3, 4, 5}\n    slice = removeIndex(slice, 2) // supprime l'élément à l'index 2 (valeur 3)\n    fmt.Println(slice) // [1 2 4 5]\n}\n

Comment cela fonctionne-t-il ?

\n
• s[:index] — on prend tous les éléments avant celui à supprimer (non inclus).
\n
• s[index+1:] — on prend tous les éléments après celui à supprimer.
\n
• append combine ces deux « morceaux » en une seule slice.
\n

Important : Cette méthode modifie le tableau sous-jacent. Après l'opération, l'élément 3 reste physiquement en mémoire (il ne sera écrasé que si vous ajoutez de nouveaux éléments). Mais pour vous, il a « disparu » de la slice.

Méthode 2 : Suppression par index (sans conservation de l'ordre) — méthode rapide

Si l'ordre des éléments n'a pas d'importance (par exemple, vous travaillez avec un ensemble de données non ordonné), vous pouvez utiliser l'astuce du « remplacement par le dernier » :

func removeFast(s []int, index int) []int {\n    // On remplace l'élément à supprimer par le dernier\n    s[index] = s[len(s)-1]\n    // On tronque la slice en supprimant le dernier élément\n    return s[:len(s)-1]\n}\n\nfunc main() {\n    slice := []int{1, 2, 3, 4, 5}\n    slice = removeFast(slice, 1) // supprime l'élément à l'index 1 (valeur 2)\n    fmt.Println(slice) // [1 5 3 4] — l'ordre est modifié !\n}\n

Pourquoi est-ce plus rapide ? Parce que nous ne copions pas la moitié de la slice. Nous déplaçons simplement un élément (le dernier) à la place de celui à supprimer et nous tronquons la slice. Opération en O(1) contre O(n) pour la première méthode.

Quand l'utiliser : Dans les boucles critiques, lorsque les performances sont essentielles et que l'ordre n'a pas d'importance (par exemple, lors de la suppression d'un pool d'objets).

Méthode 3 : Suppression par valeur (première occurrence)

Il est souvent nécessaire de trouver et de supprimer un élément par sa valeur, plutôt que par son index. Pour cela, on trouve d'abord l'index, puis on applique l'une des méthodes ci-dessus.

func removeByValue(s []string, value string) []string {\n    for i, v := range s {\n        if v == value {\n            return append(s[:i], s[i+1:]...)\n        }\n    }\n    return s // si non trouvé, on retourne