Comment fonctionne le formatage de chaîne dans Rust

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 des 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, y compris 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 des chaînes avec d'autres Types intégrés de rouille.

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

fnprincipal() {
laisser nom = "Alice";
laisser âge = 25;
laisser msg = format!("Je m'appelle {} et j'ai {} ans.", nom Age);
imprimez !("{}", message);
}

Le nom variable contient une chaîne, et la âge variable contient un entier. Le message variable a une chaîne formatée qui utilise format! pour remplacer les espaces réservés par les valeurs correspondantes, résultant en une chaîne de format contenant le nom et âge.

Le format! La macro 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.

fnprincipal() {
laisser pi = 3.14159;
laisser formatted_pi = format!("La valeur de pi est d'environ {:.2}", pi);
imprimez !("{}", formatted_pi); // imprime 3.14
}

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

Le format! macro est l'une des nombreuses méthodes de formatage de chaîne avec Rust. En fonction de vos besoins, pensez à utiliser le imprimez ! ou écrire! macro 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 sont à la base du formatage de chaîne 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 pour les 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 rembourrage aide à aligner les valeurs pour une 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 la - drapeau. Pour aligner une valeur à droite, omettez l'indicateur ou utilisez l'indicateur '0' pour le remplissage par zéro.

fnprincipal() {
 nombre = 42
 nombre_formaté = "%10d" % nombre
 imprimer (numéro_formaté)
}

La valeur est alignée à droite dans 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 la fonction intégrée de Rust std:: fmt module.

Le std:: fmt Le module fournit des traits 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 std:: fmt module fournit un Afficher et Déboguer trait pratique pour les opérations de formatage de chaîne.

Le trait d'affichage

Le Afficher trait aide à produire une sortie lisible par l'homme en définissant comment un objet doit être formaté avec le {} espace réservé dans une chaîne. Vous pouvez mettre en œuvre le Afficher trait pour votre 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 le chaîne_écriture et écrire_fmt méthodes.

utiliser std:: fmt;
// Définit une structure nommée `Point`
structureIndiquer {
 X: i32,
 y: i32,
}
// Implémenter le trait `Display` pour `Point`
mettre en œuvre fmt:: Affichage pour Indiquer {
fnfmt(&soi, F: &muet fmt:: Formateur<'_>) -> fmt ::Résultat {
// Formate la structure `Point` comme "(x, y)"
écrire!(F, "({}, {})", soi.X, soi.y)
 }
}
fnprincipal() {
// Crée une nouvelle instance `Point`
laisser point = Point { x: 5, y: 10 };
// Affiche la structure `Point` en utilisant le formatage `Display`
imprimez !("Le point est: {}", indiquer);
}

Le Indiquer struct implémente la Afficher trait. À l'intérieur de fmt méthode, la écrire! formats de macro et écrivez la sortie souhaitée dans le formateur avec le {} espace réservé.

La caractéristique de débogage

Le Déboguer trait est semblable au Afficher trait, sauf qu'il se concentre sur la production d'une sortie adaptée au débogage et la gestion des erreurs fins. Le Déboguer trait est principalement utilisé avec le {:?} espace réservé.

Mise en œuvre de la Déboguer trait sur vos types personnalisés est simple. Le Déboguer trait fournit une implémentation par défaut basée sur le Afficher trait. Cependant, vous pouvez remplacer le comportement par défaut pour fournir une représentation de débogage spécialisée.

utiliser std:: fmt;
// Définit une structure nommée `Person`
#[dériver (débogage)]
structurePersonne {
 nom: Chaîne,
 âge: u32,
}
// Implémenter le trait `Display` pour `Person`
mettre en œuvre fmt:: Affichage pour Personne {
fnfmt(&soi, F: &muet fmt:: Formateur) -> fmt ::Résultat {
// Formate la structure `Person` comme une chaîne lisible par l'homme
écrire!(F, "Nom Age: {}", soi.nom, soi.âge)
 }
}
fnprincipal() {
// Crée une nouvelle instance `Person`
laisser personne = Personne {
 nom: Chaîne::depuis("Alice"),
 âge: 30,
 };
// Affiche la structure `Person` en utilisant le formatage `Display`
imprimez !("Afficher: {}", personne);
// Affiche la structure `Person` en utilisant le formatage `Debug`
imprimez !("Débogage: {:?}", personne);
}

Le programme dérive les Déboguer trait pour le Personne structure avec #[dériver (débogage)]. Cela génère automatiquement l'implémentation basée sur les champs struct.

La macro println imprime la représentation de débogage avec la Déboguer espace réservé de formatage pour formater la sortie à l'aide de Déboguer mise en œuvre.

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

Le système de type 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 un code sûr et efficace tout en gérant les tâches de manipulation et de formatage de chaînes.

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