Afficher du texte en Rust

Vous avez déjà utilisé println! plusieurs fois. Cette page présente les autres macros d’affichage que vous croiserez, et quand utiliser chacune.

println! et print!

println! affiche du texte et ajoute un retour à la ligne à la fin. print! fait la même chose, mais sans retour à la ligne :

fn main() {
    print!("Bonjour, ");
    print!("le monde");
    println!(" !");
}

Sortie :

Bonjour, le monde !

▶ Essayez par vous-même

Remarquez que les trois appels ont affiché leur texte sur la même ligne : seul println! passe à la ligne suivante. En pratique, vous utiliserez println! presque tout le temps ; print! sert surtout quand vous construisez une ligne morceau par morceau.

Les emplacements : {} et les variables nommées

Vous avez déjà vu {} utilisé comme emplacement (placeholder). Vous pouvez le remplir soit en passant une valeur après la chaîne, soit en mettant directement le nom de la variable entre les accolades :

fn main() {
    let name = "Ferris";
    let age = 10;

    println!("{} a {} ans", name, age); // par position
    println!("{name} a {age} ans");     // en ligne (même résultat)
}

Sortie :

Ferris a 10 ans
Ferris a 10 ans

▶ Essayez par vous-même

Les deux lignes affichent la même chose. Le style en ligne ({name}) est un peu plus récent et généralement plus lisible : préférez-le quand c’est possible.

format! : construire une chaîne au lieu de l’afficher

Parfois, vous voulez obtenir le texte formaté sous forme de String au lieu de l’afficher tout de suite, par exemple pour le stocker ou le passer à une autre fonction. C’est le rôle de format!. Il fonctionne exactement comme println!, mais renvoie une String au lieu d’afficher quoi que ce soit :

fn main() {
    let name = "Ferris";
    let message = format!("Bonjour, {name} !");
    println!("{message}");
}

Sortie :

Bonjour, Ferris !

▶ Essayez par vous-même

L’affichage de débogage avec {:?}

Le simple {} ne fonctionne qu’avec les valeurs qui savent s’afficher sous forme de texte : nombres, chaînes de caractères, booléens. Pour des valeurs plus complexes, comme les tuples ou les structs, {} ne compile pas. Utilisez plutôt {:?} (le format de « débogage », ou debug) :

fn main() {
    let point = (3, 7);
    println!("{:?}", point);
}

Sortie :

(3, 7)

▶ Essayez par vous-même

Pour une présentation plus agréable, sur plusieurs lignes, quand la valeur est grosse, utilisez {:#?} (affichage « joli », ou pretty-print) :

fn main() {
    let point = (3, 7);
    println!("{:#?}", point);
}

Sortie :

(
    3,
    7,
)

▶ Essayez par vous-même

Note

Si Rust vous dit un jour qu’un type « doesn’t implement Display » (n’implémente pas Display), c’est le signal pour essayer {:?} à la place de {}. C’est l’une des erreurs les plus fréquentes chez les débutants quand ils affichent des valeurs.

Formater les nombres

Quelques astuces de formatage qui reviennent souvent :

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 décimales            -> 3.14
    println!("{:5}", 42);    // largeur de 5           -> "   42"
    println!("{:08.2}", pi); // complété par des zéros -> 00003.14
}

Sortie :

3.14
   42
00003.14

▶ Essayez par vous-même

Inutile de les apprendre par cœur : sachez simplement qu’elles existent, pour le jour où vous devrez aligner des nombres ou arrondir des décimales. Notez au passage que Rust utilise toujours un point comme séparateur décimal, jamais une virgule.

Aligner du texte et afficher des accolades

La largeur fonctionne aussi pour le texte, et vous pouvez choisir de quel côté la valeur se colle. Après le :, mettez < (à gauche), > (à droite) ou ^ (centré), puis la largeur. Vous pouvez aussi placer devant un caractère de remplissage, comme - :

fn main() {
    let coffee = 3.5;
    let bagel = 2.25;

    println!("{:-^20}", " MENU ");
    println!("{:<12}{:>8}", "Item", "Price");
    println!("{:<12}{:>8.2}", "Coffee", coffee);
    println!("{:<12}{:>8.2}", "Bagel", bagel);
    println!("{:<12}{:>8.2}", "Total", coffee + bagel);
}

