Learn Rust Coding · Lekcja

Adaptery i konsumenci

Łączenie operacji

Adaptery i konsumenci to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 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.

Dwa rodzaje metod

Metody iteratorów dzielą się na dwie grupy:

Adaptery zwracają nowy iterator i działają leniwie (map, filter, take)
Konsumenci uruchamiają iterator i tworzą końcową wartość (sum, collect, for_each)

Każdy potok składa się z zera lub większej liczby adapterów, po których następuje dokładnie jeden konsument.

take: ogranicz liczbę elementów

take(n) zwraca najwyżej n elementów, a następnie kończy działanie. Jest adapterem, więc zachowuje leniwe działanie.

Działa także z nieskończonymi iteratorami, pobierając tylko tyle elementów, ile potrzeba.

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: pomiń pierwsze elementy

skip(n) odrzuca pierwszych n elementów i zwraca pozostałe. Można połączyć je z take, aby pobrać fragment ze środka sekwencji.

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: dodaj indeks

enumerate zwraca krotki (index, value), numerując elementy od zera. To idiomatyczny sposób uzyskiwania pozycji bez ręcznego licznika.

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

zip: przechodź równocześnie przez dwa iteratory

zip łączy elementy z dwóch iteratorów w pary. Kończy działanie, gdy skończy się krótszy iterator.

Przydaje się to do łączenia równoległych danych, takich jak imiona i wyniki.

fn main() {
    let names = vec!["Ana", "Ben"];
    let ages = vec![30, 25];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} is {}", name, age);
    }
}

rev: odwróć kolejność

rev zwraca elementy od końca do początku. Wymaga iteratora dwukierunkowego, który zapewniają zakresy i wycinki.

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: połącz dwa iteratory

chain przeprowadza pierwszy iterator do końca, a następnie kontynuuje działanie z drugim, jakby oba tworzyły jedną sekwencję.

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: zbuduj pojedynczą wartość

fold to uniwersalny konsument. Rozpoczyna od akumulatora i za pomocą domknięcia składa w nim każdy element.

Wielu konsumentów, takich jak sum, to szczególne przypadki fold.

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any i all: konsumenci logiczni

any zwraca true, jeśli co najmniej jeden element spełnia predykat; all zwraca true tylko wtedy, gdy spełniają go wszystkie elementy.

Obie metody stosują short-circuiting: kończą działanie, gdy tylko znany jest wynik.

fn main() {
    let nums = vec![2, 4, 6, 7];
    println!("{}", nums.iter().all(|x| x % 2 == 0));
    println!("{}", nums.iter().any(|x| x % 2 != 0));
}

find i position

find zwraca pierwszy element pasujący do predykatu jako Option. position zwraca zamiast tego indeks pierwszego pasującego elementu.

Obie metody kończą działanie po znalezieniu pierwszego dopasowania.

fn main() {
    let nums = vec![1, 3, 5, 8, 9];
    println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
    println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}

Projektowanie potoków

Buduj potoki, układając adaptery, a następnie kończąc je jednym konsumentem. Zachowaj czytelność: jedna operacja w każdym wierszu.

Ponieważ adaptery działają leniwie, nawet długie łańcuchy wykonują tylko jedno przejście po danych.

Szybkie sprawdzenie

Adaptery a konsumenci.

Podsumowanie

Omówiono łączenie operacji:

Adaptery (take, skip, enumerate, zip, rev, chain) zachowują leniwe działanie
Konsumenci (fold, any, all, find, position) kończą pracę
Konsumenci logiczni i wyszukujący stosują short-circuiting
Każdy potok składa się z adapterów, a następnie jednego konsumenta

Często zadawane pytania

Czy lekcja „Adaptery i konsumenci” jest bezpłatna?

Tak — pełny tekst „Adaptery i konsumenci” 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 „Adaptery i konsumenci”?

Łączenie operacji Ć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 3 z 4.

Ile czasu zajmuje lekcja „Adaptery i konsumenci”?

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

← Powrót do Learn Rust Coding