Section courante

A propos

Section administrative du site

write

 Écriture
Rust

Syntaxe

macro_rules! write {
   ($dst:expr, $($arg:tt)*) => { ... };
}

Description

Cette macro permet d'écrire des données formatées dans un tampon implémentant le trait std::fmt::Write, sans saut de ligne.

Remarques

Permet d'écrire des données formatées dans un tampon.

Cette macro accepte un «writer», une chaîne de format et une liste de paramètres. Les arguments sont formatés selon la chaîne de format spécifiée et le résultat est transmis au writer. Ce writer peut être n'importe quelle valeur associée à une méthode write_fmt ; elle provient généralement d'une implémentation du trait fmt::Write ou io::Write. La macro renvoie le résultat de la méthode write_fmt ; généralement un fmt::Result ou un io::Result.

Exemples

  1. use std::io::Write;
  2.  
  3. fn main() -> std::io::Result<()> {
  4.     let mut w = Vec::new();
  5.     write!(&mut w, "test")?;
  6.     write!(&mut w, "formatted {}", "arguments")?;
  7.  
  8.     assert_eq!(w, b"testformatted arguments");
  9.     Ok(())
  10. }

Un module peut importer à la fois std::fmt::Write et std::io::Write, et appeler write! sur les objets implémentant l'un ou l'autre, car les objets n'implémentent généralement pas les deux. Cependant, le module doit éviter tout conflit entre les noms de traits, par exemple en les important sous le nom _ ou en les renommant d'une autre manière :

  1. use std::fmt::Write as _;
  2. use std::io::Write as _;
  3.  
  4. fn main() -> Result<(), Box<dyn std::error::Error>> {
  5.     let mut s = String::new();
  6.     let mut v = Vec::new();
  7.  
  8.     write!(&mut s, "{} {}", "abc", 123)?; // utilises fmt::Write::write_fmt
  9.     write!(&mut v, "s = {:?}", s)?; // utilises io::Write::write_fmt
  10.     assert_eq!(v, b"s = \"abc 123\"");
  11.     Ok(())
  12. }

Si vous avez également besoin des noms de traits eux-mêmes, par exemple pour implémenter l'un ou les deux sur vos types, importez le module conteneur, puis nommez-les avec un préfixe :

  1. use std::fmt::{self, Write as _};
  2. use std::io::{self, Write as _};
  3.  
  4. struct Example;
  5.  
  6. impl fmt::Write for Example {
  7.     fn write_str(&mut self, _s: &str) -> core::fmt::Result {
  8.          unimplemented!();
  9.     }
  10. }

Remarque : cette macro peut également être utilisée dans les configurations no_std. Dans ce cas, vous êtes responsable des détails d'implémentation des composantes.

  1. use core::fmt::Write;
  2.  
  3. struct Example;
  4.  
  5. impl Write for Example {
  6.     fn write_str(&mut self, _s: &str) -> core::fmt::Result {
  7.          unimplemented!();
  8.     }
  9. }
  10.  
  11. let mut m = Example{};
  12. write!(&mut m, "Bonjour").expect("Non écrit");    

Dernière mise à jour : Mardi, le 5 Août 2025