Learn Rust Coding · Lezione

Adattatori e consumer

Concatenazione delle operazioni

Adattatori e consumer è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Due tipi di metodi

I metodi degli iteratori si dividono in due gruppi:

Adapter: restituiscono un nuovo iteratore e sono lazy (map, filter, take)
Consumer: eseguono l'iteratore e producono un valore finale (sum, collect, for_each)

Ogni pipeline è composta da zero o più adapter seguiti esattamente da un consumer.

take: limitare il numero di elementi

take(n) produce al massimo n elementi, poi si arresta. È un adapter, quindi rimane lazy.

Funziona anche con iteratori infiniti, producendo solo il numero di elementi richiesto.

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

skip: ignorare i primi elementi

skip(n) scarta i primi n elementi e produce i rimanenti. Lo combini con take per estrarre una finestra dalla parte centrale.

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

enumerate: abbinare un indice

enumerate produce tuple (index, value), contando da zero. È il modo idiomatico per ottenere le posizioni senza un contatore manuale.

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

zip: scorrere insieme due iteratori

zip abbina gli elementi di due iteratori. Si arresta quando uno dei due, quello più corto, esaurisce i propri elementi.

È utile per combinare dati paralleli, come nomi e punteggi.

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: invertire l'ordine

rev produce gli elementi dalla fine all'inizio. Richiede un iteratore double-ended, fornito da intervalli e slice.

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

chain: unire due iteratori

chain esegue il primo iteratore fino al completamento, quindi continua con il secondo, come se fossero un'unica sequenza.

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

fold: costruire un singolo valore

fold è il consumer generico. Inizia con un accumulatore e incorpora ogni elemento al suo interno usando una closure.

Molti consumer, come sum, sono casi particolari di fold.

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

any e all: consumer booleani

any restituisce true se almeno un elemento soddisfa il predicato; all restituisce true solo se lo soddisfano tutti.

Entrambi applicano lo short-circuit: si arrestano non appena la risposta è nota.

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 e position

find restituisce il primo elemento che corrisponde a un predicato come Option. position restituisce invece l'indice della prima corrispondenza.

Entrambi applicano lo short-circuit alla prima corrispondenza.

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

Progettare le pipeline

Costruisca le pipeline impilando gli adapter e terminando con un consumer. Le mantenga leggibili: una singola operazione per riga.

Poiché gli adapter sono lazy, anche le catene lunghe effettuano un solo passaggio sui dati.

Verifica rapida

Adapter e consumer.

Riepilogo

Ha esplorato la concatenazione delle operazioni:

Gli adapter (take, skip, enumerate, zip, rev, chain) rimangono lazy
I consumer (fold, any, all, find, position) completano l'elaborazione
I consumer booleani e di ricerca applicano lo short-circuit
Ogni pipeline consiste in adapter seguiti da un consumer

Domande Frequenti

La lezione «Adattatori e consumer» è gratuita?

Sì — il testo completo di «Adattatori e consumer» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Adattatori e consumer»?

Concatenazione delle operazioni Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Adattatori e consumer»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding