Les slices Go, tableaux dynamiques offrant une manipulation de données flexible, ne possèdent pas de fonction « supprimer » directe. La suppression d’éléments nécessite une approche différente. Cet article détaille des techniques efficaces, en se concentrant sur le sous-slicing pour des performances optimales.
Table des matières
- Suppression d’un seul élément
- Suppression de plusieurs éléments
- Suppression d’éléments en fonction d’une condition
- Considérations sur les performances
Suppression d’un seul élément
La méthode la plus efficace pour supprimer un seul élément consiste à créer un nouveau slice excluant l’élément cible. Cela exploite les capacités de slicing de Go, créant une vue dans le tableau sous-jacent sans copie complète du tableau. Ceci est significativement plus rapide que les méthodes impliquant l’ajout ou la copie d’éléments individuels, en particulier pour les grands slices.
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
indexToDelete := 2 // Supprimer l'élément à l'index 2 (valeur 30)
newSlice := append(mySlice[:indexToDelete], mySlice[indexToDelete+1:]...)
fmt.Println("Slice original :", mySlice)
fmt.Println("Slice après suppression :", newSlice)
}
Ce code crée newSlice en ajoutant deux sous-slices : mySlice[:indexToDelete] (éléments avant la cible) et mySlice[indexToDelete+1:] (éléments après la cible). L’opérateur de points de suspension (…) déballe le deuxième slice pour l’ajout. Le mySlice original reste inchangé.
Suppression de plusieurs éléments
L’extension de l’approche de sous-slicing pour supprimer plusieurs éléments est moins simple, mais reste plus efficace que l’ajout itératif pour les grands slices. Bien qu’une seule opération de sous-slicing concise ne soit pas possible, nous pouvons optimiser le processus pour minimiser les allocations.
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
indicesToDelete := []int{1, 3} // Indices à supprimer
newSlice := make([]int, 0, len(mySlice)-len(indicesToDelete)) // Pré-allocation pour l'efficacité
for i, val := range mySlice {
shouldDelete := false
for _, index := range indicesToDelete {
if i == index {
shouldDelete = true
break
}
}
if !shouldDelete {
newSlice = append(newSlice, val)
}
}
fmt.Println("Slice original :", mySlice)
fmt.Println("Slice après suppression :", newSlice)
}
Cet exemple amélioré pré-alloue le newSlice pour réduire les allocations lors de l’ajout, améliorant ainsi l’efficacité. Il itère, vérifie indicesToDelete et ajoute uniquement les éléments à conserver.
Suppression d’éléments en fonction d’une condition
La suppression d’éléments en fonction d’une condition nécessite souvent une itération. Moins efficace que le sous-slicing pour les suppressions uniques, elle est nécessaire pour la suppression conditionnelle.
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
newSlice := make([]int, 0, len(mySlice)) //Pré-allocation pour l'efficacité
for _, val := range mySlice {
if val != 30 { // Supprimer les éléments égaux à 30
newSlice = append(newSlice, val)
}
}
fmt.Println("Slice original :", mySlice)
fmt.Println("Slice après suppression :", newSlice)
}
Cet exemple filtre les éléments en fonction de la condition val != 30. La pré-allocation de newSlice améliore les performances. Pour les grands slices et les suppressions conditionnelles fréquentes, envisagez des techniques plus avancées comme le filtrage avec une fonction séparée ou l’utilisation d’une structure de données différente.
Considérations sur les performances
Pour la suppression d’un seul élément, le sous-slicing reste l’approche la plus efficace. Les suppressions multiples ou conditionnelles nécessitent souvent une itération, mais la pré-allocation du slice résultant atténue considérablement la dégradation des performances. Privilégiez toujours le sous-slicing lorsque cela est possible pour des performances optimales, en particulier avec des ensembles de données volumineux.