Appariement de motifs puissant
Maîtrisez les expressions `match` et les autres constructions d’appariement de motifs pour traiter les variantes de données de manière concise et exhaustive.
Appariement de motifs puissant est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. 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 3 leçons au total.
Libérer la puissance de la correspondance de motifs
Bienvenue dans le monde de la correspondance de motifs en Rust ! Cette fonctionnalité puissante vous permet de contrôler le flux du programme en fonction de la structure des données.
Au lieu de vérifier uniquement l'égalité, vous pouvez déconstruire les valeurs, extraire leurs composants et exécuter du code précis pour différentes formes de données.
- C'est comme une instruction
if/elseouswitchsurpuissante. - Elle garantit l'exhaustivité : vous devez traiter tous les motifs possibles.
- Elle rend le code plus lisible et plus robuste.
Les bases de l'expression `match`
Le cœur de la correspondance de motifs est l'expression match. Elle prend une valeur et la compare à une série de motifs. Le premier motif correspondant l'emporte !
Chaque « branche » d'une expression match se compose d'un motif et du code à exécuter si ce motif correspond.
enum Direction {
North,
East,
South,
West,
}
fn main() {
let my_direction = Direction::North;
match my_direction {
Direction::North => println!("Going up!"),
Direction::East => println!("Going right!"),
Direction::South => println!("Going down!"),
Direction::West => println!("Going left!"),
}
}Faire correspondre des littéraux et des intervalles
Vous pouvez faire correspondre des valeurs littérales précises (nombres, caractères, booléens) ou définir des intervalles à l'aide de ..=. L'opérateur | permet de faire correspondre plusieurs motifs avec une seule branche.
N'oubliez pas que les motifs sont vérifiés dans l'ordre et que la première correspondance est utilisée.
fn main() {
let x = 7;
match x {
1 => println!("It's one!"),
2 | 3 => println!("It's two or three!"),
4..=8 => println!("It's between four and eight!"),
_ => println!("It's something else!"), // Catch-all
}
let character = 'b';
match character {
'a'..='e' => println!("Early letter"),
_ => println!("Other letter"),
}
}Déconstruire des structures
La correspondance de motifs révèle tout son intérêt lorsqu'elle déconstruit des types de données complexes comme les structures. Vous pouvez extraire directement des champs individuels dans des variables au sein de la branche match.
Cela permet d'accéder aux données d'une structure de manière claire et concise, notamment lorsque vous faites correspondre des valeurs précises de champs.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
match p {
Point { x, y: 0 } => println!("On the X axis at {}", x),
Point { x: 0, y } => println!("On the Y axis at {}", y),
Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
}
}Déconstruire des énumérations contenant des données
Les énumérations Rust peuvent contenir des données associées. La correspondance de motifs est le principal moyen d'extraire ces données d'une variante d'énumération.
Vous pouvez déconstruire directement les données dans de nouvelles variables, ce qui facilite l'utilisation du contenu de chaque variante.
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn process_message(msg: Message) {
match msg {
Message::Quit => println!("Quit message."),
Message::Move { x, y } => {
println!("Move to x: {}, y: {}", x, y);
}
Message::Write(text) => println!("Text message: {}", text),
Message::ChangeColor(r, g, b) => {
println!("Color: R:{}, G:{}, B:{}", r, g, b);
}
}
}
fn main() {
process_message(Message::Move { x: 10, y: 20 });
process_message(Message::Write(String::from("Hello!")));
}Le motif générique `_`
Le motif spécial _ (tiret bas) joue le rôle d'un cas général. Il correspond à n'importe quelle valeur sans l'associer à cette valeur.
Il est utile lorsque vous devez couvrir toutes les possibilités pour garantir l'exhaustivité, mais que la valeur précise correspondant à une branche ne vous intéresse pas.
fn main() {
let some_value = Some(5);
let absent_value: Option<i32> = None;
match some_value {
Some(x) => println!("Got a value: {}", x),
_ => println!("Something else!"), // Matches None too
}
match absent_value {
Some(x) => println!("Got a value: {}", x),
_ => println!("No value here!"),
}
}`if let` pour les motifs uniques
Parfois, vous souhaitez uniquement faire correspondre un motif précis et ignorer tous les autres. Dans ce cas, if let constitue une alternative plus concise à une expression match complète.
En substance, cela signifie : « si ce motif correspond, faites ceci ; sinon, ne faites rien (ou exécutez un bloc else facultatif). ».
fn main() {
let config_max = Some(3u8);
let none_value: Option<u8> = None;
if let Some(max) = config_max {
println!("Max configured to be: {}", max);
}
if let Some(val) = none_value {
println!("This won't print: {}", val);
} else {
println!("No value found!");
}
}`while let` pour les boucles conditionnelles
Comme if let, while let vous permet de boucler tant qu'un motif continue de correspondre.
C'est extrêmement utile pour traiter les éléments de collections comme les Vec, lorsque vous voulez continuer jusqu'à ce qu'il n'y ait plus d'éléments correspondants (par exemple, jusqu'à ce que pop() renvoie None).
fn main() {
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("Popped: {}", top);
}
println!("Stack is empty now.");
}Gardes de correspondance : ajouter des conditions
Vous pouvez ajouter une condition if supplémentaire, appelée garde de correspondance, à une branche match. Le motif doit correspondre AND la condition de garde doit être vraie pour que cette branche soit exécutée.
Cela permet un contrôle plus précis au sein d'un motif, sans devoir créer davantage de variantes d'énumération.
fn main() {
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("Even number: {}", x),
Some(x) if x < 5 => println!("Small odd number: {}", x),
Some(x) => println!("Any other number: {}", x),
None => println!("No number"),
}
}Défi de correspondance de motifs
Examinez l'extrait de code Rust suivant. Laquelle des affirmations suivantes concernant l'expression match et sa sortie est VRAIE ?
enum Status {
Loading,
Success(u32),
Error(String),
}
fn process_status(s: Status) {
match s {
Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
Status::Success(code) => println!("Success with code: {}", code),
Status::Error(msg) => println!("Failed: {}", msg),
_ => println!("Status unknown or loading..."),
}
}
fn main() {
process_status(Status::Success(201));
process_status(Status::Error(String::from("Network issue")));
process_status(Status::Loading);
process_status(Status::Success(200));
}Récapitulatif : maîtriser les motifs
Vous avez exploré l'incroyable puissance de la correspondance de motifs en Rust ! Il s'agit d'un concept fondamental pour écrire un code clair, concis et sûr.
- Les expressions
matchoffrent un contrôle exhaustif du flux d'exécution basé sur la structure des données. - Vous pouvez faire correspondre des littéraux, des plages et utiliser des caractères génériques (
_). - La déstructuration permet d'extraire directement des valeurs de structures et d'énumérations.
if letetwhile letoffrent des moyens concis de faire correspondre des motifs uniques.- Les gardes de correspondance ajoutent une logique conditionnelle aux branches de
match.
Continuez à pratiquer ces motifs : ils sont essentiels pour écrire du Rust idiomatique !
Questions Fréquemment Posées
La leçon « Appariement de motifs puissant » est-elle gratuite ?
Oui — le texte complet de « Appariement de motifs puissant » 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 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Appariement de motifs puissant » ?
Maîtrisez les expressions `match` et les autres constructions d’appariement de motifs pour traiter les variantes de données de manière concise et exhaustive. 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 3 sur 3.
Combien de temps prend la leçon « Appariement de motifs puissant » ?
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 et utiliser des structures
- Énumérations pour les types personnalisés
- Appariement de motifs puissant