Leer programmeren met Rust · Les

Collecties doorlopen

for en iterators

Les 4 van 413 stappen

Collecties doorlopen is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

Lussen met for

De for-lus is de eenvoudigste manier om elk element in een verzameling te bezoeken.

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

Door bereiken lussen

Bereiken leveren een reeks op waarover je kunt itereren. 1..5 sluit het einde uit; 1..=5 neemt het einde wel mee.

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

De methode iter

Met .iter() maak je een iterator die verwijzingen naar elk element oplevert. Iterators zijn lui totdat je ze verbruikt.

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

Drie manieren om te itereren

Vectoren bieden drie manieren om te itereren:

iter() — levert &T (lenen).
iter_mut() — levert &mut T (veranderlijk lenen).
into_iter() — levert T (eigendom overnemen).

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

Transformeren met map

map past een closure toe op elk element en produceert een nieuwe iterator. Gebruik collect om de resultaten te verzamelen.

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

Selecteren met filter

filter houdt alleen elementen over waarvoor de closure true retourneert.

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

Samenvoegen met sum en count

Verbruikende methoden reduceren een iterator tot één waarde, zoals sum, count, max en 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);
}

Adapters koppelen

Iteratormethoden kunnen worden gekoppeld tot een duidelijke pipeline. Elke stap transformeert de stroom voordat de uiteindelijke verbruiker deze verwerkt.

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 voor indices

enumerate koppelt elk element aan zijn index en levert tuples (index, value).

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

Een HashMap itereren

Iterators werken ook met maps. Een lus levert tuples met sleutel en waarde op.

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 versus iteratormethoden

Een gewone for-lus is ideaal voor neveneffecten zoals afdrukken. Iteratoradapters (map, filter, sum) zijn vooral geschikt wanneer je gegevens omzet in een nieuwe waarde.

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

Snelle controle

Haal de rol van iteratoradapters terug.

Beantwoord dit in de interactieve les

Samenvatting

Collecties doorlopen in Rust:

for x in &collection voor eenvoudige lussen.
iter, iter_mut, into_iter bepalen hoe er geleend wordt.
Adapters: map, filter, enumerate.
Verbruikers: 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);
}

Gratis beginnen

Leer Rust met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Collecties doorlopen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Collecties doorlopen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

Wat leer ik in “Collecties doorlopen”?

for en iterators Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Collecties doorlopen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Vectors
Strings en &str
HashMaps
Collecties doorlopen

← Terug naar Leer programmeren met Rust