Déballez les options avec?

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, nous explorons l'utilisation de l'opérateur ? en Rust, qui permet de déballer facilement les valeurs Option sans avoir besoin d'instructions match imbriquées. L'opérateur ? peut être utilisé pour retourner rapidement la valeur sous-jacente si l'Option est Some, ou terminer la fonction et retourner None si l'Option est None. Cet opérateur peut être chaîné pour rendre le code plus lisible et concise.

Note : Si le laboratoire ne spécifie pas de nom de fichier, 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/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/ErrorHandlingandDebuggingGroup(["Error Handling and Debugging"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") 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/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/ErrorHandlingandDebuggingGroup -.-> rust/error_propagation("Error Propagation") rust/AdvancedTopicsGroup -.-> rust/traits("Traits") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99235{{"Déballez les options avec?"}} rust/integer_types -.-> lab-99235{{"Déballez les options avec?"}} rust/function_syntax -.-> lab-99235{{"Déballez les options avec?"}} rust/expressions_statements -.-> lab-99235{{"Déballez les options avec?"}} rust/lifetime_specifiers -.-> lab-99235{{"Déballez les options avec?"}} rust/method_syntax -.-> lab-99235{{"Déballez les options avec?"}} rust/error_propagation -.-> lab-99235{{"Déballez les options avec?"}} rust/traits -.-> lab-99235{{"Déballez les options avec?"}} rust/operator_overloading -.-> lab-99235{{"Déballez les options avec?"}} end

Déballez les options avec ?

Vous pouvez déballer les Option en utilisant des instructions match, mais il est souvent plus facile d'utiliser l'opérateur ?. Si x est une Option, alors l'évaluation de x? retournera la valeur sous-jacente si x est Some, sinon elle terminera la fonction en cours d'exécution et retournera None.

fn next_birthday(current_age: Option<u8>) -> Option<String> {
    // Si `current_age` est `None`, cela retourne `None`.
    // Si `current_age` est `Some`, l'`u8` interne est assigné à `next_age`
    let next_age: u8 = current_age? + 1;
    Some(format!("Next year I will be {}", next_age))
}

Vous pouvez chaîner plusieurs ? pour rendre votre code beaucoup plus lisible.

struct Person {
    job: Option<Job>,
}

#[derive(Clone, Copy)]
struct Job {
    phone_number: Option<PhoneNumber>,
}

#[derive(Clone, Copy)]
struct PhoneNumber {
    area_code: Option<u8>,
    number: u32,
}

impl Person {

    // Obtient le code d'aire du numéro de téléphone du travail de la personne, s'il existe.
    fn work_phone_area_code(&self) -> Option<u8> {
        // Cela nécessiterait de nombreuses instructions `match` imbriquées sans l'opérateur `?`.
        // Cela nécessiterait beaucoup plus de code - essayez de l'écrire vous-même et voyez lequel
        // est plus facile.
        self.job?.phone_number?.area_code
    }
}

fn main() {
    let p = Person {
        job: Some(Job {
            phone_number: Some(PhoneNumber {
                area_code: Some(61),
                number: 439222222,
            }),
        }),
    };

    assert_eq!(p.work_phone_area_code(), Some(61));
}

Résumé

Félicitations ! Vous avez terminé le laboratoire Déballez les options avec ?. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.