Learn Rust Coding · Lektion

Sammlungen durchlaufen

for und Iteratoren

Sammlungen durchlaufen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Mit for Schleifen

Die for-Schleife ist die einfachste Möglichkeit, jedes Element einer Collection zu besuchen.

fn main() {
    let nums = vec![1, 2, 3];
    for n in &nums {
        println!("{}", n);
    }
}

Über Bereiche iterieren

Bereiche erzeugen eine Sequenz, über die Sie iterieren können. 1..5 schließt das Ende aus; 1..=5 schließt es ein.

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

Die Methode iter

Der Aufruf von .iter() erstellt einen Iterator, der Referenzen auf jedes Element liefert. Iteratoren sind träge, bis sie verbraucht werden.

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

Drei Arten zu iterieren

Vektoren bieten drei Iterationsarten:

iter() — liefert &T (Ausleihen).
iter_mut() — liefert &mut T (veränderliches Ausleihen).
into_iter() — liefert T (übernimmt den Besitz).

fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

Mit map transformieren

map wendet eine Closure auf jedes Element an und erzeugt einen neuen Iterator. Verwenden Sie collect, um die Ergebnisse zu sammeln.

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

Mit filter auswählen

filter behält nur die Elemente, für die die Closure true zurückgibt.

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

Mit sum und count aggregieren

Verbrauchende Methoden reduzieren einen Iterator auf einen einzelnen Wert, beispielsweise sum, count, max und min.

fn main() {
    let v = vec![4, 8, 15, 16];
    let total: i32 = v.iter().sum();
    let how_many = v.iter().count();
    println!("sum {} count {}", total, how_many);
}

Adapter verketten

Iteratormethoden können zu einer klaren Pipeline verkettet werden. Jeder Schritt transformiert den Datenstrom, bevor ihn der abschließende Verbraucher verarbeitet.

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];
    let result: i32 = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 10)
        .sum();
    println!("{}", result);
}

enumerate für Indizes

enumerate paart jedes Element mit seinem Index und liefert Tupel der Form (index, value).

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

Über eine HashMap iterieren

Iteratoren funktionieren auch mit Maps. Beim Durchlaufen werden Schlüssel-Wert-Tupel geliefert.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

for-Schleifen vs. Iterator-Methoden

Eine einfache for-Schleife eignet sich hervorragend für Seiteneffekte wie das Ausgeben von Text. Iterator-Adapter (map, filter, sum) spielen ihre Stärke aus, wenn Daten in einen neuen Wert umgewandelt werden.

fn main() {
    let v = vec![2, 4, 6];
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    for x in &doubled {
        println!("{}", x);
    }
}

Kurze Überprüfung

Rufen Sie sich die Aufgabe von Iterator-Adaptern ins Gedächtnis.

Zusammenfassung

Sammlungen in Rust durchlaufen:

for x in &collection für einfache Schleifen.
iter, iter_mut, into_iter steuern das Ausleihen.
Adapter: map, filter, enumerate.
Verbraucher: collect, sum, count, max.

fn main() {
    let prices = vec![10, 25, 40];
    let with_tax: Vec<i32> = prices.iter().map(|p| p + p / 5).collect();
    let total: i32 = with_tax.iter().sum();
    println!("{:?} total {}", with_tax, total);
}

Häufig gestellte Fragen

Ist die Lektion „Sammlungen durchlaufen“ kostenlos?

Ja — der vollständige Text von „Sammlungen durchlaufen“ 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 „Sammlungen durchlaufen“?

for und Iteratoren 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 4 von 4.

Wie lange dauert die Lektion „Sammlungen durchlaufen“?

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

Vektoren
Strings und &str
HashMaps
Sammlungen durchlaufen

← Zurück zu Learn Rust Coding