Le trait Iterator
next et évaluation paresseuse
Le trait Iterator est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu’est-ce qu’un itérateur ?
Un itérateur est tout élément qui produit une suite de valeurs, une à la fois. En Rust, les itérateurs sont la manière idiomatique de traiter des collections comme les vecteurs, les intervalles et les tranches.
Tout le concept repose sur un seul trait : Iterator. Dès qu’un type l’implémente, vous obtenez gratuitement des dizaines de méthodes utiles.
Le trait Iterator
Le trait Iterator possède une méthode obligatoire, next, et un type associé, Item :
type Item— le type de valeur produitefn next(&mut self) -> Option<Self::Item>— renvoie la valeur suivante
Il renvoie Some(value) tant qu’il reste des valeurs, puis None une fois terminé.
fn main() {
let v = vec![10, 20, 30];
let mut it = v.iter();
println!("{:?}", it.next());
println!("{:?}", it.next());
println!("{:?}", it.next());
println!("{:?}", it.next());
}next renvoie Option
Chaque appel à next fait avancer l’itérateur et vous fournit un Option. Some contient une valeur réelle ; None signale la fin.
Remarquez que next prend &mut self : son appel modifie l’état interne afin que l’appel suivant renvoie une valeur différente.
fn main() {
let mut it = (1..4).into_iter();
while let Some(n) = it.next() {
println!("got {}", n);
}
println!("done");
}Les itérateurs sont paresseux
La création d’un itérateur ne fait rien à elle seule. Aucune valeur n’est calculée tant que rien ne les demande. C’est ce qu’on appelle la paresse.
Dans l’exemple suivant, la fermeture map ne s’exécute jamais, car nous ne consommons jamais l’itérateur.
fn main() {
let nums = vec![1, 2, 3];
let _doubled = nums.iter().map(|x| {
println!("mapping {}", x);
x * 2
});
println!("nothing printed above this line");
}La consommation déclenche le travail
Pour qu’un itérateur paresseux s’exécute réellement, vous devez le consommer. Une boucle for est le consommateur le plus simple : elle appelle next à plusieurs reprises jusqu’à obtenir None.
La même fermeture map s’exécute alors pour chaque élément.
fn main() {
let nums = vec![1, 2, 3];
for x in nums.iter().map(|x| x * 2) {
println!("value {}", x);
}
}Trois façons de parcourir une collection
Les collections proposent trois méthodes qui produisent des itérateurs :
iter()— produit&T(emprunts)iter_mut()— produit&mut T(emprunts mutables)into_iter()— produitT(prend possession)
fn main() {
let mut v = vec![1, 2, 3];
for x in v.iter_mut() {
*x += 10;
}
println!("{:?}", v);
}Les boucles for utilisent into_iter
Lorsque vous écrivez directement for x in collection, Rust appelle into_iter(), ce qui consomme la collection.
Après cette boucle, vous ne pouvez plus utiliser v, car il a été déplacé dans l’itérateur.
fn main() {
let v = vec![String::from("a"), String::from("b")];
for s in v {
println!("{}", s);
}
// v is no longer usable here
}Les intervalles sont des itérateurs
Un intervalle comme 0..5 est lui-même un itérateur qui produit 0, 1, 2, 3, 4. La fin est exclusive. Utilisez 0..=5 pour un intervalle inclusif.
Les intervalles sont parfaits pour les boucles de comptage qui évitent de gérer manuellement les index.
fn main() {
for i in 0..5 {
print!("{} ", i);
}
println!();
for i in 1..=3 {
print!("{} ", i);
}
println!();
}count : un consommateur simple
count consomme l’itérateur entier et renvoie le nombre d’éléments qu’il a produits. C’est l’un des nombreux adaptateurs consommateurs.
Comme il consomme l’itérateur, vous ne pouvez pas le réutiliser ensuite.
fn main() {
let total = (1..=100).count();
println!("there are {} numbers", total);
}sum : réduire à une valeur
sum additionne tous les éléments et renvoie une seule valeur. Vous indiquez souvent le type cible afin que Rust sache quoi produire.
Cette méthode est plus concise et plus claire qu’une boucle manuelle avec accumulateur.
fn main() {
let total: i32 = (1..=5).sum();
println!("sum is {}", total);
}Pourquoi les itérateurs sont importants
Les itérateurs vous offrent la composabilité : vous pouvez enchaîner de petites opérations pour former des pipelines clairs. Ils sont également à coût nul : le compilateur les optimise pour atteindre la vitesse de boucles écrites manuellement.
Maîtriser next, la paresse et la consommation constitue la base de tout ce qui suit.
Vérification rapide
Testez votre compréhension du trait Iterator.
Récapitulatif
Vous avez appris les bases des itérateurs Rust :
- Le trait
Iteratornécessite seulementnextet un typeItem nextrenvoieSome(value), puisNone- Les itérateurs sont paresseux : ils ne font rien tant qu’ils ne sont pas consommés
iter,iter_mutetinto_itercontrôlent l’emprunt et la possession- Les consommateurs comme
for,countetsumdéclenchent le travail
Questions Fréquemment Posées
La leçon « Le trait Iterator » est-elle gratuite ?
Oui — le texte complet de « Le trait Iterator » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Le trait Iterator » ?
next et évaluation paresseuse Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Le trait Iterator » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.