Lär dig programmera i Rust · Lektion

Iterator-traiten

next och lat evaluering

Lektion 1 av 413 steg

Iterator-traiten är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad är en iterator?

En iterator är något som producerar en följd av värden, ett i taget. I Rust är iteratorer det idiomatiska sättet att bearbeta samlingar som vektorer, intervall och slices.

Hela konceptet bygger på ett enda trait: Iterator. När en typ implementerar det får ni dussintals användbara metoder utan extra arbete.

Iterator-traitet

Traitet Iterator har en obligatorisk metod, next, och en associerad typ, Item:

type Item — typen av värde som produceras
fn next(&mut self) -> Option<Self::Item> — returnerar nästa värde

Det returnerar Some(value) så länge det finns värden kvar och sedan None när det är slut.

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 returnerar Option

Varje anrop till next flyttar iteratorn framåt och ger er en Option. Some omsluter ett faktiskt värde; None signalerar slutet.

Observera att next tar &mut self — anropet ändrar det interna tillståndet, så nästa anrop returnerar ett annat värde.

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

Iteratorer är lata

Att skapa en iterator gör ingenting i sig. Inga värden beräknas förrän något efterfrågar dem. Detta kallas lathet.

I nästa exempel körs map-stängningen aldrig, eftersom vi aldrig konsumerar iteratorn.

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

Konsumtion utlöser arbetet

För att få en lat iterator att faktiskt köras måste ni konsumera den. En for-loop är den enklaste konsumenten: den anropar next upprepade gånger tills den får None.

Nu körs samma map-stängning för varje element.

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

Tre sätt att iterera

Samlingar erbjuder tre metoder som skapar iteratorer:

iter() — ger &T (lånar)
iter_mut() — ger &mut T (lånar muterbart)
into_iter() — ger T (tar över ägarskapet)

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

for-loopar använder into_iter

När ni skriver for x in collection direkt anropar Rust into_iter(), vilket konsumerar samlingen.

Efter den här loopen kan ni inte använda v igen, eftersom den flyttades in i iteratorn.

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

Intervall är iteratorer

Ett intervall som 0..5 är självt en iterator som producerar 0, 1, 2, 3, 4. Slutet är exklusivt. Använd 0..=5 för ett inkluderande intervall.

Intervall passar bra för räkneloopar utan manuell hantering av index.

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

count: en enkel konsument

count konsumerar hela iteratorn och returnerar hur många objekt den producerade. Det är en av många konsumerande adaptrar.

Eftersom den konsumerar iteratorn kan ni inte återanvända den efteråt.

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

sum: vik ihop till ett värde

sum lägger ihop alla element och returnerar ett enda värde. Ofta anger Ni måltypen så att Rust vet vad som ska skapas.

Detta är mer kortfattat och tydligare än en manuell loop med ackumulator.

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

Varför iteratorer är viktiga

Iteratorer ger Er komponerbarhet: Ni kan kedja små operationer till tydliga pipelines. De har också nollkostnad — kompilatorn optimerar dem så att de blir lika snabba som handskrivna loopar.

Att behärska next, lathet och konsumtion är grunden för allt som följer.

Snabb kontroll

Testa Er förståelse av Iterator-traiten.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er grunderna i Rust-iteratorer:

Trait-en Iterator behöver endast next och en Item-typ
next returnerar Some(value) och därefter None
Iteratorer är lata — de gör ingenting förrän de konsumeras
iter, iter_mut och into_iter styr lån kontra ägarskap
Konsumenter som for, count och sum utför arbetet

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Iterator-traiten” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Iterator-traiten”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”Iterator-traiten”?

next och lat evaluering Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Iterator-traiten”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust