Learn Rust Coding · Lektion

Adapter und Consumer

Operationen verketten

Adapter und Consumer ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Zwei Arten von Methoden

Iterator-Methoden lassen sich in zwei Gruppen einteilen:

Adapter geben einen neuen Iterator zurück und werden verzögert ausgewertet (map, filter, take)
Consumer führen den Iterator aus und erzeugen einen Endwert (sum, collect, for_each)

Jede Pipeline besteht aus null oder mehr Adaptern, gefolgt von genau einem Consumer.

take: Anzahl begrenzen

take(n) liefert höchstens n Elemente und beendet sich dann. Als Adapter bleibt es verzögert.

Es funktioniert auch mit unendlichen Iteratoren und nimmt nur so viele Elemente, wie Sie anfordern.

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: Die ersten Elemente ignorieren

skip(n) verwirft die ersten n Elemente und liefert den Rest. Kombinieren Sie es mit take, um einen Ausschnitt aus der Mitte zu erhalten.

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: Mit einem Index verknüpfen

enumerate liefert (index, value)-Tupel und beginnt bei null zu zählen. Das ist der idiomatische Weg, Positionen ohne manuellen Zähler zu erhalten.

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, c) in letters.iter().enumerate() {
        println!("{} -> {}", i, c);
    }
}

zip: Zwei Iteratoren gemeinsam durchlaufen

zip verknüpft Elemente aus zwei Iteratoren. Es endet, sobald der kürzere Iterator keine weiteren Elemente mehr liefert.

Das ist praktisch, um parallele Daten wie Namen und Punktzahlen zu kombinieren.

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: Die Reihenfolge umkehren

rev liefert die Elemente in umgekehrter Reihenfolge. Dafür ist ein doppelseitiger Iterator erforderlich, wie ihn Bereiche und Slices bereitstellen.

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: Zwei Iteratoren verbinden

chain führt den ersten Iterator vollständig aus und setzt anschließend mit dem zweiten fort, als wären beide eine einzige Sequenz.

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: Einen einzelnen Wert erstellen

fold ist der allgemeine Consumer. Er beginnt mit einem Akkumulator und arbeitet jedes Element mithilfe einer Closure darin ein.

Viele Consumer wie sum sind Spezialfälle von fold.

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any und all: Boolesche Consumer

any gibt true zurück, wenn mindestens ein Element das Prädikat erfüllt; all gibt nur dann true zurück, wenn jedes Element es erfüllt.

Beide brechen frühzeitig ab: Sie stoppen, sobald das Ergebnis feststeht.

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 und position

find gibt das erste Element, das einem Prädikat entspricht, als Option zurück. position gibt stattdessen den Index des ersten passenden Elements zurück.

Beide brechen beim ersten Treffer frühzeitig ab.

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

Pipelines entwerfen

Erstellen Sie Pipelines, indem Sie Adapter aneinanderreihen und anschließend mit einem Consumer abschließen. Halten Sie sie lesbar: eine Operation pro Zeile.

Da Adapter verzögert ausgewertet werden, durchlaufen selbst lange Ketten die Daten nur einmal.

Kurzer Test

Adapter oder Consumer?

Zusammenfassung

Sie haben das Verketten von Operationen kennengelernt:

Adapter (take, skip, enumerate, zip, rev, chain) werden weiterhin verzögert ausgewertet
Consumer (fold, any, all, find, position) schließen die Verarbeitung ab
Boolesche Consumer und Such-Consumer brechen frühzeitig ab
Jede Pipeline besteht aus Adaptern und anschließend einem Consumer

Häufig gestellte Fragen

Ist die Lektion „Adapter und Consumer“ kostenlos?

Ja — der vollständige Text von „Adapter und Consumer“ 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 „Adapter und Consumer“?

Operationen verketten 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 3 von 4.

Wie lange dauert die Lektion „Adapter und Consumer“?

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