Sortie :

------- MENU -------
Item           Price
Coffee          3.50
Bagel           2.25
Total           5.75

▶ Essayez par vous-même

Les libellés du menu sont restés en anglais (Item = article, Price = prix, Coffee = café) : cet exemple porte sur la largeur des colonnes, et le site garde ce type d’exemple identique dans toutes les langues pour que chaque colonne tombe exactement au même endroit.

Lisons {:>8.2} morceau par morceau : > signifie aligné à droite, 8 est la largeur et .2 veut dire deux décimales. Aligner les nombres à droite permet de mettre les points décimaux les uns sous les autres, c’est pour cela que les tickets de caisse et les tableaux le font.

Et si vous voulez un vrai { dans votre affichage ? Comme les accolades signifient « emplacement », il faut les doubler : {{ affiche { et }} affiche }.

fn main() {
    println!("Ensemble : {{{}, {}}}", 1, 2);
}

Sortie :

Ensemble : {1, 2}

▶ Essayez par vous-même

Afficher des erreurs

Il existe aussi eprintln! (et eprint!). Il fonctionne exactement comme println!, mais écrit sur la sortie d’erreur au lieu de la sortie normale. Les terminaux affichent les deux, mais si quelqu’un enregistre la sortie de votre programme dans un fichier, les messages d’erreur n’y finissent pas. Utilisez-le pour les avertissements et les messages d’erreur.

Exercices

1. Une étiquette de prix

Stockez l’article "cahier" et le prix 2.5, puis affichez Le cahier coûte 2.50 €. Indice : {:.2} arrondit à deux décimales, et cela marche aussi en ligne : {price:.2}.

Voir la solution

fn main() {
    let item = "cahier";
    let price = 2.5;
    println!("Le {item} coûte {price:.2} €");
}

Sortie :

Le cahier coûte 2.50 €

▶ Essayez par vous-même

2. Construire une étiquette, puis l’afficher de deux façons

Utilisez format! pour construire l’étiquette ferris-7 à partir du nom "ferris" et du nombre 7. Affichez-la une fois avec {} et une fois avec {:?}, et repérez la différence. Indice : format! accepte exactement les mêmes emplacements que println!.

Voir la solution

fn main() {
    let name = "ferris";
    let id = 7;
    let label = format!("{name}-{id}");

    println!("{label}");
    println!("{label:?}");
}

Sortie :

ferris-7
"ferris-7"

▶ Essayez par vous-même

L’affichage de débogage montre le texte entre guillemets, pour que vous voyiez exactement où il commence et où il finit. C’est pratique quand une valeur contient des espaces en trop.

Récapitulatif

• println! affiche avec un retour à la ligne ; print!, non.
• {} et {name} sont des emplacements pour des valeurs qui savent s’afficher (Display).
• format! fonctionne comme println!, mais renvoie une String au lieu d’afficher.
• {:?} (et {:#?}) affiche les valeurs pour le débogage, y compris celles que {} ne sait pas gérer.
• {:.2} arrondit les décimales ; <, > et ^ avec une largeur alignent le texte ; {{ et }} affichent des accolades.

Petit quiz

Petit quiz

1. Quelle est la différence entre println! et print! ?

println! ajoute un retour à la ligne à la fin, print! non print! ajoute un retour à la ligne à la fin, println! non Il n’y a aucune différence

2. Pourquoi utiliser {:?} plutôt que {} pour afficher un tuple ?

{:?} est plus rapide Les tuples n’implémentent pas Display, donc {} ne compile pas {} ne fonctionne que dans print!, pas dans println!

Score : 0 / 2

Pour aller plus loin

• std::fmt — documentation de la bibliothèque standard (en anglais) : la liste complète des options de formatage, dont la largeur, le remplissage, l’alignement et la précision.
• Formatted print — Rust by Example (en anglais) : des exemples exécutables d’arguments positionnels et nommés, de remplissage et d’alignement.
• Debug — Rust by Example (en anglais) : comment fonctionnent {:?} et {:#?}, et comment vos propres types peuvent en profiter.
• println! — documentation de la bibliothèque standard (en anglais) : la référence officielle de println!, avec des liens vers print! et eprintln!.
• format! — documentation de la bibliothèque standard (en anglais) : construire une String avec les mêmes règles de formatage.