---
title: "Quelles sont les différences entre into_iter(), iter() et iter_mut() ?"
description: "into_iter(), iter() et iter_mut() diffèrent par ce qu'ils cèdent : la valeur, une référence partagée ou une référence exclusive."
url: "https://mayorana.ch/fr/blog/iter-methods-rust"
language: "fr"
date: "2025-10-25"
author: "Mohamed Bennekrouf"
tags:
- "rust"
- "iterators"
- "collections"
- "ownership"
en_version: "https://mayorana.ch/en/blog/iter-methods-rust.md"
---
# Quelles sont les différences entre into_iter(), iter() et iter_mut() ?
Ces trois méthodes sont fondamentales pour travailler avec des collections en Rust, chacune servant des cas d'utilisation distincts en matière d'ownership et de mutabilité.
## 1. `into_iter()` - itérateur qui consomme l'ownership
- **Prend l'ownership** de la collection (`self`).
- **Produit** des valeurs possédées (`T`) lors de l'itération.
- **Détruit** la collection originale (ne peut plus être utilisée ensuite).
```rust
let vec = vec!["a".to_string(), "b".to_string()];
for s in vec.into_iter() { // `vec` est déplacé ici
println!("{}", s); // `s` est un String (possédé)
}
// println!("{:?}", vec); // ERREUR : `vec` a été consommé
```
**Quand l'utiliser** :
- Quand tu as besoin de transformer ou consommer la collection définitivement.
- Pour enchaîner des adaptateurs d'itérateurs qui nécessitent l'ownership (ex: `.filter().collect()`).
## 2. `iter()` - itérateur d'emprunt immuable
- **Emprunte** la collection de manière immuable (`&self`).
- **Produit** des références (`&T`).
- **Laisse** la collection intacte.
```rust
let vec = vec!["a", "b", "c"];
for s in vec.iter() { // Emprunte `vec`
println!("{}", s); // `s` est &&str (référence)
}
println!("{:?}", vec); // OK : `vec` toujours valide
```
**Quand l'utiliser** :
- Quand tu as seulement besoin d'un accès en lecture seule aux éléments.
- Pour des opérations comme la recherche (`.find()`) ou l'inspection.
## 3. `iter_mut()` - itérateur d'emprunt mutable
- **Emprunte** la collection de manière mutable (`&mut self`).
- **Produit** des références mutables (`&mut T`).
- **Permet** la modification en place.
```rust
let mut vec = vec![1, 2, 3];
for num in vec.iter_mut() { // Emprunt mutable
*num *= 2; // Modifie en place
}
println!("{:?}", vec); // [2, 4, 6]
```
**Quand l'utiliser** :
- Quand tu as besoin de modifier les éléments sans [réallocation](https://mayorana.ch/fr/blog/vec-push-vs-with-capacity-performance).
- Pour des mises à jour en masse (ex: appliquer des transformations).
## Résumé des différences clés
| Méthode | Ownership | Produit | Modifie l'original ? | Réutilisable ? |
|---------------|---------------|------------|---------------------|----------------|
| `into_iter()` | Consomme | `T` | ❌ (détruit) | ❌ |
| `iter()` | Emprunte | `&T` | ❌ | ✅ |
| `iter_mut()` | Emprunt mut | `&mut T` | ✅ | ✅ |
## Ce qui coince en pratique
- **Déplacements accidentels avec `into_iter()`** :
```rust
let vec = vec![1, 2];
let _ = vec.into_iter(); // `vec` déplacé ici
// println!("{:?}", vec); // ERREUR !
```
- **Accès mutable simultané** :
```rust
let mut vec = vec![1, 2];
let iter = vec.iter_mut();
// vec.push(3); // ERREUR : Impossible d'emprunter `vec` pendant que l'itérateur existe
```
Le second cas surprend, car rien ne *semble* encore emprunter. L'emprunt mutable pris par `iter_mut()` est stocké dans l'itérateur : il reste donc vivant tant que l'itérateur est utilisé plus loin dans la fonction :
## Exemples concrets
- **`iter()` pour un traitement en lecture seule** :
```rust
let words = vec!["hello", "world"];
let lengths: Vec<_> = words.iter().map(|s| s.len()).collect(); // [5, 5]
```
- **`iter_mut()` pour des mises à jour en place** :
```rust
let mut scores = vec![85, 92, 78];
scores.iter_mut().for_each(|s| *s += 5); // [90, 97, 83]
```
- **`into_iter()` pour un transfert d'ownership** :
```rust
let matrix = vec![vec![1, 2], vec![3, 4]];
let flattened: Vec<_> = matrix.into_iter().flatten().collect(); // [1, 2, 3, 4]
```
## Notes de performance
- `iter()` et `iter_mut()` sont des [zero-cost abstractions](https://mayorana.ch/fr/blog/zero-cost-abstractions-rust) (juste des pointeurs).
- `into_iter()` peut impliquer des déplacements (mais optimisés pour les primitives comme `i32`).
`Copy` n'a rien à voir ici : `iter_mut()` donne des `&mut T` dans tous les cas, donc
`*item = new_value` fonctionne sur un `Vec` exactement comme sur un `Vec`.