Learn Rust Coding · Lezione

Il trait Iterator

next e lazy evaluation

Il trait Iterator è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos'è un iteratore?

Un iteratore è qualunque elemento che produca una sequenza di valori, uno alla volta. In Rust, gli iteratori sono il modo idiomatico per elaborare collezioni come vettori, intervalli e slice.

L'intero concetto si basa su un singolo trait: Iterator. Quando un tipo lo implementa, si ottengono gratuitamente decine di metodi utili.

Il trait Iterator

Il trait Iterator ha un metodo obbligatorio, next, e un tipo associato, Item:

type Item — il tipo di valore prodotto
fn next(&mut self) -> Option<Self::Item> — restituisce il valore successivo

Restituisce Some(value) finché rimangono valori, quindi None al termine.

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 restituisce Option

Ogni chiamata a next fa avanzare l'iteratore e restituisce un Option. Some contiene un valore reale; None segnala la fine.

Noti che next accetta &mut self: chiamarlo modifica lo stato interno, quindi la chiamata successiva restituisce un valore diverso.

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

Gli iteratori sono lazy

Creare un iteratore da solo non fa nulla. Non viene calcolato alcun valore finché qualcosa non lo richiede. Questo comportamento si chiama laziness.

Nell'esempio successivo la closure map non viene mai eseguita, perché non consumiamo l'iteratore.

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

Il consumo avvia l'elaborazione

Per fare in modo che un iteratore lazy venga eseguito, deve consumarlo. Un ciclo for è il consumer più semplice: chiama ripetutamente next fino a None.

Ora la stessa closure map viene eseguita per ogni elemento.

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

Tre modi per iterare

Le collezioni offrono tre metodi che producono iteratori:

iter() — restituisce &T (prende in prestito)
iter_mut() — restituisce &mut T (prende in prestito in modo mutabile)
into_iter() — restituisce T (acquisisce la proprietà)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

I cicli for usano into_iter

Quando scrive direttamente for x in collection, Rust chiama into_iter(), che consuma la collezione.

Dopo questo ciclo non può usare nuovamente v, perché è stata spostata nell'iteratore.

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

Gli intervalli sono iteratori

Un intervallo come 0..5 è a sua volta un iteratore che produce 0, 1, 2, 3, 4. L'estremo finale è esclusivo. Usi 0..=5 per un intervallo inclusivo.

Gli intervalli sono ottimi per i cicli di conteggio senza dover gestire manualmente gli indici.

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

count: un consumer semplice

count consuma l'intero iteratore e restituisce il numero di elementi prodotti. È uno dei numerosi adattatori consumer.

Poiché lo consuma, non può riutilizzare l'iteratore in seguito.

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: combinare in un unico valore

sum somma tutti gli elementi e restituisce un singolo valore. Spesso si annota il tipo di destinazione, così Rust sa che cosa produrre.

È più conciso e chiaro di un ciclo manuale con accumulatore.

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

Perché gli iteratori sono importanti

Gli iteratori offrono componibilità: può concatenare piccole operazioni in pipeline chiare. Sono anche zero-cost: il compilatore li ottimizza rendendoli veloci quanto i cicli scritti a mano.

Padroneggiare next, la laziness e il consumo è la base di tutto ciò che segue.

Verifica rapida

Verifichi la sua comprensione del trait Iterator.

Riepilogo

Ha imparato i fondamenti degli iteratori di Rust:

Il trait Iterator richiede solo next e un tipo Item
next restituisce Some(value), quindi None
Gli iteratori sono lazy: non fanno nulla finché non vengono consumati
iter, iter_mut e into_iter controllano la differenza tra prestito e proprietà
I consumer come for, count e sum avviano l'elaborazione

Domande Frequenti

La lezione «Il trait Iterator» è gratuita?

Sì — il testo completo di «Il trait Iterator» è 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 «Il trait Iterator»?

next e lazy evaluation 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 1 di 4.

Quanto tempo richiede la lezione «Il trait Iterator»?

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