0Pricing
Learn Rust Coding · Lekcja

Iterowanie po kolekcjach

for i iteratory

Iterowanie po kolekcjach to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Pętla for

Pętla for to najprostszy sposób na odwiedzenie każdego elementu kolekcji.

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

Iterowanie po zakresach

Zakresy tworzą sekwencję, po której można iterować. 1..5 nie obejmuje końca, a 1..=5 go obejmuje.

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

Metoda iter

Wywołanie .iter() tworzy iterator, który zwraca odwołania do kolejnych elementów. Iteratory są leniwe, dopóki nie zostaną wykorzystane.

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

Trzy sposoby iterowania

Wektory oferują trzy sposoby iterowania:

  • iter() — zwraca &T (pożycza).
  • iter_mut() — zwraca &mut T (pożycza mutowalnie).
  • into_iter() — zwraca T (przejmuje własność).
fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

Przekształcanie za pomocą map

map stosuje domknięcie do każdego elementu, tworząc nowy iterator. Użyj collect, aby zebrać wyniki.

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

Wybieranie za pomocą filter

filter zachowuje tylko te elementy, dla których domknięcie zwraca 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);
}

Agregowanie za pomocą sum i count

Metody zużywające iterator redukują go do jednej wartości, na przykład sum, count, max i 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);
}

Łączenie adapterów

Metody iteratorów można łączyć w przejrzysty potok. Każdy krok przekształca strumień przed jego końcowym wykorzystaniem.

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 dla indeksów

enumerate łączy każdy element z jego indeksem, zwracając krotki (index, value).

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

Iterowanie po HashMap

Iteratory działają również na mapach. Iteracja zwraca krotki klucz-wartość.

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

Pętla for a metody iteratorów

Zwykła pętla for świetnie nadaje się do efektów ubocznych, takich jak wyświetlanie. Adaptery iteratorów (map, filter, sum) sprawdzają się przy przekształcaniu danych w nową wartość.

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

Szybkie sprawdzenie

Przypomnij sobie, jaką rolę pełnią adaptery iteratorów.

Podsumowanie

Iterowanie po kolekcjach w Rust:

  • for x in &collection służy do prostych pętli.
  • iter, iter_mut, into_iter określają sposób pożyczania.
  • Adaptery: map, filter, enumerate.
  • Konsumenci: 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);
}

Często zadawane pytania

Czy lekcja „Iterowanie po kolekcjach” jest bezpłatna?

Tak — pełny tekst „Iterowanie po kolekcjach” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Iterowanie po kolekcjach”?

for i iteratory Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Iterowanie po kolekcjach”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wektory
  2. Napisy i &str
  3. HashMapy
  4. Iterowanie po kolekcjach
← Powrót do Learn Rust Coding