Utiliser 'match' avec 'Result'

Fait partie de la section Logic & Flow du Journey Rust de Coddy — leçon 43 sur 66.

Maintenant que vous comprenez ce qu'est un Result, apprenons la manière la plus explicite et la plus puissante de gérer les cas de succès et d'échec : en utilisant une expression match.

Tout comme avec Option, match vous oblige à gérer les deux variantes d'un Result. Vous créez une branche pour Ok afin de gérer le succès, et une autre branche pour Err afin de gérer l'échec :

let result = divide(10, 2);

match result {
    Ok(value) => println!("Division successful: {}", value),
    Err(error) => println!("Division failed: {}", error),
}

Lorsque le Result est Ok, le match extrait la valeur de succès et exécute la première branche. Lorsqu'il s'agit d'un Err, il extrait les informations d'erreur et exécute la deuxième branche. Ce pattern garantit que vous n'ignorez jamais accidentellement une erreur potentielle.

Défi

Facile

Vous recevrez deux entrées. La première entrée est un nombre (sous forme de chaîne de caractères), et la seconde entrée est un autre nombre (sous forme de chaîne de caractères). Créez une fonction qui tente de diviser le premier nombre par le second et renvoie un Result<f64, &'static str>. Si le second nombre est zéro, renvoyez un Err avec le message "Division by zero". Sinon, renvoyez Ok avec le résultat de la division. Utilisez une expression match pour gérer les cas Ok et Err et afficher le message approprié.

Exigences :

Lire la première entrée (dividende) et supprimer les espaces blancs
Analyser la première entrée en f64
Lire la seconde entrée (diviseur) et supprimer les espaces blancs
Analyser la seconde entrée en f64
Créer une fonction qui prend deux paramètres f64 et renvoie Result<f64, &'static str>
À l'intérieur de la fonction, vérifiez si le diviseur est 0.0 :
- Si oui, renvoyez Err("Division by zero")
- Si non, renvoyez Ok(dividend / divisor)
Appeler la fonction avec les deux nombres analysés
Utiliser une expression match pour gérer le Result
Dans la branche Ok(value), affichez : Result: [value]
Dans la branche Err(error), affichez : Error: [error]

Entrée :

Première ligne : Un nombre représentant le dividende (par ex., 10.0)
Deuxième ligne : Un nombre représentant le diviseur (par ex., 2.0)

Sortie :

Si la division réussit : Result: [result]
Si division par zéro : Error: Division by zero

Aide-mémoire

Utilisez match pour gérer à la fois les variantes Ok et Err d'un Result :

let result = divide(10, 2);

match result {
    Ok(value) => println!("Division successful: {}", value),
    Err(error) => println!("Division failed: {}", error),
}

L'expression match vous oblige à gérer à la fois les cas de succès et d'échec. Lorsque le Result est Ok, elle extrait la valeur de succès et exécute la première branche. Lorsqu'il s'agit d'un Err, elle extrait les informations d'erreur et exécute la deuxième branche.

Essayez vous-même

use std::io;

// TODO: Créez votre fonction de division ici qui retourne Result<f64, &'static str>


fn main() {
    // Lire la première entrée (dividende)
    let mut dividend_input = String::new();
    io::stdin().read_line(&mut dividend_input).expect("Failed to read line");
    let dividend: f64 = dividend_input.trim().parse().expect("Invalid number");
    
    // Lire la deuxième entrée (diviseur)
    let mut divisor_input = String::new();
    io::stdin().read_line(&mut divisor_input).expect("Failed to read line");
    let divisor: f64 = divisor_input.trim().parse().expect("Invalid number");
    
    // TODO: Appelez votre fonction de division et utilisez match pour gérer le Result
    // Afficher "Result: [value]" pour le cas Ok
    // Afficher "Error: [error]" pour le cas Err
}