Le trait Display

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 36 sur 61.

Alors que Debug est idéal pour les développeurs qui inspectent les données, le trait Display est conçu pour une sortie destinée à l'utilisateur. C'est lui qui alimente le formateur {} dans println!. Contrairement à Debug, Rust ne peut pas dériver automatiquement Display. Vous devez l'implémenter manuellement.

Pour implémenter Display, vous devez importer le module fmt et implémenter la méthode fmt :

use std::fmt;

struct Temperature {
    celsius: f64,
}

impl fmt::Display for Temperature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}°C", self.celsius)
    }
}

La méthode fmt reçoit un Formatter et renvoie un fmt::Result. Vous utilisez la macro write! pour formater votre sortie, en accédant aux champs de la structure via self.

Vous pouvez maintenant afficher la structure avec le formateur standard {} :

let temp = Temperature { celsius: 23.5 };
println!("{}", temp);  // 23.5°C

La différence essentielle : la sortie de Debug montre la structure de vos données (utile pour le débogage), tandis que la sortie de Display est soignée et destinée aux utilisateurs finaux. Un struct peut implémenter les deux : utilisez {:?} pour le débogage et {} pour une sortie claire.

Défi

Facile

Créons un système d’affichage de produits convivial ! Alors que Debug montre la structure brute de vos données, le trait Display vous permet de concevoir une sortie soignée et lisible par les humains, parfaite pour les utilisateurs finaux.

Vous organiserez votre code sur deux fichiers :

product.rs : définissez une structure publique Product avec deux champs publics : name (String) et price (f64). Implémentez le trait Display pour votre structure afin qu’il la formate comme {name} - ${price}. N’oubliez pas d’importer std::fmt et d’utiliser la macro write! dans votre méthode fmt.
main.rs : importez votre module de produit et créez une instance de Product à l’aide des entrées fournies. Affichez le produit en utilisant le formateur standard {} pour montrer votre affichage personnalisé.

Le trait Display vous oblige à implémenter manuellement la méthode fmt : Rust ne peut pas la dériver automatiquement comme Debug. Cela vous donne un contrôle total sur la manière dont votre type apparaît pour les utilisateurs.

Votre sortie doit afficher le produit dans un format clair et convivial :

{name} - ${price}

Par exemple, avec les entrées Wireless Mouse et 29.99 :

Wireless Mouse - $29.99

Vous recevrez deux entrées : le nom du produit et le prix (à analyser en tant que f64).

Essayez vous-même

mod product;

use product::Product;

fn main() {
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();

    let mut price_input = String::new();
    std::io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");

    // TODO: Créer une instance de Product avec le nom et le prix

    // TODO: Afficher le produit en utilisant le formateur {}
}