Learn Rust Coding · Lektion

map, filter, collect

Sequenzen transformieren

map, filter, collect ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Sequenzen transformieren

Drei Methoden übernehmen den Großteil der Arbeit in Iterator-Pipelines: map transformiert jedes Element, filter behält bestimmte Elemente bei und collect sammelt Ergebnisse in einer Collection.

Zusammen ersetzen sie viele manuelle Schleifen durch kurze, gut lesbare Ketten.

map: Eins hinein, eins hinaus

map wendet eine Closure auf jedes Element an und liefert den transformierten Wert. Die Anzahl der Elemente bleibt gleich; nur ihre Werte ändern sich.

Die Auswertung erfolgt verzögert, daher wird die Closure erst ausgeführt, wenn der Iterator verbraucht wird.

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

map kann den Typ ändern

Der Ausgabetyp von map muss nicht dem Eingabetyp entsprechen. Hier wandeln wir Zahlen in Strings um.

Dadurch eignet sich map ideal, um Daten von einer Form in eine andere umzuwandeln.

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

filter: Behalten Sie, was Sie brauchen

filter erwartet eine Closure, die bool zurückgibt. Elemente, für die sie true zurückgibt, werden behalten; der Rest wird verworfen.

Die Closure erhält eine Referenz. Deshalb dereferenzieren Sie häufig mit * oder verwenden Pattern Matching.

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

map und filter verketten

Sie können Adapter beliebig verketten. Die Reihenfolge ist wichtig: Jedes Element durchläuft die Kette von oben nach unten.

Hier behalten wir gerade Zahlen und quadrieren anschließend die verbleibenden Elemente.

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

collect in einen Vec

collect verbraucht einen Iterator und erstellt eine Collection. Da mehrere Collection-Typen möglich sind, annotieren Sie normalerweise den Zieltyp.

Die Turbofish-Syntax collect::<Vec<_>>() ist eine Alternative zur Annotation der Variablen.

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

collect in einen String

collect ist nicht auf Vektoren beschränkt. Ein Iterator über char-Werte kann in einen String gesammelt werden.

Rust verwendet den Zieltyp, um zu entscheiden, wie die Elemente zusammengesetzt werden.

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

collect in eine HashMap

Ein Iterator über Schlüssel-Wert-Tupel kann in eine HashMap gesammelt werden. Verknüpfen Sie Elemente mit zip oder erstellen Sie Tupel in einem map.

So lassen sich aus zwei parallelen Sequenzen übersichtlich Nachschlagetabellen erstellen.

use std::collections::HashMap;

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

Alle drei kombinieren

Eine typische Pipeline liest sich wie ein Satz: Elemente nehmen, filtern, transformieren und sammeln.

Hier behalten wir Wörter mit mehr als drei Buchstaben und schreiben sie in Großbuchstaben um.

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: Filtern und Transformieren auf einmal

filter_map wendet eine Closure an, die Option zurückgibt. Some(v) wird behalten und entpackt; None wird verworfen.

Besonders nützlich ist das beim Parsen, wenn einige Eingaben ungültig sein können.

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

Warum dieses Muster überzeugt

map/filter/collect-Pipelines sind deklarativ: Sie sagen, was Sie möchten, nicht wie Sie eine Schleife schreiben. Sie vermeiden Off-by-one-Fehler und veränderlichen Zwischenzustand.

Dank der verzögerten Auswertung werden zwischen den Schritten außerdem keine temporären Vektoren erstellt.

Kurzer Test

Überprüfen Sie Ihr Wissen über die Transformation von Sequenzen.

Zusammenfassung

Sie können nun echte Iterator-Pipelines erstellen:

map transformiert jedes Element und kann dessen Typ ändern
filter behält Elemente bei, deren Prädikat true ergibt
collect sammelt Ergebnisse in Vec, String, HashMap und weiteren Typen
filter_map filtert und transformiert in einem Schritt mithilfe von Option

Häufig gestellte Fragen

Ist die Lektion „map, filter, collect“ kostenlos?

Ja — der vollständige Text von „map, filter, collect“ 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 „map, filter, collect“?

Sequenzen transformieren 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 2 von 4.

Wie lange dauert die Lektion „map, filter, collect“?

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