Lær at programmere i Rust · Lektion

Gennemløb af samlinger

for og iteratorer

Lektion 4 af 413 trin

Gennemløb af samlinger er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Løkker med for

for-løkken er den enkleste måde at besøge hvert element i en samling på.

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

Løkker over områder

Områder producerer en sekvens, som du kan iterere over. 1..5 er eksklusivt; 1..=5 inkluderer slutningen.

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

Metoden iter

Et kald til .iter() opretter en iterator, der giver referencer til hvert element. Iteratorer er dovne, indtil de forbruges.

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

Tre måder at iterere på

Vektorer tilbyder tre iterationsformer:

iter() — giver &T (lån).
iter_mut() — giver &mut T (foranderligt lån).
into_iter() — giver T (overtager ejerskabet).

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

Transformation med map

map anvender en closure på hvert element og producerer en ny iterator. Brug collect til at samle resultaterne.

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

Udvælgelse med filter

filter beholder kun de elementer, som closuren 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);
}

Aggregering med sum og count

Forbrugende metoder reducerer en iterator til én værdi, 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);
}

Kædning af adaptere

Iteratormetoder kan kædes sammen til en tydelig pipeline. Hvert trin transformerer datastrømmen før den endelige forbruger.

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

enumerate parrer hvert element med dets indeks og giver tuplerne (index, value).

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

Iteration over et HashMap

Iteratorer fungerer også på maps. En løkke giver tupler med nøgler og værdier.

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 sammenlignet med Iterator-metoder

En almindelig for-løkke er god til bivirkninger som udskrivning. Iterator-adaptere (map, filter, sum) er særligt nyttige, når du omdanner data til en ny værdi.

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

Hurtigt tjek

Husk, hvilken rolle iterator-adaptere spiller.

Besvar den i den interaktive lektion

Opsummering

Iteration over samlinger i Rust:

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

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Gennemløb af samlinger” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Gennemløb af samlinger”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Gennemløb af samlinger”?

for og iteratorer Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Gennemløb af samlinger”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Vektorer
Strings og &str
HashMaps
Gennemløb af samlinger

← Tilbage til Lær at programmere i Rust