Cecha Iterator
next i leniwe przetwarzanie
Cecha Iterator to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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.
Czym jest iterator?
Iterator to dowolny element, który zwraca sekwencję wartości, po jednej naraz. W Rust iteratory są idiomatycznym sposobem przetwarzania kolekcji, takich jak wektory, zakresy i wycinki.
Cała koncepcja opiera się na jednej cesze: Iterator. Gdy typ ją implementuje, otrzymuje dziesiątki przydatnych metod.
Cecha Iterator
Cecha Iterator wymaga jednej metody, next, oraz jednego typu powiązanego, Item:
type Item— rodzaj zwracanej wartościfn next(&mut self) -> Option<Self::Item>— zwraca następną wartość
Zwraca Some(value), dopóki pozostają jeszcze wartości, a po zakończeniu zwraca None.
fn main() {
let v = vec![10, 20, 30];
let mut it = v.iter();
println!("{:?}", it.next());
println!("{:?}", it.next());
println!("{:?}", it.next());
println!("{:?}", it.next());
}next zwraca Option
Każde wywołanie next przesuwa iterator i przekazuje wartość typu Option. Some opakowuje rzeczywistą wartość, a None sygnalizuje koniec.
Zauważ, że next przyjmuje &mut self — wywołanie zmienia stan wewnętrzny, dzięki czemu następne wywołanie zwróci inną wartość.
fn main() {
let mut it = (1..4).into_iter();
while let Some(n) = it.next() {
println!("got {}", n);
}
println!("done");
}Iteratory są leniwe
Samo utworzenie iteratora nie robi nic. Żadne wartości nie są obliczane, dopóki coś o nie nie poprosi. Nazywa się to leniwością.
W następnym przykładzie domknięcie map nigdy się nie wykona, ponieważ iterator nie zostanie skonsumowany.
fn main() {
let nums = vec![1, 2, 3];
let _doubled = nums.iter().map(|x| {
println!("mapping {}", x);
x * 2
});
println!("nothing printed above this line");
}Konsumowanie uruchamia pracę
Aby leniwy iterator rzeczywiście zaczął działać, należy go skonsumować. Pętla for jest najprostszym konsumentem: wielokrotnie wywołuje next, aż otrzyma None.
Teraz to samo domknięcie map wykona się dla każdego elementu.
fn main() {
let nums = vec![1, 2, 3];
for x in nums.iter().map(|x| x * 2) {
println!("value {}", x);
}
}Trzy sposoby iterowania
Kolekcje udostępniają trzy metody tworzące iteratory:
iter()— zwraca&T(pożycza)iter_mut()— zwraca&mut T(pożycza mutowalnie)into_iter()— zwracaT(przejmuje własność)
fn main() {
let mut v = vec![1, 2, 3];
for x in v.iter_mut() {
*x += 10;
}
println!("{:?}", v);
}Pętle for używają into_iter
Gdy bezpośrednio napiszesz for x in collection, Rust wywoła into_iter(), który skonsumuje kolekcję.
Po tej pętli nie można ponownie użyć v, ponieważ została przeniesiona do iteratora.
fn main() {
let v = vec![String::from("a"), String::from("b")];
for s in v {
println!("{}", s);
}
// v is no longer usable here
}Zakresy są iteratorami
Zakres taki jak 0..5 sam jest iteratorem zwracającym wartości 0, 1, 2, 3, 4. Koniec zakresu jest wyłączny. Użyj 0..=5, aby utworzyć zakres domknięty.
Zakresy świetnie nadają się do pętli zliczających bez ręcznego śledzenia indeksu.
fn main() {
for i in 0..5 {
print!("{} ", i);
}
println!();
for i in 1..=3 {
print!("{} ", i);
}
println!();
}count: prosty konsument
count konsumuje cały iterator i zwraca liczbę wygenerowanych przez niego elementów. Jest jednym z wielu adapterów konsumujących.
Ponieważ iterator zostaje skonsumowany, nie można go później ponownie użyć.
fn main() {
let total = (1..=100).count();
println!("there are {} numbers", total);
}sum: składanie do jednej wartości
sum dodaje do siebie wszystkie elementy i zwraca pojedynczą wartość. Często adnotuje się typ docelowy, aby Rust wiedział, jaki wynik utworzyć.
To rozwiązanie jest krótsze i bardziej przejrzyste niż ręczna pętla z akumulatorem.
fn main() {
let total: i32 = (1..=5).sum();
println!("sum is {}", total);
}Dlaczego iteratory są ważne
Iteratory zapewniają komponowalność: można łączyć małe operacje w przejrzyste potoki. Są także bezpłatne wydajnościowo — kompilator optymalizuje je tak, aby działały równie szybko jak pętle napisane ręcznie.
Opanowanie next, leniwego działania i konsumowania iteratorów stanowi podstawę wszystkiego, co nastąpi dalej.
Szybkie sprawdzenie
Sprawdź swoją znajomość cechy Iterator.
Podsumowanie
Opanowano podstawy iteratorów w Rust:
- Cecha
Iteratorwymaga jedynienextoraz typuItem nextzwraca najpierwSome(value), a następnieNone- Iteratory są leniwe — nic nie robią, dopóki nie zostaną skonsumowane
iter,iter_mutiinto_iterokreślają pożyczanie lub własność- Konsumenci, tacy jak
for,countisum, wykonują pracę
Często zadawane pytania
Czy lekcja „Cecha Iterator” jest bezpłatna?
Tak — pełny tekst „Cecha Iterator” 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 „Cecha Iterator”?
next i leniwe przetwarzanie Ć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 1 z 4.
Ile czasu zajmuje lekcja „Cecha Iterator”?
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.