0Pricing
Learn Rust Coding · Leçon

map, filter, collect

Transformer des séquences

map, filter, collect est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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.

Transformer des séquences

Trois méthodes effectuent l’essentiel du travail dans les pipelines d’itérateurs : map transforme chaque élément, filter conserve certains éléments et collect rassemble les résultats dans une collection.

Ensemble, elles remplacent de nombreuses boucles manuelles par de courtes chaînes lisibles.

map : une entrée, une sortie

map applique une fermeture à chaque élément et produit la valeur transformée. Le nombre d’éléments reste identique ; seules leurs valeurs changent.

Cette méthode est paresseuse : la fermeture ne s’exécute que lorsque l’itérateur est consommé.

fn main() {
    let nums = vec![1, 2, 3];
    let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
    println!("{:?}", doubled);
}

map peut modifier le type

Le type de sortie de map ne doit pas nécessairement correspondre au type d’entrée. Ici, nous transformons des nombres en chaînes.

map est ainsi idéal pour convertir des données d’une forme à une autre.

fn main() {
    let nums = vec![1, 2, 3];
    let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
    println!("{:?}", labels);
}

filter&nbsp;: conserver ce que vous voulez

filter prend une fermeture qui renvoie un bool. Les éléments pour lesquels elle renvoie true sont conservés ; les autres sont supprimés.

La fermeture reçoit une référence, vous devez donc souvent la déréférencer avec * ou utiliser la déstructuration par motifs.

fn main() {
    let nums = vec![1, 2, 3, 4, 5, 6];
    let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
    println!("{:?}", evens);
}

Enchaîner map et filter

Vous pouvez enchaîner librement les adaptateurs. L’ordre compte : chaque élément traverse la chaîne de haut en bas.

Ici, nous conservons les nombres pairs, puis élevons au carré ceux qui restent.

fn main() {
    let result: Vec<i32> = (1..=6)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("{:?}", result);
}

collect dans un Vec

collect consomme un itérateur et construit une collection. Comme plusieurs types de collections sont possibles, vous indiquez généralement le type cible.

La syntaxe turbofish collect::<Vec<_>>() est une autre façon de préciser le type de la variable.

fn main() {
    let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squares);
}

collect dans une String

collect ne se limite pas aux vecteurs. Un itérateur de char peut être rassemblé dans une String.

Rust utilise le type cible pour déterminer comment assembler les éléments.

fn main() {
    let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
    println!("{}", shouted);
}

collect dans un HashMap

Un itérateur de tuples clé-valeur peut être rassemblé dans un HashMap. Associez les éléments avec zip ou construisez des tuples dans un map.

C’est une manière claire de construire des tables de recherche à partir de deux séquences parallèles.

use std::collections::HashMap;

fn main() {
    let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
    println!("{:?}", map.get(&2));
}

Combiner les trois méthodes

Un pipeline classique se lit comme une phrase : prendre les éléments, les filtrer, les transformer avec map, puis les rassembler.

Ici, nous conservons les mots de plus de trois lettres et les mettons en majuscules.

fn main() {
    let words = vec!["hi", "rust", "go", "code"];
    let kept: Vec<String> = words
        .into_iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{:?}", kept);
}

filter_map&nbsp;: filtrer et transformer en une fois

filter_map applique une fermeture qui renvoie un Option. Some(v) est conservé et déballé ; None est supprimé.

Cette méthode est particulièrement utile lors de l’analyse, lorsque certaines entrées peuvent être invalides.

fn main() {
    let inputs = vec!["1", "two", "3"];
    let nums: Vec<i32> = inputs
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("{:?}", nums);
}

Pourquoi ce modèle est efficace

Les pipelines map/filter/collect sont déclaratifs : ils indiquent ce que vous voulez, et non comment effectuer la boucle. Ils évitent les erreurs de décalage d’un élément et l’état mutable intermédiaire.

De plus, grâce à la paresse, aucun vecteur temporaire n’est construit entre les étapes.

Vérification rapide

Vérifiez ce que vous savez sur la transformation des séquences.

Récapitulatif

Vous pouvez maintenant créer de véritables chaînes d’itérateurs :

  • map transforme chaque élément et peut modifier son type
  • filter conserve les éléments dont le prédicat vaut true
  • collect rassemble les résultats dans Vec, String, HashMap, etc.
  • filter_map filtre et transforme en une seule étape à l’aide de Option

Questions Fréquemment Posées

La leçon « map, filter, collect » est-elle gratuite ?

Oui — le texte complet de « map, filter, collect » 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 « map, filter, collect » ?

Transformer des séquences 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 2 sur 4.

Combien de temps prend la leçon « map, filter, collect » ?

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

  1. Le trait Iterator
  2. map, filter, collect
  3. Adaptateurs et consommateurs
  4. Itérateurs personnalisés
← Retour à Learn Rust Coding