Learn Rust Coding · Lezione

map, filter, collect

Trasformazione delle sequenze

map, filter, collect è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 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.

Trasformare sequenze

Tre metodi svolgono gran parte del lavoro nelle pipeline di iteratori: map trasforma ogni elemento, filter conserva alcuni elementi e collect raccoglie i risultati in una collezione.

Insieme sostituiscono molti cicli manuali con concatenazioni brevi e leggibili.

map: uno entra, uno esce

map applica una closure a ogni elemento e restituisce il valore trasformato. Il numero di elementi rimane invariato; cambiano solo i valori.

È lazy, quindi la closure viene eseguita solo quando l'iteratore viene consumato.

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

map può cambiare il tipo

Il tipo di output di map non deve necessariamente corrispondere a quello di input. Qui trasformiamo numeri in stringhe.

Questo rende map perfetto per convertire i dati da una forma a un'altra.

fn main() {
    let nums = vec![1, 2, 3];
    let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
    println!("{:?}", labels);
}

filter: mantenere ciò che serve

filter accetta una closure che restituisce bool. Vengono mantenuti gli elementi per cui restituisce true; gli altri vengono scartati.

La closure riceve un riferimento, quindi spesso si usa il dereferenziamento con * oppure il pattern matching.

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

Concatenare map e filter

È possibile concatenare liberamente gli adapter. L'ordine è importante: ogni elemento attraversa la catena dall'alto verso il basso.

Qui vengono mantenuti i numeri pari, quindi i risultati vengono elevati al quadrato.

fn main() {
    let result: Vec<i32> = (1..=6)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("{:?}", result);
}

collect in un Vec

collect consuma un iteratore e costruisce una collezione. Poiché sono possibili molti tipi di collezione, di solito è necessario annotare il tipo di destinazione.

La sintassi turbofish collect::<Vec<_>>() è un'alternativa all'annotazione della variabile.

fn main() {
    let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squares);
}

collect in una String

collect non è limitato ai vettori. Un iteratore di char può essere raccolto in una String.

Rust usa il tipo di destinazione per decidere come assemblare gli elementi.

fn main() {
    let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
    println!("{}", shouted);
}

collect in una HashMap

Un iteratore di tuple chiave-valore può essere raccolto in una HashMap. È possibile abbinare gli elementi con zip oppure costruire tuple in una map.

È un modo chiaro per creare strutture di ricerca a partire da due sequenze parallele.

use std::collections::HashMap;

fn main() {
    let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
    println!("{:?}", map.get(&2));
}

Combinare tutti e tre

Una pipeline tipica si legge come una frase: prendere gli elementi, filtrarli, trasformarli e raccoglierli.

Qui manteniamo le parole più lunghe di tre lettere e le convertiamo in maiuscolo.

fn main() {
    let words = vec!["hi", "rust", "go", "code"];
    let kept: Vec<String> = words
        .into_iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{:?}", kept);
}

filter_map: filtrare e trasformare in un solo passaggio

filter_map applica una closure che restituisce Option. Some(v) viene mantenuto e ne viene estratto il valore; None viene scartato.

È particolarmente utile durante il parsing, quando alcuni input potrebbero non essere validi.

fn main() {
    let inputs = vec!["1", "two", "3"];
    let nums: Vec<i32> = inputs
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("{:?}", nums);
}

Perché questo pattern è efficace

Le pipeline map/filter/collect sono dichiarative: indicano che cosa si desidera, non come eseguire il ciclo. Evitano gli errori di tipo off-by-one e lo stato mutabile intermedio.

Inoltre, grazie alla lazy evaluation, tra i vari passaggi non vengono creati vettori temporanei.

Verifica rapida

Verifichi le Sue conoscenze sulla trasformazione delle sequenze.

Riepilogo

Ora è in grado di costruire vere pipeline di iteratori:

map trasforma ogni elemento e può modificarne il tipo
filter mantiene gli elementi il cui predicato è true
collect raccoglie i risultati in Vec, String, HashMap e altro ancora
filter_map filtra e trasforma in un solo passaggio usando Option

Domande Frequenti

La lezione «map, filter, collect» è gratuita?

Sì — il testo completo di «map, filter, collect» è 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 «map, filter, collect»?

Trasformazione delle sequenze 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 2 di 4.

Quanto tempo richiede la lezione «map, filter, collect»?

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