Lær Rust-programmering · leksjon

Iterere over samlinger

for og iteratorer

Leksjon 4 av 413 trinn

Iterere over samlinger er en gratis leksjon i Lær Rust-programmering på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær Rust-programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Løkker med for

for-løkken er den enkleste måten å gå gjennom hvert element i en samling på.

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

Løkker over intervaller

Intervaller lager en sekvens du kan iterere over. 1..5 inkluderer ikke slutten, mens 1..=5 inkluderer den.

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

iter-metoden

Et kall til .iter() oppretter en iterator som gir referanser til hvert element. Iteratorer er late frem til de konsumeres.

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

Tre måter å iterere på

Vektorer tilbyr tre måter å iterere på:

iter() — gir &T (lån).
iter_mut() — gir &mut T (foranderlig lån).
into_iter() — gir T (tar eierskap).

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

Transformere med map

map bruker en closure på hvert element og produserer en ny iterator. Bruk collect for å samle resultatene.

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

Velge med filter

filter beholder bare elementer som closure-en returnerer true for.

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

Aggregere med sum og count

Konsumerende metoder reduserer en iterator til én enkelt verdi, for eksempel sum, count, max og 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);
}

Kjede adaptere

Iterator-metoder kan kjedes sammen til en tydelig prosesseringskjede. Hvert trinn transformerer datastrømmen før den endelige konsumenten.

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 for indekser

enumerate kobler hvert element sammen med indeksen sin og gir tupler på formen (index, value).

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

Iterere over en HashMap

Iteratorer fungerer også på map-er. Løkken gir tupler med nøkkel og verdi.

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 kontra iterator-metoder

En vanlig for-løkke er ypperlig for bivirkninger, for eksempel utskrift. Iterator-adaptere (map, filter, sum) er spesielt nyttige når data skal omformes til en ny verdi.

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

Rask sjekk

Husk hvilken rolle iterator-adaptere har.

Besvar den i den interaktive leksjonen

Oppsummering

Iterering over samlinger i Rust:

for x in &collection for enkle løkker.
iter, iter_mut, into_iter styrer lån.
Adaptere: map, filter, enumerate.
Konsumenter: 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 å komme i gang

Lær deg Rust med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 144

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Iterere over samlinger» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær Rust-programmering, inkludert «Iterere over samlinger», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Hva lærer jeg i «Iterere over samlinger»?

for og iteratorer Du øver på Lær Rust-programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lær Rust-programmering?

Ingen tidligere erfaring er nødvendig. Lær Rust-programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Iterere over samlinger»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lær Rust-programmering-leksjonen?

Ja. Alle Lær Rust-programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Vektorer
Strenger og &str
HashMaps
Iterere over samlinger

← Tilbake til Lær Rust-programmering