Gestire le varianti degli enum con match
Usi match per gestire ogni caso.
Gestire le varianti degli enum con match è 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.
Conoscere l'espressione match
L'espressione match confronta un valore con una serie di pattern ed esegue il codice del primo che corrisponde.
È il naturale complemento degli enum: può gestire ogni variante nel proprio braccio.
enum Light {
Red,
Green,
}
fn action(l: Light) {
match l {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}
}Anatomia di un braccio match
Ogni braccio ha la forma pattern => expression e i bracci sono separati da virgole.
Il pattern indica cosa confrontare, mentre l'espressione dopo => viene eseguita quando c'è una corrispondenza. Qui il pattern è una singola variante di enum.
match light {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}Un programma completo con match
Ecco un programma completo che usa match su un semaforo e stampa un'istruzione.
Lo esegua, quindi cambi la variante in main per vedere l'esecuzione di un braccio diverso.
enum TrafficLight {
Red,
Yellow,
Green,
}
fn main() {
let light = TrafficLight::Yellow;
match light {
TrafficLight::Red => println!("Stop"),
TrafficLight::Yellow => println!("Slow down"),
TrafficLight::Green => println!("Go"),
}
}match deve essere esaustivo
Rust richiede che match copra ogni variante possibile. Se ne dimentica una, il programma non verrà compilato.
È una potente funzionalità di sicurezza: se in seguito aggiunge una nuova variante, il compilatore Le ricorda tutti i punti in cui è necessario gestirla.
// This would FAIL to compile because
// the Green case is missing:
// match light {
// Light::Red => println!("Stop"),
// }Il caso generico con _
Quando non vuole elencare ogni variante, usi il trattino basso _ come pattern generico. Corrisponde a qualsiasi valore non gestito in precedenza.
Lo posizioni per ultimo, poiché i bracci vengono provati in ordine.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Dime;
match c {
Coin::Penny => println!("1 cent"),
_ => println!("Some other coin"),
}
}match restituisce un valore
match è un'espressione, quindi produce un valore che può memorizzare in una variabile.
Ogni braccio deve restituire lo stesso tipo. Noti che qui non c'è un punto e virgola dopo l'espressione di ciascun braccio.
enum Coin {
Penny,
Quarter,
}
fn main() {
let coin = Coin::Quarter;
let cents = match coin {
Coin::Penny => 1,
Coin::Quarter => 25,
};
println!("{} cents", cents);
}Corpi dei bracci su più righe
Un braccio può eseguire diverse istruzioni racchiudendole tra parentesi graffe { ... }.
L'ultima espressione all'interno delle parentesi graffe è il valore prodotto dal braccio.
match light {
Light::Red => {
println!("Caution!");
println!("Stop the car");
}
Light::Green => println!("Go"),
}Combinare i pattern con |
Usi la barra verticale | per confrontare più varianti in un unico braccio. Si legge "oppure".
In questo modo evita di ripetere lo stesso corpo per varianti che devono comportarsi nello stesso modo.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Nickel;
match c {
Coin::Penny | Coin::Nickel => println!("Small coin"),
_ => println!("Bigger coin"),
}
}match rispetto a if/else
Potrebbe concatenare if / else if per verificare le varianti, ma match è più chiaro e sicuro.
Con match, il compilatore verifica che siano stati gestiti tutti i casi. Una catena di istruzioni if non offre alcuna garanzia simile.
Confrontare e stampare insieme
Un pattern comune consiste nel trasformare una variante in una stringa descrittiva e stamparla.
Esegua questo programma e cambi la direzione selezionata per visualizzare il messaggio corrispondente.
enum Direction {
North,
South,
East,
West,
}
fn main() {
let d = Direction::West;
let name = match d {
Direction::North => "North",
Direction::South => "South",
Direction::East => "East",
Direction::West => "West",
};
println!("Heading {}", name);
}L'ordine è importante
I bracci vengono verificati dall'alto verso il basso e vince la prima corrispondenza. Gli altri vengono ignorati.
Per questo il caso generico _ deve essere inserito per ultimo: se fosse il primo, catturerebbe ogni valore prima che possano essere eseguiti i bracci specifici.
Verifica rapida
Verifichi la Sua comprensione di match.
Riepilogo
Ha imparato che match confronta un valore con dei pattern ed esegue il primo braccio corrispondente.
Deve essere esaustivo, può usare _ come caso generico, combinare varianti con | e restituire un valore perché è un'espressione. In seguito assegnerà dati propri alle varianti degli enum.
Domande Frequenti
La lezione «Gestire le varianti degli enum con match» è gratuita?
Sì — il testo completo di «Gestire le varianti degli enum con 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 «Gestire le varianti degli enum con match»?
Usi match per gestire ogni caso. 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 «Gestire le varianti degli enum con 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