Adaptere og forbrugere
Kædning af operationer
Adaptere og forbrugere er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 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.
To slags metoder
Iterator-metoder falder i to grupper:
- Adaptere returnerer en ny iterator og er lazy (
map,filter,take) - Forbrugere kører iteratoren og producerer en endelig værdi (
sum,collect,for_each)
Enhver behandlingskæde består af nul eller flere adaptere efterfulgt af præcis én forbruger.
take: Begræns antallet
take(n) giver højst n elementer videre og stopper derefter. Det er en adapter, så den forbliver lazy.
Den fungerer også på uendelige iteratorer, fordi den kun tager det antal elementer, du beder om.
fn main() {
let first_three: Vec<i32> = (1..).take(3).collect();
println!("{:?}", first_three);
}skip: Ignorér de første elementer
skip(n) fjerner de første n elementer og giver resten videre. Kombinér den med take for at hente et udsnit fra midten.
fn main() {
let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
println!("{:?}", window);
}enumerate: Par med et indeks
enumerate giver tuplerne (index, value) videre og tæller fra nul. Det er den idiomatiske måde at få positioner på uden en manuel tæller.
fn main() {
let letters = vec!['a', 'b', 'c'];
for (i, c) in letters.iter().enumerate() {
println!("{} -> {}", i, c);
}
}zip: Gå gennem to iteratorer sammen
zip parrer elementer fra to iteratorer. Den stopper, når den korteste iterator løber tør.
Det er praktisk til at kombinere parallelle data som navne og resultater.
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: Vend rækkefølgen
rev giver elementerne videre bagfra. Den kræver en iterator, der kan gennemløbes fra begge ender, hvilket intervaller og slices understøtter.
fn main() {
let backwards: Vec<i32> = (1..=5).rev().collect();
println!("{:?}", backwards);
}chain: Forbind to iteratorer
chain kører den første iterator færdig og fortsætter derefter med den anden, som om de var én sekvens.
fn main() {
let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
println!("{:?}", joined);
}fold: Opbyg én enkelt værdi
fold er den generelle forbruger. Den starter med en akkumulator og folder hvert element ind i den ved hjælp af en closure.
Mange forbrugere som sum er specialtilfælde af fold.
fn main() {
let product = (1..=5).fold(1, |acc, x| acc * x);
println!("5! = {}", product);
}any og all: Booleske forbrugere
any returnerer true, hvis mindst ét element opfylder prædikatet; all returnerer true, kun hvis alle elementer gør det.
Begge kortslutter: De stopper, så snart svaret er kendt.
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 og position
find returnerer det første element, der matcher et prædikat, som en Option. position returnerer i stedet indekset for det første match.
Begge kortslutter ved det første fund.
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));
}Design af behandlingskæder
Opbyg behandlingskæder ved at stable adaptere og derefter afslutte med én forbruger. Gør dem læsbare: én operation pr. linje.
Da adaptere er lazy, gennemløber selv lange kæder kun dataene én gang.
Hurtigt tjek
Adaptere kontra forbrugere.
Opsamling
Du har udforsket kædning af operationer:
- Adaptere (
take,skip,enumerate,zip,rev,chain) forbliver lazy - Forbrugere (
fold,any,all,find,position) afslutter arbejdet - Booleske forbrugere og søgeforbrugere kortslutter
- Enhver behandlingskæde består af adaptere efterfulgt af én forbruger
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
Ofte stillede spørgsmål
Er lektionen “Adaptere og forbrugere” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Adaptere og forbrugere”, 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 “Adaptere og forbrugere”?
Kædning af operationer 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 3 af 4.
Hvor lang tid tager lektionen “Adaptere og forbrugere”?
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
- Iterator-traitet
- map, filter, collect
- Adaptere og forbrugere
- Brugerdefinerede iteratorer