--- title: "Aplatir un Vec> en Vec avec des itérateurs" description: "Comparaison entre l'aplatissement de Vec> avec des itérateurs et la concaténation manuelle, avec analyse des implications sur les performances" url: "https://mayorana.ch/fr/blog/flatten-vec-iterators-performance" language: "fr" date: "2025-10-31" author: "Mohamed Bennekrouf" tags: - "rust" - "vec" - "flatten" - "iterators" - "performance" - "collections" en_version: "https://mayorana.ch/en/blog/flatten-vec-iterators-performance.md" --- # Aplatir un Vec> en Vec avec des itérateurs ## Aplatissement avec les itérateurs La manière la plus idiomatique est d'utiliser `.flatten()` ou `.flat_map()` :

```rust let nested = vec![vec![1, 2], vec![3], vec![4, 5, 6]]; // Méthode 1 : flatten() (pour Vec) let flat: Vec<_> = nested.iter().flatten().copied().collect(); // Méthode 2 : flat_map() (pour des transformations personnalisées) let flat: Vec<_> = nested.into_iter().flat_map(|v| v).collect(); ``` **Résultat** : `[1, 2, 3, 4, 5, 6]` ## Concaténation manuelle Pour comparaison, voici comment tu pourrais le faire manuellement : ```rust let mut flat = Vec::new(); for subvec in nested { flat.extend(subvec); // ou append() si subvec n'est plus nécessaire } ``` ## Comparaison des performances | Méthode | Complexité temporelle | Complexité spatiale | Allocations | Optimisations | |--------|-----------------|------------------|-------------|---------------| | Itérateur (flatten) | O(n) | O(1) itérateur | 1 (résultat) | Peut fusionner les itérateurs | | Manuel (extend) | O(n) | O(1) espace temporaire | 1 (résultat) | Pré-allocation possible | ## Principales observations ### Avantage de la pré-allocation (Manuel) Tu peux [pré-allouer](https://mayorana.ch/fr/blog/vec-new-vs-with-capacity) le Vec cible si la taille totale est connue : ```rust let total_len: usize = nested.iter().map(|v| v.len()).sum(); let mut flat = Vec::with_capacity(total_len); // Critique pour les grands jeux de données flat.extend(nested.into_iter().flatten()); ``` ### Évaluation paresseuse des itérateurs - `.flatten()` est paresseux, mais `.collect()` doit quand même allouer le résultat. - Les itérateurs chaînés (ex: `.filter().flatten()`) peuvent être mieux optimisés que les boucles manuelles. Cette paresse signifie que `flatten()` ne garde vivants que deux objets — l'itérateur externe et l'itérateur interne qu'il est en train de vider — et fait tout son travail dans un seul appel à `next()` :

## Exemple de benchmark ```rust let nested: Vec> = (0..1_000).map(|i| vec![i; 100]).collect(); // Approche par itérateur let start = std::time::Instant::now(); let flat = nested.iter().flatten().copied().collect::>(); println!("flatten: {:?}", start.elapsed()); // Approche manuelle avec pré-allocation let start = std::time::Instant::now(); let total_len = nested.iter().map(|v| v.len()).sum(); let mut flat = Vec::with_capacity(total_len); flat.extend(nested.into_iter().flatten()); println!("manual: {:?}", start.elapsed()); ``` **Résultat typique** : - La méthode manuelle avec pré-allocation est ~10–20% plus rapide pour les grands Vec. - La version avec itérateur est plus concise et aussi rapide pour les petites données. ## Les approches comparées | Approche | Convient le mieux pour | Pièges | |----------|----------|----------| | Itérateur | Lisibilité, chaînage d'opérations | Légèrement plus lent sans pré-allocation | | Manuel | Performances maximales, grandes données | Verbeux ; nécessite le calcul de la longueur | ## Avancé : Aplatissement sans copie Si tu as `Vec<&[T]>` au lieu de `Vec>`, utilise `.flatten().copied()` pour éviter le clonage : ```rust let slices: Vec<&[i32]> = vec![&[1, 2], &[3, 4]]; let flat: Vec = slices.iter().flatten().copied().collect(); ``` **Utilise .flatten() pour** : - Un code propre et idiomatique. - Le chaînage avec d'autres adaptateurs d'itérateurs (ex: `.filter()`). **Utilise extend manuel pour** : - Les grands jeux de données où la pré-allocation est importante. - Les cas où tu connais déjà la longueur totale. **Toujours pré-allouer pour la concaténation manuelle de grandes collections !** Pour aplatir et dédupliquer en une passe, collecte dans un `HashSet` plutôt que dans un `Vec` — `.flatten().collect::>()` — en acceptant de perdre l'ordre.