Learn Rust Coding · Lezione

if let e while let

Matching conciso

if let e while let è 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.

Corrispondenza concisa

A volte interessa un solo pattern. if let e while let consentono di eseguire una corrispondenza concisa senza un match completo.

La forma if let

if let esegue un blocco solo quando un valore corrisponde a un pattern, associando eventuali dati acquisiti.

fn main() {
    let maybe = Some(10);
    if let Some(n) = maybe {
        println!("value is {n}");
    }
}

if let e match a confronto

if let è una sintassi abbreviata per un match con un solo ramo interessante e un passaggio alternativo _ => (). Lo usi quando gli altri casi non richiedono alcuna gestione.

fn main() {
    let config: Option<i32> = None;
    // match equivalent would have an empty _ arm
    if let Some(v) = config {
        println!("configured: {v}");
    }
    println!("done");
}

Aggiungere un else

Aggiunga un else per gestire il caso in cui non si verifichi alcuna corrispondenza.

fn main() {
    let result: Result<i32, String> = Err("boom".to_string());
    if let Ok(v) = result {
        println!("ok: {v}");
    } else {
        println!("failed");
    }
}

let else

let ... else esegue l'associazione quando il pattern corrisponde; altrimenti esegue un blocco divergente, come return. È ideale per le uscite anticipate.

fn parse(s: &str) -> i32 {
    let Ok(n) = s.parse::<i32>() else {
        println!("not a number");
        return 0;
    };
    n * 2
}

fn main() {
    println!("{}", parse("21"));
    println!("{}", parse("oops"));
}

La forma while let

while let continua il ciclo finché un valore corrisponde a un pattern. È perfetto per svuotare strutture come gli stack.

fn main() {
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("popped {top}");
    }
}

Iterare sugli iteratori

while let può iterare chiamando ripetutamente next e fermandosi quando restituisce None.

fn main() {
    let mut iter = [10, 20, 30].into_iter();
    while let Some(x) = iter.next() {
        println!("{x}");
    }
}

Guardie con if let

Combini una guardia aggiungendo una condizione && (Rust 2024) oppure inserendo un if annidato.

fn main() {
    let value = Some(8);
    if let Some(n) = value {
        if n > 5 {
            println!("big: {n}");
        }
    }
}

Quando usare ciascuna forma

Linee guida:

if let — gestire un pattern e ignorare il resto
let else — associare un valore o uscire subito
while let — ripetere il ciclo finché un pattern continua a corrispondere
match — quando è necessario gestire più casi

Compromesso sulla leggibilità

Queste forme riducono il codice ripetitivo, ma possono nascondere alcuni casi. Se deve gestire diversi pattern, torni a un match completo per maggiore chiarezza.

Annidare if let

Può concatenare valori opzionali annidando if let e rimuovendo un livello alla volta.

fn main() {
    let outer: Option<Option<i32>> = Some(Some(99));
    if let Some(inner) = outer {
        if let Some(value) = inner {
            println!("value is {value}");
        }
    }
}

Verifica rapida

Quale costrutto esegue ripetutamente il corpo di un ciclo finché un valore continua a corrispondere a un pattern?

Riepilogo

Ha imparato la corrispondenza concisa:

if let gestisce un singolo pattern, facoltativamente con else
let else esegue un'associazione o diverge immediatamente
while let ripete il ciclo finché un pattern corrisponde
Passi a match quando è necessario gestire più casi

Domande Frequenti

La lezione «if let e while let» è gratuita?

Sì — il testo completo di «if let e while let» è 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 «if let e while let»?

Matching conciso 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 «if let e while let»?

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