Menu
CoddyTech

Déballer une 'Option'

Fait partie de la section Logique & Flux du Journey Rust de Coddy. Leçon 38 sur 66.

Parfois, tu dois extraire la valeur réelle d’un Option lorsque tu es sûr qu’il contient un Some. Rust fournit la méthode .unwrap() à cette fin : elle extrait la valeur d’un Some et te la renvoie directement.

let maybe_number = Some(42);
let actual_number = maybe_number.unwrap();
println!("The number is: {}", actual_number);

Lorsque tu appelles .unwrap() sur un Some(value), cela renvoie la valeur interne. Dans l’exemple ci-dessus, actual_number devient 42 : elle n’est plus enveloppée dans un Option.

Cependant, il y a un avertissement crucial : si tu appelles .unwrap() sur un None, ton programme paniquera et plantera immédiatement. Cela fait de .unwrap() une méthode potentiellement dangereuse, qui ne devrait être utilisée que lorsque tu es absolument certain que l’Option contient un Some.

let empty_option: Option<i32> = None;
let value = empty_option.unwrap(); // Cela provoquera une panique !

Utilise .unwrap() avec parcimonie et uniquement dans les situations où tu peux garantir que Option contient une valeur, par exemple dans des exemples simples ou lorsque tu as déjà vérifié avec .is_some().

challenge icon

Défi

Facile

Tu recevras deux entrées. La première entrée est un nombre (sous forme de chaîne), et la seconde indique si ce nombre doit être considéré comme valide ou invalide. Si la seconde entrée est valid, crée une Option<i32> contenant Some avec le nombre analysé. Si la seconde entrée est invalid, crée une Option<i32> contenant None. Utilise .unwrap() pour extraire la valeur de l’Option et l’afficher.

Exigences :

  • Lis la première entrée et supprime les espaces superflus
  • Lis la seconde entrée et supprime les espaces superflus
  • Analyse la première entrée en i32 à l’aide de .parse::<i32>()
  • Crée une variable de type Option<i32> :
    • Si la seconde entrée est valid, assigne-lui Some(parsed_number)
    • Si la seconde entrée est invalid, assigne-lui None
  • Utilise .unwrap() pour extraire la valeur de l’Option
  • Affiche la valeur extraite au format : Value: [number]

Entrée :

  • Première ligne : un nombre sous forme de chaîne (par exemple, 42)
  • Deuxième ligne : valid ou invalid

Sortie :

  • Si la seconde entrée est valid : Value: [number]
  • Si la seconde entrée est invalid : le programme provoquera une panique (c’est le comportement attendu pour ce défi)

Remarque : Lorsque la seconde entrée est invalid, appeler .unwrap() sur None provoquera une panique. Cela montre le danger de .unwrap() lorsque tu n’es pas certain que l’Option contient une valeur.

Essayez vous-même

use std::io;

fn main() {
    // Lisez la première entrée (nombre sous forme de chaîne)
    let mut number_input = String::new();
    io::stdin().read_line(&mut number_input).expect("Failed to read line");
    let number_input = number_input.trim();
    
    // Lisez la deuxième entrée (valide ou non valide)
    let mut validity_input = String::new();
    io::stdin().read_line(&mut validity_input).expect("Failed to read line");
    let validity_input = validity_input.trim();
    
    // Convertissez le nombre
    let parsed_number: i32 = number_input.parse().expect("Failed to parse number");
    
    // TODO: Écrivez votre code ci-dessous
    // Créez un Option<i32> en fonction de validity_input
    // Si validity_input vaut "valid", attribuez Some(parsed_number)
    // Si validity_input vaut "invalid", attribuez None
    // Utilisez ensuite .unwrap() pour extraire la valeur et l’afficher au format : Value: [number]
    
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

Entraînez-vous par vous-même : Compilateur Rust en ligne