Guardie e binding in match
Aggiunga condizioni e acquisisca valori.
Guardie e binding in match è 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.
Che cos'è una guardia di match?
Una guardia di match è una condizione aggiuntiva if inserita in un braccio di match. Il braccio viene eseguito solo quando il pattern corrisponde e la condizione è vera.
Consente di suddividere una variante in casi più specifici in base ai suoi dati.
match number {
Some(n) if n > 0 => println!("positive"),
Some(n) => println!("zero or negative"),
None => println!("no number"),
}Sintassi delle guardie
Scrivete il pattern, poi if condition, quindi =>. La condizione può usare qualsiasi variabile associata dal pattern.
Se la guardia è falsa, Rust passa a provare il braccio successivo.
fn main() {
let n = 4;
match n {
x if x % 2 == 0 => println!("even"),
_ => println!("odd"),
}
}Guardie con dati degli enum
Le guardie sono particolarmente utili con gli enum che contengono dati. Associate il valore interno, quindi verificatelo.
Qui un saldo positivo e uno negativo ricevono messaggi diversi, anche se appartengono entrambi alla stessa variante.
enum Account {
Balance(i32),
Closed,
}
fn main() {
let a = Account::Balance(-5);
match a {
Account::Balance(b) if b < 0 => println!("overdrawn"),
Account::Balance(b) => println!("balance {}", b),
Account::Closed => println!("closed"),
}
}L'ordine conta ancora
Poiché i bracci vengono provati dall'alto verso il basso, mettete il braccio con guardia più specifico prima di quello generale.
Se il braccio semplice Balance(b) venisse prima, corrisponderebbe a tutto e il braccio con guardia non verrebbe mai eseguito.
Corrispondenza di valori letterali
Potete anche confrontare direttamente valori letterali specifici nel pattern, senza usare una guardia.
Qui 0 e 1 devono corrispondere esattamente, mentre _ gestisce tutti gli altri casi.
fn main() {
let n = 1;
match n {
0 => println!("zero"),
1 => println!("one"),
_ => println!("many"),
}
}Corrispondenza di intervalli
I pattern possono corrispondere a un intervallo di valori con ..=, che include entrambi gli estremi.
È un'alternativa chiara a diverse guardie di confronto.
fn main() {
let score = 85;
match score {
0..=59 => println!("fail"),
60..=100 => println!("pass"),
_ => println!("out of range"),
}
}Binding con l'operatore @
L'operatore @ consente di verificare un valore rispetto a un pattern e di associarlo contemporaneamente a un nome.
Qui id @ 1..=5 verifica l'intervallo e salva il valore effettivo in id, così potete stamparlo.
fn main() {
let n = 3;
match n {
id @ 1..=5 => println!("small id {}", id),
other => println!("other {}", other),
}
}Binding dell'intero valore
Un nome semplice in un pattern, come other qui sopra, associa l'intero valore. Funziona come un caso generico che potete comunque usare.
Usate _ quando volete ignorare il valore, e un nome quando vi serve.
fn main() {
let n = 99;
match n {
0 => println!("zero"),
value => println!("got {}", value),
}
}Guardie e binding insieme
Potete combinare un binding con una guardia per ottenere un controllo preciso: associate i dati, quindi aggiungete una condizione.
Questo programma segnala in modo speciale i saldi pari elevati.
enum Account {
Balance(i32),
}
fn main() {
let a = Account::Balance(200);
match a {
Account::Balance(b) if b > 100 && b % 2 == 0 => println!("big even {}", b),
Account::Balance(b) => println!("normal {}", b),
}
}Guardie su più pattern
Una guardia si applica all'intero braccio, anche quando il braccio combina pattern con |.
La condizione viene verificata dopo che uno qualsiasi dei pattern elencati ha trovato una corrispondenza.
fn main() {
let n = 6;
match n {
2 | 4 | 6 if n > 3 => println!("big even"),
_ => println!("other"),
}
}Mettere tutto insieme
Questo programma finale combina varianti con dati, un binding, una guardia e un caso generico per classificare una temperatura.
Modificate il valore ed eseguite nuovamente il programma per vedere l'attivazione di bracci diversi.
enum Reading {
Temp(i32),
Missing,
}
fn main() {
let r = Reading::Temp(38);
match r {
Reading::Temp(t) if t >= 38 => println!("fever: {}", t),
Reading::Temp(t) => println!("normal: {}", t),
Reading::Missing => println!("no reading"),
}
}Verifica rapida
Verificate la vostra comprensione di guardie e binding.
Riepilogo
Avete imparato a perfezionare i match con le guardie (pattern if condition), a confrontare valori letterali e intervalli (..=) e a creare binding con nomi o con l'operatore @.
Insieme a tutto ciò che avete visto prima, ora potete modellare insiemi fissi di stati, associarvi dati e reagire con precisione a ogni caso. Ottimo lavoro con gli enum e i match!
Domande Frequenti
La lezione «Guardie e binding in match» è gratuita?
Sì — il testo completo di «Guardie e binding in match» è 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 «Guardie e binding in match»?
Aggiunga condizioni e acquisisca valori. 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 «Guardie e binding in match»?
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
- Definire il primo enum
- Gestire le varianti degli enum con match
- Enum con dati
- Guardie e binding in match