Learn Rust Coding · Leçon

if let et while let

Correspondance concise

if let et while let 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.

Correspondance concise

Parfois, un seul motif vous intéresse. if let et while let permettent une correspondance concise sans utiliser un match complet.

La forme if let

if let exécute un bloc uniquement lorsqu’une valeur correspond à un motif, en liant les données capturées.

fn main() {
    let maybe = Some(10);
    if let Some(n) = maybe {
        println!("value is {n}");
    }
}

if let ou match

if let est une syntaxe abrégée pour un match avec un seul bras intéressant et une branche de repli _ => (). Utilisez-le lorsque les autres cas ne nécessitent aucun traitement.

fn main() {
    let config: Option<i32> = None;
    // match equivalent would have an empty _ arm
    if let Some(v) = config {
        println!("configured: {v}");
    }
    println!("done");
}

Ajouter un else

Ajoutez un else pour gérer le cas qui ne correspond pas.

fn main() {
    let result: Result<i32, String> = Err("boom".to_string());
    if let Ok(v) = result {
        println!("ok: {v}");
    } else {
        println!("failed");
    }
}

let else

let ... else effectue la liaison lorsque le motif correspond ; sinon, il exécute un bloc qui ne se termine pas normalement, comme return. C'est idéal pour effectuer des sorties anticipées.

fn parse(s: &str) -> i32 {
    let Ok(n) = s.parse::<i32>() else {
        println!("not a number");
        return 0;
    };
    n * 2
}

fn main() {
    println!("{}", parse("21"));
    println!("{}", parse("oops"));
}

La forme while let

while let continue la boucle tant qu'une valeur correspond à un motif. C'est parfait pour vider des structures comme les piles.

fn main() {
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("popped {top}");
    }
}

Parcourir des itérateurs

while let peut itérer en appelant next à répétition et s'arrêter lorsqu'il renvoie None.

fn main() {
    let mut iter = [10, 20, 30].into_iter();
    while let Some(x) = iter.next() {
        println!("{x}");
    }
}

Garde avec if let

Combinez une garde en ajoutant une condition && (Rust 2024) ou en imbriquant un if.

fn main() {
    let value = Some(8);
    if let Some(n) = value {
        if n > 5 {
            println!("big: {n}");
        }
    }
}

Quand utiliser chaque forme

Directives :

if let — traiter un motif et ignorer le reste
let else — effectuer une liaison ou quitter rapidement
while let — boucler tant qu'un motif correspond
match — lorsque plusieurs cas doivent être traités

Compromis de lisibilité

Ces formes réduisent le code répétitif, mais peuvent masquer certains cas. Si vous vous retrouvez à traiter plusieurs motifs, revenez à un match complet pour plus de clarté.

Imbriquer des if let

Vous pouvez enchaîner des valeurs facultatives en imbriquant des if let et en déballant une couche à la fois.

fn main() {
    let outer: Option<Option<i32>> = Some(Some(99));
    if let Some(inner) = outer {
        if let Some(value) = inner {
            println!("value is {value}");
        }
    }
}

Vérification rapide

Quelle construction exécute de façon répétée le corps d'une boucle tant qu'une valeur continue de correspondre à un motif ?

Récapitulatif

Vous avez appris les correspondances concises :

if let traite un seul motif, éventuellement avec else
let else effectue une liaison ou quitte rapidement
while let boucle tant qu'un motif correspond
Passez à match lorsque plusieurs cas doivent être traités

Questions Fréquemment Posées

La leçon « if let et while let » est-elle gratuite ?

Oui — le texte complet de « if let et while let » 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 « if let et while let » ?

Correspondance concise 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 « if let et while let » ?

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