Faire correspondre les variantes d’un énuméré
Utilisez match pour traiter chaque cas.
Faire correspondre les variantes d’un énuméré est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Découvrez l’expression match
L’expression match compare une valeur à une série de motifs et exécute le code du premier motif correspondant.
Elle s’associe naturellement aux énumérations : vous pouvez traiter chaque variante dans sa propre branche.
enum Light {
Red,
Green,
}
fn action(l: Light) {
match l {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}
}Anatomie d’une branche match
Chaque branche suit la forme pattern => expression, et les branches sont séparées par des virgules.
Le motif indique ce qui doit correspondre, et l’expression après => s’exécute lorsqu’il y a correspondance. Ici, le motif est une seule variante d’énumération.
match light {
Light::Red => println!("Stop"),
Light::Green => println!("Go"),
}Un programme complet avec match
Voici un programme complet qui applique un filtrage à un feu de circulation et affiche une instruction.
Exécutez-le, puis modifiez la variante dans main pour voir une autre branche s’exécuter.
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 doit être exhaustif
Rust exige que match couvre toutes les variantes possibles. Si vous en oubliez une, le programme ne compilera pas.
C’est une fonctionnalité de sécurité puissante : si vous ajoutez une nouvelle variante plus tard, le compilateur vous rappelle tous les endroits qui doivent la traiter.
// This would FAIL to compile because
// the Green case is missing:
// match light {
// Light::Red => println!("Stop"),
// }Le motif fourre-tout avec _
Lorsque vous ne souhaitez pas lister toutes les variantes, utilisez le caractère de soulignement _ comme motif fourre-tout. Il correspond à tout ce qui n’a pas été traité précédemment.
Placez-le en dernier, car les branches sont essayées dans l’ordre.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn main() {
let c = Coin::Dime;
match c {
Coin::Penny => println!("1 cent"),
_ => println!("Some other coin"),
}
}match renvoie une valeur
match est une expression, elle produit donc une valeur que vous pouvez stocker dans une variable.
Chaque branche doit renvoyer le même type. Remarquez qu’il n’y a pas de point-virgule après l’expression de chaque branche ici.
enum Coin {
Penny,
Quarter,
}
fn main() {
let coin = Coin::Quarter;
let cents = match coin {
Coin::Penny => 1,
Coin::Quarter => 25,
};
println!("{} cents", cents);
}Corps de branches sur plusieurs lignes
Une branche peut exécuter plusieurs instructions en les entourant d’accolades { ... }.
La dernière expression entre les accolades est la valeur produite par la branche.
match light {
Light::Red => {
println!("Caution!");
println!("Stop the car");
}
Light::Green => println!("Go"),
}Combiner des motifs avec |
Utilisez la barre verticale | pour faire correspondre plusieurs variantes dans une même branche. Elle se lit « ou ».
Cela évite de répéter le même corps pour des variantes qui doivent se comporter de manière identique.
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 ou if/else
Vous pourriez enchaîner if / else if pour vérifier les variantes, mais match est plus clair et plus sûr.
Avec match, le compilateur vérifie que vous avez traité tous les cas. Une suite d’instructions if n’offre aucune garantie de ce type.
Filtrer et afficher ensemble
Un schéma courant consiste à transformer une variante en chaîne de caractères conviviale, puis à l’afficher.
Exécutez ce programme et modifiez la direction choisie pour voir le message correspondant.
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’ordre est important
Les branches sont vérifiées de haut en bas, et la première correspondance l’emporte. Les suivantes sont ignorées.
C’est pourquoi le motif fourre-tout _ doit être placé en dernier : s’il était placé en premier, il intercepterait toutes les valeurs avant l’exécution des branches spécifiques.
Vérification rapide
Vérifiez votre compréhension de match.
Récapitulatif
Vous avez appris que match compare une valeur à des motifs et exécute la première branche correspondante.
Il doit être exhaustif, peut utiliser _ comme motif fourre-tout, combiner des variantes avec | et renvoyer une valeur puisqu’il s’agit d’une expression. Vous apprendrez ensuite à attribuer leurs propres données aux variantes d’énumération.
Questions Fréquemment Posées
La leçon « Faire correspondre les variantes d’un énuméré » est-elle gratuite ?
Oui — le texte complet de « Faire correspondre les variantes d’un énuméré » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Faire correspondre les variantes d’un énuméré » ?
Utilisez match pour traiter chaque cas. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Faire correspondre les variantes d’un énuméré » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Définir votre premier énuméré
- Faire correspondre les variantes d’un énuméré
- Énumérés avec données
- Gardes et liaisons de correspondance