Lær at programmere i Rust · Lektion

map, filter, collect

Transformér sekvenser

Lektion 2 af 413 trin

map, filter, collect er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 2 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.

Transformation af sekvenser

Tre metoder udfører det meste af arbejdet i iteratorbehandlingskæder: map transformerer hvert element, filter beholder nogle elementer, og collect samler resultaterne i en samling.

Tilsammen erstatter de mange manuelle løkker med korte, læsbare kæder.

map: Ét ind, ét ud

map anvender en closure på hvert element og giver den transformerede værdi videre. Antallet af elementer forbliver det samme; kun deres værdier ændres.

Den er lazy, så closuren kun kører, når iteratoren forbruges.

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

map kan ændre typen

Outputtypen for map behøver ikke at være den samme som inputtypen. Her omdanner vi tal til strenge.

Det gør map ideel til at konvertere data fra én form til en anden.

fn main() {
    let nums = vec![1, 2, 3];
    let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
    println!("{:?}", labels);
}

filter: Behold det, du ønsker

filter tager en closure, der returnerer bool. Elementer, hvor den returnerer true, beholdes; resten fjernes.

Closuren modtager en reference, så du skal ofte dereferere med * eller bruge mønstermatchning.

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

Kædning af map og filter

Du kan frit kæde adaptere sammen. Rækkefølgen betyder noget: hvert element bevæger sig gennem kæden fra top til bund.

Her beholder vi lige tal og kvadrerer derefter de resterende.

fn main() {
    let result: Vec<i32> = (1..=6)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("{:?}", result);
}

collect til en Vec

collect forbruger en iterator og opbygger en samling. Da mange samlingstyper er mulige, angiver du normalt måltypen.

Turbofish-syntaksen collect::<Vec<_>>() er et alternativ til at angive variablens type.

fn main() {
    let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squares);
}

collect til en String

collect er ikke begrænset til vektorer. En iterator af char kan samles i en String.

Rust bruger måltypen til at afgøre, hvordan elementerne skal sættes sammen.

fn main() {
    let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
    println!("{}", shouted);
}

collect til en HashMap

En iterator af nøgleværdi-tupler kan samles i en HashMap. Sammensæt elementpar med zip, eller opbyg tupler i en map.

Det er en enkel måde at oprette opslag ud fra to parallelle sekvenser.

use std::collections::HashMap;

fn main() {
    let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
    println!("{:?}", map.get(&2));
}

Kombination af alle tre

En typisk behandlingskæde kan læses som en sætning: hent elementer, filtrer dem, transformér dem, og saml dem.

Her beholder vi ord, der er længere end tre bogstaver, og skriver dem med store bogstaver.

fn main() {
    let words = vec!["hi", "rust", "go", "code"];
    let kept: Vec<String> = words
        .into_iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{:?}", kept);
}

filter_map: Filtrér og transformér på én gang

filter_map anvender en closure, der returnerer Option. Some(v) beholdes og pakkes ud; None fjernes.

Den er særligt nyttig ved parsing, hvor nogle inputværdier kan være ugyldige.

fn main() {
    let inputs = vec!["1", "two", "3"];
    let nums: Vec<i32> = inputs
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("{:?}", nums);
}

Hvorfor dette mønster er effektivt

map/filter/collect-behandlingskæder er deklarative: De angiver hvad du ønsker, ikke hvordan du skal løkke. De undgår fejl med forskudte grænser og mellemtilstand, der kan ændres.

Og takket være den dovne evaluering oprettes der ingen midlertidige vektorer mellem trinnene.

Hurtigt tjek

Undersøg, hvad du ved om transformation af sekvenser.

Besvar den i den interaktive lektion

Opsamling

Du kan nu opbygge rigtige iteratorbehandlingskæder:

map transformerer hvert element og kan ændre dets type
filter beholder elementer, hvis prædikat er true
collect samler resultater i Vec, String, HashMap og meget mere
filter_map filtrerer og transformerer i ét trin ved hjælp af Option

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 “map, filter, collect” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “map, filter, collect”, 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 “map, filter, collect”?

Transformér sekvenser 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 2 af 4.

Hvor lang tid tager lektionen “map, filter, collect”?

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

← Tilbage til Lær at programmere i Rust