--- title: "Vec::retain() vs filtrage avec iter().filter().collect() ?" description: "Comparaison du filtrage en place avec Vec::retain() et iter().filter().collect() pour différents scénarios de filtrage et implications sur les performances" url: "https://mayorana.ch/fr/blog/vec-retain-vs-filter-collect" language: "fr" date: "2025-10-30" author: "Mohamed Bennekrouf" tags: - "rust" - "retain" - "vec" - "filter" - "iterators" - "performance" en_version: "https://mayorana.ch/en/blog/vec-retain-vs-filter-collect.md" --- # Vec::retain() vs filtrage avec iter().filter().collect() ? ## Vec::retain() : Filtrage en place **Objectif** : Supprime les éléments d'un Vec en place selon un prédicat, en préservant l'ordre des éléments conservés.
[1, 2, 3, 4].retain(pair) vs .filter(pair).collect() retain() [1,2,3,4] [2, 4] (même Vec) en place, O(1) espace supp. filter().collect() [1,2,3,4] [1,2,3,4] (inchangé) nouveau Vec [2, 4] nouvelle allocation, O(n) espace supp.
**Signature** : ```rust pub fn retain(&mut self, f: F) where F: FnMut(&T) -> bool, ``` ## Caractéristiques principales | Aspect | retain() | iter().filter().collect() | |--------|----------|---------------------------| | Modifie l'original | ✅ Oui (en place) | ❌ Non (alloue un nouveau Vec) | | Préserve l'ordre | ✅ Oui | ✅ Oui | | Efficacité mémoire | ✅ O(1) espace supplémentaire | ❌ O(n) espace supplémentaire | | Performances | Plus rapide (pas de réallocation) | Plus lent (allocation/copie) | | Cas d'usage | Filtrage sans allocation | Création d'une nouvelle collection filtrée | ## Exemple : Filtrer les nombres pairs ### Utilisation de retain() (en place) ```rust let mut vec = vec![1, 2, 3, 4]; vec.retain(|x| x % 2 == 0); // Garde les pairs assert_eq!(vec, [2, 4]); // Le `vec` original est modifié ``` ### Utilisation de filter().collect() (nouvelle allocation) ```rust let vec = vec![1, 2, 3, 4]; let filtered: Vec<_> = vec.iter().filter(|x| *x % 2 == 0).copied().collect(); assert_eq!(filtered, [2, 4]); // Nouveau `Vec` créé // `vec` reste inchangé : [1, 2, 3, 4] ``` ## Comparaison des performances ### retain() : - **Temps** : O(n) (passage unique, décale les éléments vers la gauche en place). - **Espace** : O(1) (pas d'allocations supplémentaires). Concrètement, `retain()` parcourt le tampon avec deux curseurs : un curseur de lecture qui visite chaque élément, et un curseur d'écriture qui n'avance que lorsqu'un élément est conservé.
retain(|x| x % 2 == 0) sur [1, 2, 3, 4] : un passage, deux curseurs lecture 0 → 1 impair 1 2 3 4 ignoré · écriture reste 0 lecture 1 → 2 pair 2 2 3 4 placé en case 0 · écriture 1 lecture 2 → 3 impair 2 2 3 4 ignoré · écriture reste 1 lecture 3 → 4 pair 2 4 3 4 placé en case 1 · écriture 2 len = écriture 2 4 len 2, capacité toujours 4 La même allocation du début à la fin : les éléments gardés recouvrent les supprimés, puis len diminue.
### filter().collect() : - **Temps** : O(n) (mais nécessite une copie vers une nouvelle allocation). - **Espace** : O(n) (nouveau Vec alloué). ### Suggestion de benchmark : ```rust let mut big_vec = (0..1_000_000).collect::>(); // Mesurer `retain` let start = std::time::Instant::now(); big_vec.retain(|x| x % 2 == 0); println!("retain: {:?}", start.elapsed()); // Mesurer `filter().collect()` let big_vec = (0..1_000_000).collect::>(); let start = std::time::Instant::now(); let filtered = big_vec.iter().filter(|x| *x % 2 == 0).collect::>(); println!("filter.collect: {:?}", start.elapsed()); ``` **Résultat typique** : `retain()` est 2 à 3 fois plus rapide grâce à l'absence d'allocations. ## Quand utiliser chaque méthode ### Préférer retain() quand : - Tu veux modifier le Vec en place. - L'efficacité mémoire est critique (ex : Vec de grande taille). - L'ordre des éléments doit être préservé. ### Préférer filter().collect() quand : - Tu as besoin que le Vec original reste intact. - Tu enchaînes plusieurs adaptateurs d'itérateur (ex : `.filter().map()`). - Tu travailles avec des itérateurs non-Vec (ex : ranges, slices). ## Notes avancées ### retain_mut() : Rust fournit également `retain_mut()` pour les prédicats qui nécessitent un accès mutable aux éléments : ```rust let mut vec = vec![1, 2, 3]; vec.retain_mut(|x| { *x += 1; // Modification en place *x % 2 == 0 // Garde si pair après incrément }); assert_eq!(vec, [2, 4]); ``` ### Stabilité : Les deux méthodes préservent l'ordre relatif des éléments conservés (filtrage stable). ## Quand `retain()` l'emporte **retain()** : Plus rapide, efficace en mémoire et en place. Idéal pour les modifications en masse. **filter().collect()** : Flexible, non destructif. Idéal pour les pipelines d'itérateurs. ## Cas d'usage réel : - **retain()** : Nettoyer les sessions expirées dans un pool de sessions serveur. - **filter().collect()** : Transformer les données de réponse d'API en un sous-ensemble filtré. Un `retain()` dont le prédicat garde tout coûte un parcours et rien d'autre — aucune suppression, aucune [réallocation](https://mayorana.ch/fr/blog/vec-push-vs-with-capacity-performance), capacité inchangée.