Comment fonctionne le formatage des chaînes dans Rust

Apprenez à formater vos données de chaîne pour une présentation parfaite.

Le formatage des chaînes est un aspect crucial de la programmation car il vous permet de manipuler et d'afficher les données de manière lisible et structurée. Vous pouvez contrôler la présentation des données en formatant les chaînes pour une meilleure expérience utilisateur.

Rust fournit un mécanisme puissant et flexible pour le formatage des chaînes qui vous permet de créer une sortie claire et concise, comprenant des fonctionnalités numériques, de date, d'heure et de gestion des erreurs.

Formatage de chaîne de base dans Rust

Rust fournit des fonctionnalités pour formater les chaînes avec d'autres types intégrés de Rust.

Vous pouvez utiliser la macro format ! pour le formatage de chaîne de base dans Rust. La macro format ! fournit un moyen concis et puissant de construire des chaînes formatées avec des espaces réservés entre accolades.

fn main() {
    let name = "Alice";
    let age = 25;
    let message = format!("My name is {} and I am {} years old.", name, age);
    println!("{}", message);
}

La variable name contient une chaîne et la variable age contient un entier. La variable message a une chaîne formatée qui utilise format ! pour remplacer les espaces réservés par les valeurs correspondantes, ce qui donne une chaîne de format contenant le nom et < fort>âge.

La macro format ! prend en charge divers spécificateurs de format qui vous permettent de contrôler la sortie.

Voici comment spécifier le nombre de décimales pour les nombres à virgule flottante, définir la largeur des champs et aligner la sortie.

fn main() {
    let pi = 3.14159;
    let formatted_pi = format!("The value of pi is approximately {:.2}", pi);
    println!("{}", formatted_pi); // prints 3.14
}

La variable pi contient une valeur à virgule flottante ; avec le spécificateur de format :.2, vous pouvez demander à la macro format! d'afficher pi avec deux décimales.

La macro format ! est l'une des nombreuses méthodes de formatage de chaîne avec Rust. En fonction de vos besoins, envisagez d'utiliser la macro println! ou write! pour une sortie formatée vers la console ou d'autres flux de sortie.

Formatage des valeurs numériques

Rust fournit également des fonctionnalités pour formater diverses valeurs numériques, des entiers aux flottants et autres types numériques.

Généralement, les spécificateurs de format constituent la base du formatage des chaînes dans Rust, et vous aurez besoin du bon spécificateur en fonction de la valeur numérique que vous souhaitez formater.

Voici quelques-uns des spécificateurs de format fournis par Rust pour les valeurs numériques :

De plus, vous pouvez spécifier le remplissage et l'alignement des valeurs numériques. Le remplissage ajoute des espaces ou des zéros à une valeur numérique formatée pour obtenir la largeur souhaitée. Le remplissage permet d'aligner les valeurs pour la présentation sous forme de tableau ou d'autres mises en page visuellement organisées. Avant la valeur de largeur, vous pouvez spécifier le caractère de remplissage, soit un espace, soit zéro.

Pour aligner une valeur à gauche, utilisez le drapeau -. Pour aligner une valeur à droite, omettez l'indicateur ou utilisez l'indicateur « 0 » pour un remplissage nul.

fn main() {
    number = 42
    formatted_number = "%10d" % number
    print(formatted_number)
}

La valeur est alignée à droite sur une largeur de 10 caractères, ce qui donne huit espaces avant le nombre.

Formatage de chaîne personnalisé dans Rust

Le formatage de chaîne personnalisé est important pour les opérations plus exigeantes. Vous pouvez créer des implémentations de formatage personnalisées pour vos types avec le module std::fmt intégré de Rust.

Le module std::fmt fournit des caractéristiques pour le formatage de la sortie avec un large éventail d'options pour personnaliser l'apparence des données pendant le processus de conversion de chaîne. Le module std::fmt fournit un trait Display et Debug qui est pratique pour les opérations de formatage de chaîne.

Le trait d’affichage

Le trait Display permet de produire une sortie lisible par l'homme en définissant la manière dont un objet doit être formaté avec l'espace réservé {} dans une chaîne. Vous pouvez implémenter le trait Display pour vos types personnalisés en définissant une méthode appelée fmt qui prend un formateur comme argument.

Le formateur fournit diverses méthodes pour contrôler la sortie du format, comme les méthodes write_str et write_fmt.

use std::fmt;
// Define a struct named `Point`
struct Point {
    x: i32,
    y: i32,
}
// Implement the `Display` trait for `Point`
impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // Format the `Point` struct as "(x, y)"
        write!(f, "({}, {})", self.x, self.y)
    }
}
fn main() {
    // Create a new `Point` instance
    let point = Point { x: 5, y: 10 };
    // Print the `Point` struct using the `Display` formatting
    println!("The point is: {}", point);
}

La structure Point implémente le trait Display. Dans la méthode fmt, la macro write! formate et écrit la sortie souhaitée dans le formateur avec l'espace réservé {}.

Le trait de débogage

Le trait Debug est similaire au trait Display, sauf qu'il se concentre sur la production de sorties adaptées au débogage et à la gestion des erreurs. Le trait Debug est principalement utilisé avec l'espace réservé {:?>.

L'implémentation du trait Debug sur vos types personnalisés est simple. Le trait Debug fournit une implémentation par défaut basée sur le trait Display. Toutefois, vous pouvez remplacer le comportement par défaut pour fournir une représentation de débogage spécialisée.

use std::fmt;
// Define a struct named `Person`
#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}
// Implement the `Display` trait for `Person`
impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Format the `Person` struct as a human-readable string
        write!(f, "Name: {}, Age: {}", self.name, self.age)
    }
}
fn main() {
    // Create a new `Person` instance
    let person = Person {
        name: String::from("Alice"),
        age: 30,
    };
    // Print the `Person` struct using the `Display` formatting
    println!("Display: {}", person);
    // Print the `Person` struct using the `Debug` formatting
    println!("Debug: {:?}", person);
}

Le programme dérive le trait Debug pour la structure Person avec #[derive(Debug)]. Cela génère automatiquement l'implémentation basée sur les champs de structure.

La macro println imprime la représentation de débogage avec l'espace réservé de formatage Debug pour formater la sortie à l'aide de l'implémentation Debug.

Rust a un système de types riche en fonctionnalités

Le système de types riche de Rust joue un rôle crucial dans le formatage des chaînes. En tirant parti du typage statique et des puissantes bibliothèques de formatage de Rust, vous pouvez écrire du code sûr et efficace tout en gérant les tâches de manipulation et de formatage de chaînes.

Le système de types garantit la sécurité au moment de la compilation et évite les erreurs courantes, des incompatibilités de types aux problèmes de spécificateur de format. Grâce à la combinaison du système de types de Rust et de ses capacités de formatage étendues, vous pouvez relever en toute confiance les défis de formatage de chaînes et bénéficier des garanties de performances et de sécurité du langage.