Adaptateurs et consommateurs
Chaînage des opérations
Adaptateurs et consommateurs est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.
Deux types de méthodes
Les méthodes des itérateurs se répartissent en deux groupes :
- Adaptateurs renvoient un nouvel itérateur et sont paresseux (
map,filter,take) - Consommateurs exécutent l’itérateur et produisent une valeur finale (
sum,collect,for_each)
Chaque chaîne comporte zéro adaptateur ou plus, suivis d’un seul consommateur.
take : limiter le nombre
take(n) fournit au plus n éléments, puis s’arrête. C’est un adaptateur, il reste donc paresseux.
Il fonctionne même avec les itérateurs infinis, en ne prenant que le nombre d’éléments demandé.
fn main() {
let first_three: Vec<i32> = (1..).take(3).collect();
println!("{:?}", first_three);
}skip : ignorer les premiers éléments
skip(n) ignore les n premiers éléments et fournit les suivants. Combinez-le avec take pour extraire une fenêtre au milieu.
fn main() {
let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
println!("{:?}", window);
}enumerate : associer un index
enumerate fournit des tuples (index, value), en commençant à zéro. C’est la manière idiomatique d’obtenir les positions sans compteur manuel.
fn main() {
let letters = vec!['a', 'b', 'c'];
for (i, c) in letters.iter().enumerate() {
println!("{} -> {}", i, c);
}
}zip : parcourir deux itérateurs ensemble
zip associe les éléments de deux itérateurs. Il s’arrête lorsque le plus court n’a plus d’éléments.
C’est pratique pour combiner des données parallèles, comme des noms et des scores.
fn main() {
let names = vec!["Ana", "Ben"];
let ages = vec![30, 25];
for (name, age) in names.iter().zip(ages.iter()) {
println!("{} is {}", name, age);
}
}rev : inverser l’ordre
rev fournit les éléments de la fin vers le début. Il nécessite un itérateur à double extrémité, comme ceux fournis par les plages et les tranches.
fn main() {
let backwards: Vec<i32> = (1..=5).rev().collect();
println!("{:?}", backwards);
}chain : réunir deux itérateurs
chain exécute le premier itérateur jusqu’à son terme, puis poursuit avec le second, comme s’il s’agissait d’une seule séquence.
fn main() {
let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
println!("{:?}", joined);
}fold : construire une valeur unique
fold est le consommateur général. Il commence avec un accumulateur et y intègre chaque élément à l’aide d’une fermeture.
De nombreux consommateurs comme sum sont des cas particuliers de fold.
fn main() {
let product = (1..=5).fold(1, |acc, x| acc * x);
println!("5! = {}", product);
}any et all : consommateurs booléens
any renvoie true si au moins un élément satisfait le prédicat ; all renvoie true uniquement si tous les éléments le satisfont.
Les deux appliquent un court-circuit : ils s’arrêtent dès que la réponse est connue.
fn main() {
let nums = vec![2, 4, 6, 7];
println!("{}", nums.iter().all(|x| x % 2 == 0));
println!("{}", nums.iter().any(|x| x % 2 != 0));
}find et position
find renvoie le premier élément correspondant à un prédicat sous la forme d’un Option. position renvoie à la place l’index de la première correspondance.
Les deux s’arrêtent dès la première correspondance.
fn main() {
let nums = vec![1, 3, 5, 8, 9];
println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}Concevoir des chaînes
Construisez les chaînes en empilant des adaptateurs, puis terminez par un seul consommateur. Gardez-les lisibles : une opération par ligne.
Comme les adaptateurs sont paresseux, même les longues chaînes ne parcourent les données qu’une seule fois.
Vérification rapide
Adaptateurs et consommateurs.
Récapitulatif
Vous avez exploré l’enchaînement d’opérations :
- Les adaptateurs (
take,skip,enumerate,zip,rev,chain) restent paresseux - Les consommateurs (
fold,any,all,find,position) terminent le traitement - Les consommateurs booléens et de recherche appliquent un court-circuit
- Chaque chaîne contient des adaptateurs, puis un seul consommateur
Questions Fréquemment Posées
La leçon « Adaptateurs et consommateurs » est-elle gratuite ?
Oui — le texte complet de « Adaptateurs et consommateurs » 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 « Adaptateurs et consommateurs » ?
Chaînage des opérations 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 3 sur 4.
Combien de temps prend la leçon « Adaptateurs et consommateurs » ?
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.
Toutes les leçons de ce cours
- Le trait Iterator
- map, filter, collect
- Adaptateurs et consommateurs
- Itérateurs personnalisés