Learn Rust Coding · Lezione

Iterazione sulle collezioni

for e iteratori

Iterazione sulle collezioni è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 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.

Ciclare con for

Il ciclo for è il modo più semplice per visitare ogni elemento di una collezione.

fn main() {
    let nums = vec![1, 2, 3];
    for n in &nums {
        println!("{}", n);
    }
}

Ciclare su intervalli

Gli intervalli producono una sequenza su cui è possibile iterare. 1..5 esclude il limite finale; 1..=5 lo include.

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

Il metodo iter

Chiamare .iter() crea un iteratore che restituisce riferimenti a ogni elemento. Gli iteratori sono lazy finché non vengono consumati.

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

Tre modi per iterare

I vettori offrono tre modalità di iterazione:

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

fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

Trasformare con map

map applica una closure a ogni elemento, producendo un nuovo iteratore. Utilizzi collect per raccogliere i risultati.

fn main() {
    let v = vec![1, 2, 3];
    let squared: Vec<i32> = v.iter().map(|x| x * x).collect();
    println!("{:?}", squared);
}

Selezionare con filter

filter conserva solo gli elementi per i quali la closure restituisce true.

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let odds: Vec<i32> = v.into_iter().filter(|x| x % 2 == 1).collect();
    println!("{:?}", odds);
}

Aggregare con sum e count

I metodi consumatori riducono un iteratore a un singolo valore, ad esempio con sum, count, max e min.

fn main() {
    let v = vec![4, 8, 15, 16];
    let total: i32 = v.iter().sum();
    let how_many = v.iter().count();
    println!("sum {} count {}", total, how_many);
}

Comporre gli adattatori

I metodi degli iteratori possono essere concatenati in una pipeline chiara. Ogni passaggio trasforma il flusso prima del consumatore finale.

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];
    let result: i32 = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 10)
        .sum();
    println!("{}", result);
}

enumerate per gli indici

enumerate associa ogni elemento al relativo indice, restituendo tuple (index, value).

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

Iterare su una HashMap

Gli iteratori funzionano anche sulle mappe. Il ciclo restituisce tuple chiave-valore.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

for e metodi degli iteratori a confronto

Un semplice ciclo for è ottimo per gli effetti collaterali, come la stampa. Gli adattatori degli iteratori (map, filter, sum) sono ideali quando si trasformano i dati in un nuovo valore.

fn main() {
    let v = vec![2, 4, 6];
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    for x in &doubled {
        println!("{}", x);
    }
}

Verifica rapida

Ricordi il ruolo degli adattatori degli iteratori.

Riepilogo

Iterare sulle collezioni in Rust:

for x in &collection per i cicli semplici.
iter, iter_mut, into_iter controllano i prestiti.
Adattatori: map, filter, enumerate.
Consumatori: collect, sum, count, max.

fn main() {
    let prices = vec![10, 25, 40];
    let with_tax: Vec<i32> = prices.iter().map(|p| p + p / 5).collect();
    let total: i32 = with_tax.iter().sum();
    println!("{:?} total {}", with_tax, total);
}

Domande Frequenti

La lezione «Iterazione sulle collezioni» è gratuita?

Sì — il testo completo di «Iterazione sulle collezioni» è 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 «Iterazione sulle collezioni»?

for e iteratori 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 4 di 4.

Quanto tempo richiede la lezione «Iterazione sulle collezioni»?

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

Vector
Stringhe e &str
HashMap
Iterazione sulle collezioni

← Torna a Learn Rust Coding