Learn Rust Coding · Leçon

Itérateurs personnalisés

Implémenter Iterator

Itérateurs personnalisés est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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.

Créer votre propre itérateur

Vous n’êtes pas limité aux itérateurs intégrés. En implémentant le trait Iterator sur votre propre type, celui-ci bénéficie gratuitement de tous les adaptateurs et consommateurs.

Tout ce que vous devez fournir est le type Item et une méthode next.

Une structure Counter

Commencez par une structure qui contient l’état de l’itérateur. Un compteur simple a seulement besoin d’une valeur actuelle.

struct Counter {
    count: u32,
}

fn main() {
    let c = Counter { count: 0 };
    println!("start at {}", c.count);
}

Implémenter next

Implémentez Iterator pour la structure. Définissez type Item, puis écrivez next pour faire progresser l’état et renvoyer Some jusqu’à une condition d’arrêt, puis None.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let mut c = Counter { count: 0 };
    println!("{:?}", c.next());
    println!("{:?}", c.next());
}

L’utiliser dans une boucle for

Une fois que next existe, votre type fonctionne dans une boucle for, comme n’importe quel itérateur standard.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    for n in (Counter { count: 0 }) {
        print!("{} ", n);
    }
    println!();
}

Des adaptateurs et consommateurs gratuits

Comme vous avez implémenté une seule méthode, toute la boîte à outils des itérateurs est désormais disponible. Ici, nous additionnons les carrés de valeurs de compteur associées.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let total: u32 = Counter { count: 0 }.map(|x| x * 2).sum();
    println!("{}", total);
}

Une méthode constructeur

Ajoutez une fonction new afin que les utilisateurs n’aient pas à accéder directement aux champs internes. Le code est ainsi plus propre et vous pouvez conserver le champ privé.

struct Counter { count: u32 }

impl Counter {
    fn new() -> Counter { Counter { count: 0 } }
}

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 3 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let v: Vec<u32> = Counter::new().collect();
    println!("{:?}", v);
}

Un itérateur de Fibonacci

Les itérateurs peuvent conserver un état plus riche. Un générateur de Fibonacci mémorise les deux dernières valeurs et les met à jour à chaque appel de next.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let current = self.a;
        self.a = self.b;
        self.b = current + self.b;
        Some(current)
    }
}

fn main() {
    let fib = Fib { a: 0, b: 1 };
    let seq: Vec<u64> = fib.take(8).collect();
    println!("{:?}", seq);
}

Les itérateurs infinis ne posent aucun problème

L’itérateur de Fibonacci ne renvoie jamais None : il est infini. Cela ne pose aucun problème, car la paresse signifie que les valeurs ne sont produites qu’à la demande. Utilisez take pour le borner.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let c = self.a;
        self.a = self.b;
        self.b = c + self.b;
        Some(c)
    }
}

fn main() {
    let big = Fib { a: 0, b: 1 }.nth(20);
    println!("{:?}", big);
}

Itérer sur un type enveloppe

Souvent, vous implémentez Iterator sur une structure auxiliaire qui emprunte vos données. Ici, un itérateur par pas fournit un nombre sur deux à partir d’une plage stockée à l’intérieur.

struct EvenUpTo { current: u32, max: u32 }

impl Iterator for EvenUpTo {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.current > self.max { return None; }
        let value = self.current;
        self.current += 2;
        Some(value)
    }
}

fn main() {
    let evens: Vec<u32> = (EvenUpTo { current: 0, max: 10 }).collect();
    println!("{:?}", evens);
}

Pourquoi créer des itérateurs personnalisés ?

Les itérateurs personnalisés vous permettent de diffuser des valeurs sans allouer une collection complète, de modéliser des séquences infinies ou calculées et d’offrir aux appelants une interface familière et composable.

Une petite méthode next suffit à déverrouiller tout l’écosystème.

Conseils de conception

Conservez un état minimal, renvoyez None exactement une fois à la fin (ou jamais pour les itérateurs infinis) et évitez les traitements lourds dans next afin que la paresse reste peu coûteuse.

Vérification rapide

Implémenter le trait Iterator.

Récapitulatif

Vous avez créé des itérateurs personnalisés :

Conservez l’état dans une structure, puis utilisez impl Iterator
Définissez type Item et écrivez next
Vous obtenez immédiatement et gratuitement les adaptateurs et les consommateurs
Les itérateurs peuvent être finis ou infinis ; utilisez take pour borner les itérateurs infinis

Questions Fréquemment Posées

La leçon « Itérateurs personnalisés » est-elle gratuite ?

Oui — le texte complet de « Itérateurs personnalisés » 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 « Itérateurs personnalisés » ?

Implémenter Iterator 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 4 sur 4.

Combien de temps prend la leçon « Itérateurs personnalisés » ?

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

← Retour à Learn Rust Coding