---
title: "Implications d'itérer sur un Vec avec .into_iter() au lieu de .iter()"
description: "Comprendre les différences entre .into_iter() et .iter() lors de l'itération sur Vec, couvrant les implications d'ownership et considérations de performance"
url: "https://mayorana.ch/fr/blog/into-iter-vs-iter-ownership-fr"
language: "fr"
date: "2025-08-21"
author: "Mohamed Bennekrouf"
tags:
- "rust"
- "iterators"
- "ownership"
- "vec"
- "into-iter"
- "collections"
en_version: "https://mayorana.ch/en/blog/into-iter-vs-iter-ownership.md"
---
# Implications d'itérer sur un Vec avec .into_iter() au lieu de .iter()
## `.into_iter()` face à `.iter()`
| .into_iter() | .iter() |
|--------------|---------|
| Consomme le Vec (prend ownership). | Emprunte le Vec en écriture (mut) |
| Produit des valeurs owned (T). | Produit des références (&T). |
| Le Vec original est inutilisable après. | Le Vec original reste intact. |
## Quand utiliser .into_iter()
### Besoin d'Ownership sur les éléments d'une liste
Utile quand tu veux sortir des éléments du Vec (ex : transférer vers une autre collection, comme un ctrl-x) :
```rust
let vec = vec![String::from("a"), String::from("b")];
let new_vec: Vec = vec.into_iter().collect(); // `vec` est consommé
// println!("{:?}", vec); // ERREUR: `vec` moved
```
### Opérations Destructives
Pour des opérations qui détruisent le Vec (ex : trier et dédupliquer en un passage) :
```rust
let mut vec = vec![3, 1, 2, 1];
vec = vec.into_iter().unique().sorted().collect(); // Destructif mais efficace
```
### Optimisation de performance
Évite le cloning quand on travaille avec des données owned (ex : Vec) :
```rust
let vec = vec![String::from("rust")];
for s in vec.into_iter() { // Pas de clone, move le `String`
println!("{}", s);
}
```
## Implications d'Ownership
### Après .into_iter(), le Vec original est "moved" et ne peut pas être utilisé :
```rust
let vec = vec![1, 2, 3];
let iter = vec.into_iter(); // `vec` est moved ici
// println!("{:?}", vec); // ERREUR: value borrowed after move
```
### Fonctionne avec les types "non-Copy" (ex: String, Box) :
```rust
let vec = vec![String::from("hello")];
let s = vec.into_iter().next().unwrap(); // Move le `String` dehors
```
## Comparaison avec .iter()
| Scénario | .into_iter() | .iter() |
|----------|--------------|---------|
| Besoin de réutiliser le Vec | ❌ Non | ✅ Oui |
| Modifier les éléments | ❌ Non (consommé) | ✅ Oui (iter_mut()) |
| Éviter le cloning de données owned | ✅ Oui | ❌ Non (nécessite clone()) |
## Exemples réels
### Transfert de données
Déplacer un Vec dans une fonction qui prend ownership :
```rust
fn process(data: impl Iterator) { /* ... */ }
let vec = vec![String::from("a"), String::from("b")];
process(vec.into_iter()); // Efficace, pas de clones
```
### Filtrage Destructif
Retirer des éléments pendant l'itération :
```rust
let vec = vec![1, 2, 3, 4];
let evens: Vec<_> = vec.into_iter().filter(|x| x % 2 == 0).collect();
```
## Ce que ça coûte à l'exécution
- **Zero-cost pour les primitives (i32, bool)** : `.into_iter()` et `.iter()` compilent vers le même code assembleur si le type implémente le trait copy (`T: Copy`).
- **Évite les allocations** quand on chaîne des adaptateurs (ex : `.map().filter()`).
## Choisir entre les deux
**Utilise .into_iter() pour** :
- Sortir des éléments d'un Vec.
- Optimiser la performance avec des données owned.
- Transformer destructivement des collections.
**Evite si tu dois** :
- Réutiliser le Vec après itération.
- Partager des références entre threads (`&T` est Sync; mais `T` pourrait ne pas l'être).
Un piège à connaître : appelle `.into_iter()` sur un `Vec` puis passe le même `Vec` à `rayon` et
tu obtiens une erreur de compilation, parce que le premier appel l'a consommé. Pour du parallèle
en lecture seule, prends `.par_iter()` et ne cède jamais l'ownership.