Comment fonctionne le formatage des chaînes de caractères en Rust

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

Rust fournit un mécanisme puissant et flexible pour le formatage des chaînes de caractères qui vous permet de créer des résultats clairs et concis, y compris des fonctionnalités numériques, de date, d’heure et de gestion des erreurs.

Formatage de base des chaînes de caractères en Rust

Rust fournit des fonctionnalités pour formater les chaînes de caractères avec d’autres types intégrés à Rust.

Vous pouvez utiliser la fonction ! macro pour le formatage de base des chaînes de caractères en Rust. La macro format ! fournit un moyen concis et puissant de construire des chaînes de caractères formatées à l’aide de caractères de remplacement entourés d’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 macro nom contient une chaîne de caractères, et la variable âge contient un nombre entier. La variable message La variable a une chaîne formatée qui utilise format ! pour remplacer les caractères de remplacement par les valeurs correspondantes, ce qui donne une chaîne de format contenant les éléments suivants nom et âge.

Le format ! La macro prend en charge plusieurs 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
}
 

Le pi contient une valeur en virgule flottante ; avec le spécificateur de format :.2, vous pouvez instruire le format ! macro à afficher pi avec deux décimales.

Le format ! La macro est l’une des nombreuses méthodes de formatage de chaînes de caractères en Rust. En fonction de vos besoins, vous pouvez envisager d’utiliser la macro println ! ou écrire ! macro pour une sortie formatée vers la console ou d’autres flux de sortie.

Formatage des valeurs numériques

Rust propose également des fonctionnalités de formatage de diverses valeurs numériques, des entiers aux flottants en passant par d’autres types numériques.

En général, les spécificateurs de format sont la base du formatage des chaînes de caractères en 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 :

En outre, 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 en vue de leur présentation sous forme de tableau ou d’autres mises en page visuellement organisées. Avant la valeur de la largeur, vous pouvez spécifier le caractère de remplissage, soit un espace, soit un zéro.

Pour aligner une valeur à gauche, utilisez l’option – drapeau. Pour aligner une valeur à droite, omettre l’indicateur ou utiliser l’indicateur ‘0’ pour un remplissage nul.

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

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

Formatage personnalisé des chaînes de caractères en Rust

Le formatage personnalisé des chaînes de caractères est important pour les opérations plus exigeantes. Vous pouvez créer des implémentations de formatage personnalisées pour vos types à l’aide de la fonction intégrée std::fmt module.

Le std::fmt Le module std::fmt fournit des traits pour le formatage de la sortie avec une large gamme d’options pour personnaliser l’apparence des données pendant le processus de conversion des chaînes de caractères. Le module std::fmt Le module std::fmt fournit un Affichage et Débogage Il s’agit d’un trait de caractère pratique pour les opérations de formatage de chaînes de caractères.

L’attribut Display

Le Trait d’Affichage Affichage Le trait aide à produire une sortie lisible par l’homme en définissant comment un objet doit être formaté avec le trait {} dans une chaîne de caractères. Vous pouvez implémenter la méthode Affichage Vous pouvez créer un trait de caractère pour vos types personnalisés en définissant une méthode appelée fmt qui prend un formateur en argument.

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

 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);
}
 

Les Point met en œuvre la structure Affichage trait. À l’intérieur du fmt méthode, le écrire ! et écrire la sortie désirée au formateur avec la commande {} placeholder.

Le trait de débogage

Le Débogage Le trait de caractère est similaire au trait de caractère Affichage sauf qu’il se concentre sur la production d’une sortie adaptée au débogage et à la gestion des erreurs. Le trait Débogage Ce trait est principalement utilisé avec le {:?} placeholder.

Mise en œuvre de l’option Débogage L’ajout d’un trait de caractère à vos types personnalisés est simple. Le trait Débogage trait fournit une implémentation par défaut basée sur le Affichage trait. Cependant, 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 Débogage trait pour le Personne struct avec #[derive(Debug)]. Cela génère automatiquement l’implémentation basée sur les champs de la structure.

La macro println imprime la représentation de débogage avec l’attribut Débogage formatage de l’espace réservé pour le formatage de la sortie à l’aide de la fonction Débogage mise en œuvre.

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

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

Le système de type assure la sécurité à la compilation et prévient les erreurs courantes, qu’il s’agisse d’une erreur de type ou d’un problème 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 du formatage de chaînes de caractères et bénéficier des garanties de performance et de sécurité du langage.