Learn Rust Coding · Leçon

Analyse approfondie de match

Motifs et gardes

Analyse approfondie de match est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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.

L’expression match

match compare une valeur à une série de motifs et exécute le bras correspondant à la première correspondance. C’est une expression, elle renvoie donc une valeur.

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

Exhaustivité

Un match doit couvrir toutes les valeurs possibles. Le caractère générique _ capture tout ce qui ne correspond pas aux bras précédents, ce qui garantit l’exhaustivité.

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

Faire correspondre plusieurs valeurs

Utilisez | pour faire correspondre plusieurs motifs dans un même bras.

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

Motifs d’intervalle

Faites correspondre un intervalle de valeurs avec ..= (bornes incluses). C’est pratique pour regrouper des nombres ou des caractères.

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

Gardes de correspondance

Une garde est une condition if supplémentaire appliquée à un bras. Le bras ne correspond que si le motif convient et que la garde est vraie.

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

Liaison dans les motifs

Les motifs peuvent lier les parties correspondantes à des variables afin de les utiliser dans le corps du bras.

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

Faire correspondre des énumérations

match est particulièrement adapté aux énumérations, surtout lorsque leurs variantes contiennent des données.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

Ignorer avec _ et ..

Utilisez _ pour ignorer une seule valeur et .. pour ignorer le reste d’un tuple ou d’une structure.

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

Renvoyer une valeur depuis match

Comme match est une expression, vous pouvez affecter son résultat à une variable ou le renvoyer directement. Chaque bras doit produire le même type.

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

L’ordre des bras est important

Les bras sont vérifiés de haut en bas ; le premier qui correspond l’emporte. Placez les motifs spécifiques avant les motifs généraux et le caractère générique en dernier.

Lier des intervalles avec @

Combinez un intervalle avec l’opérateur @ pour tester une valeur tout en conservant son contenu exact dans le même bras.

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

Vérification rapide

Quel est le rôle d’une garde de correspondance comme (x, y) if x > y ?

Récapitulatif

Vous avez approfondi match :

C’est une expression exhaustive qui renvoie une valeur
| fait correspondre plusieurs motifs ; ..= fait correspondre des intervalles
Les gardes ajoutent des conditions if supplémentaires
Les motifs lient les données ; _ et .. ignorent certaines parties
L’ordre des bras est important : la première correspondance l’emporte

Questions Fréquemment Posées

La leçon « Analyse approfondie de match » est-elle gratuite ?

Oui — le texte complet de « Analyse approfondie de match » 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 « Analyse approfondie de match » ?

Motifs et gardes 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 1 sur 4.

Combien de temps prend la leçon « Analyse approfondie de match » ?

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

← Retour à Learn Rust Coding