Rust-ohjelmoinnin perusteet · Oppitunti

Kokoelmien läpikäynti

for ja iteraattorit.

Oppitunti 4/413 vaihetta

Kokoelmien läpikäynti on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Rust-ohjelmoinnin perusteet-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Silmukointi for-silmukalla

for-silmukka on yksinkertaisin tapa käsitellä kokoelman jokainen alkio.

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

Alueiden läpikäynti

Alueet tuottavat sarjan, jonka voi käydä läpi. 1..5 ei sisällä loppuarvoa, kun taas 1..=5 sisältää sen.

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

iter-metodi

.iter()-kutsun tuloksena syntyy iteraattori, joka tuottaa viittauksen jokaiseen alkioon. Iteraattorit ovat laiskoja, kunnes niitä kulutetaan.

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

Kolme tapaa iteroida

Vektoreille on kolme iteraatiotapaa:

iter() — tuottaa arvon &T (lainaus).
iter_mut() — tuottaa arvon &mut T (muokattava lainaus).
into_iter() — tuottaa arvon T (ottaa omistajuuden).

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

Muuntaminen map-metodilla

map soveltaa sulkeumaa jokaiseen alkioon ja tuottaa uuden iteraattorin. Kootkaa tulokset collect-metodilla.

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

Valitseminen filter-metodilla

filter säilyttää vain ne alkiot, joille sulkeuma palauttaa arvon true.

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

Kokoaminen sum- ja count-metodeilla

Kuluttavat metodit pelkistävät iteraattorin yhdeksi arvoksi, kuten sum-, count-, max- ja min-metodit.

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

Sovittimien ketjuttaminen

Iteraattorimetodeja voi ketjuttaa selkeäksi käsittelyketjuksi. Jokainen vaihe muuntaa virtaa ennen lopullista kuluttajaa.

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 indeksien kanssa

enumerate yhdistää jokaiseen alkioon sen indeksin ja tuottaa tupleja muodossa (index, value).

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

HashMapin läpikäynti

Iteraattorit toimivat myös map-rakenteilla. Silmukointi tuottaa avain–arvo-tuplia.

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-silmukat ja iteraattorimetodit

Tavallinen for-silmukka sopii erinomaisesti sivuvaikutuksiin, kuten tulostamiseen. Iteraattorisovittimet (map, filter, sum) ovat parhaimmillaan, kun tietoja muunnetaan uudeksi arvoksi.

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

Pikatarkistus

Palauttakaa mieleenne iteraattorisovittimien rooli.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Kokoelmien iteroiminen Rustissa:

for x in &collection yksinkertaisiin silmukoihin.
iter, iter_mut, into_iter hallitsevat lainaamista.
Sovittimet: map, filter, enumerate.
Kuluttajat: 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);
}

Aloita maksutta

Opi Rust tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 144

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Kokoelmien läpikäynti” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Kokoelmien läpikäynti”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Kokoelmien läpikäynti”?

for ja iteraattorit. Harjoittelet Rust-ohjelmoinnin perusteet-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Rust-ohjelmoinnin perusteet-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Rust-ohjelmoinnin perusteet-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Kokoelmien läpikäynti”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Rust-ohjelmoinnin perusteet-oppitunnilla?

Kyllä. Jokainen Rust-ohjelmoinnin perusteet-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Vektorit
Merkkijonot ja &str
HashMapit
Kokoelmien läpikäynti

← Takaisin: Rust-ohjelmoinnin perusteet