Itération concise des Options Rust avec While Let

RustRustBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, l'utilisation de while let en Rust est démontrée comme une alternative plus concise et efficace à l'utilisation de séquences match lors de l'incrémentation de variables ou de l'itération sur des types Option.

Note : Si le nom de fichier n'est pas spécifié dans le laboratoire, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/ErrorHandlingandDebuggingGroup(["Error Handling and Debugging"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/BasicConceptsGroup -.-> rust/mutable_variables("Mutable Variables") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/MemorySafetyandManagementGroup -.-> rust/lifetime_specifiers("Lifetime Specifiers") rust/ErrorHandlingandDebuggingGroup -.-> rust/error_propagation("Error Propagation") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/mutable_variables -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/integer_types -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/function_syntax -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/expressions_statements -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/lifetime_specifiers -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/error_propagation -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} rust/operator_overloading -.-> lab-99319{{"Itération concise des Options Rust avec While Let"}} end

while let

De la même manière que if let, while let peut rendre les séquences match embarrassantes plus supportables. Considérez la séquence suivante qui incrémente i :

// Crée une variable `optional` de type `Option<i32>`
let mut optional = Some(0);

// Répétez le test.
loop {
    match optional {
        // Si `optional` peut être décomposé, évaluez le bloc.
        Some(i) => {
            if i > 9 {
                println!("Plus grand que 9, arrêtez!");
                optional = None;
            } else {
                println!("`i` vaut `{:?}`. Essayez encore.", i);
                optional = Some(i + 1);
            }
            // ^ Requiert 3 indentations!
        },
        // Arrêtez la boucle lorsque la décomposition échoue :
        _ => { break; }
        // ^ Pourquoi est-ce nécessaire? Il doit y avoir une meilleure façon!
    }
}

En utilisant while let, cette séquence est bien meilleure :

fn main() {
    // Crée une variable `optional` de type `Option<i32>`
    let mut optional = Some(0);

    // Cela signifie : "tant que `let` décompose `optional` en
    // `Some(i)`, évaluez le bloc (`{}`). Sinon, `break`.
    while let Some(i) = optional {
        if i > 9 {
            println!("Plus grand que 9, arrêtez!");
            optional = None;
        } else {
            println!("`i` vaut `{:?}`. Essayez encore.", i);
            optional = Some(i + 1);
        }
        // ^ Moins d'indentation vers la droite et ne nécessite pas
        // de gérer explicitement le cas d'échec.
    }
    // ^ `if let` avait des clauses `else`/`else if` optionnelles supplémentaires. `while let` n'en a pas.
}

Résumé

Félicitations! Vous avez terminé le laboratoire While Let. Vous pouvez pratiquer d'autres laboratoires dans LabEx pour améliorer vos compétences.