Learn Rust Coding · Lektion

Das Iterator-Trait

next und Lazy-Auswertung

Das Iterator-Trait ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Iterator?

Ein Iterator ist alles, was eine Folge von Werten nacheinander erzeugt. In Rust sind Iteratoren der idiomatische Weg, Sammlungen wie Vektoren, Bereiche und Slices zu verarbeiten.

Das gesamte Konzept basiert auf einem einzigen Trait: Iterator. Sobald ein Typ ihn implementiert, stehen Ihnen zahlreiche nützliche Methoden automatisch zur Verfügung.

Das Iterator-Trait

Das Iterator-Trait besitzt eine erforderliche Methode, next, und einen zugehörigen Typ, Item:

type Item — die Art des erzeugten Werts
fn next(&mut self) -> Option<Self::Item> — gibt den nächsten Wert zurück

Solange Werte vorhanden sind, gibt es Some(value) zurück; nach dem Ende None.

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 gibt Option zurück

Jeder Aufruf von next bewegt den Iterator weiter und gibt Ihnen ein Option. Some enthält einen tatsächlichen Wert; None signalisiert das Ende.

Beachten Sie, dass next &mut self entgegennimmt — der Aufruf verändert den internen Zustand, sodass der nächste Aufruf einen anderen Wert zurückgibt.

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

Iteratoren sind faul

Das Erzeugen eines Iterators bewirkt von selbst nichts. Werte werden erst berechnet, wenn etwas sie anfordert. Das nennt man verzögerte Auswertung.

Im nächsten Beispiel wird die map-Closure nie ausgeführt, weil wir den Iterator nie verbrauchen.

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");
}

Verbrauchen löst die Arbeit aus

Damit ein verzögerter Iterator tatsächlich ausgeführt wird, müssen Sie ihn verbrauchen. Eine for-Schleife ist der einfachste Verbraucher: Sie ruft wiederholt next auf, bis None zurückgegeben wird.

Nun wird dieselbe map-Closure für jedes Element ausgeführt.

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

Drei Arten zu iterieren

Sammlungen bieten drei Methoden, die Iteratoren erzeugen:

iter() — liefert &T (leiht aus)
iter_mut() — liefert &mut T (leiht veränderlich aus)
into_iter() — liefert T (übernimmt den Besitz)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

for-Schleifen verwenden into_iter

Wenn Sie direkt for x in collection schreiben, ruft Rust into_iter() auf, wodurch die Sammlung verbraucht wird.

Nach dieser Schleife können Sie v nicht erneut verwenden, weil es in den Iterator verschoben wurde.

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

Bereiche sind Iteratoren

Ein Bereich wie 0..5 ist selbst ein Iterator und erzeugt 0, 1, 2, 3, 4. Das Ende ist exklusiv. Verwenden Sie 0..=5 für einen inklusiven Bereich.

Bereiche eignen sich hervorragend für Zählschleifen ohne manuelle Indexverwaltung.

fn main() {
    for i in 0..5 {
        print!("{} ", i);
    }
    println!();
    for i in 1..=3 {
        print!("{} ", i);
    }
    println!();
}

count: Ein einfacher Verbraucher

count verbraucht den gesamten Iterator und gibt zurück, wie viele Elemente er erzeugt hat. Es ist einer von vielen verbrauchenden Adaptern.

Da der Iterator dabei verbraucht wird, können Sie ihn anschließend nicht wiederverwenden.

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: Zu einem Wert zusammenfalten

sum addiert alle Elemente und gibt einen einzelnen Wert zurück. Häufig annotieren Sie den Zieltyp, damit Rust weiß, was erzeugt werden soll.

Das ist prägnanter und klarer als eine manuelle Schleife mit Akkumulator.

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

Warum Iteratoren wichtig sind

Iteratoren bieten Ihnen Komponierbarkeit: Sie können kleine Operationen zu klaren Pipelines verketten. Außerdem sind sie kostenlos — der Compiler optimiert sie so, dass sie genauso schnell wie von Hand geschriebene Schleifen sind.

Die Beherrschung von next, verzögerter Auswertung und Verbrauch bildet die Grundlage für alles Weitere.

Kurzer Test

Testen Sie Ihr Verständnis des Iterator-Traits.

Zusammenfassung

Sie haben die Grundlagen der Rust-Iteratoren gelernt:

Der Iterator-Trait benötigt nur next und einen Item-Typ
next gibt zunächst Some(value) und anschließend None zurück
Iteratoren werden verzögert ausgewertet — sie tun nichts, bis sie verbraucht werden
iter, iter_mut und into_iter steuern Ausleihen und Besitz
Consumer wie for, count und sum führen die Verarbeitung aus

Häufig gestellte Fragen

Ist die Lektion „Das Iterator-Trait“ kostenlos?

Ja — der vollständige Text von „Das Iterator-Trait“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Das Iterator-Trait“?

next und Lazy-Auswertung Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Das Iterator-Trait“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding