Der Druck wird durch eine Reihe von Makros
behandelt, die in std::fmt
definiert sind, darunter einige:
format!
: formatierten Text in eine String
schreiben.
print!
: wie format!
, aber der Text wird auf der Konsole (io::stdout) gedruckt.
println!
: wie print!
, aber ein Zeilenumbruch wird angehängt.
eprint!
: wie print!
, aber der Text wird auf die Standardfehlerausgabe (io::stderr) gedruckt.
eprintln!
: wie eprint!
, aber ein Zeilenumbruch wird angehängt.
Alle analysieren den Text auf die gleiche Weise. Als Plus prüft Rust die Formatierkorrektheit zur Compile-Zeit.
fn main() {
// Im Allgemeinen wird `{}` automatisch durch beliebige
// Argumente ersetzt. Diese werden in einen String umgewandelt.
println!("{} Tage", 31);
// Es können positionale Argumente verwendet werden. Die Angabe einer ganzen Zahl innerhalb von `{}`
// bestimmt, welches zusätzliche Argument ersetzt werden soll. Die Argumente beginnen
// bei 0 direkt nach der Formatzeichenfolge.
println!("{0}, dies ist {1}. {1}, dies ist {0}", "Alice", "Bob");
// Ebenso können benannte Argumente verwendet werden.
println!("{subject} {verb} {object}",
object="der faulige Hund",
subject="der schnelle braune Fuchs",
verb="springt über");
// Verschiedene Formatierungen können durch Angabe des Formatzeichens
// nach einem `:` aufgerufen werden.
println!("Base 10: {}", 69420); // 69420
println!("Base 2 (binär): {:b}", 69420); // 10000111100101100
println!("Base 8 (oktal): {:o}", 69420); // 207454
println!("Base 16 (hexadezimal): {:x}", 69420); // 10f2c
println!("Base 16 (hexadezimal): {:X}", 69420); // 10F2C
// Sie können Text rechtsbündig mit einer angegebenen Breite ausrichten. Dies wird
// " 1" ausgeben. (Vier Leerzeichen und eine "1", für eine Gesamtbreite von 5.)
println!("{number:>5}", number=1);
// Sie können Zahlen mit zusätzlichen Nullen auffüllen,
println!("{number:0>5}", number=1); // 00001
// und linksbündig durch Umschreiben des Zeichens. Dies wird "10000" ausgeben.
println!("{number:0<5}", number=1); // 10000
// Sie können benannte Argumente im Formatangaben durch Anhängen eines `$` verwenden.
println!("{number:0>width$}", number=1, width=5);
// Rust prüft sogar, ob die richtige Anzahl von Argumenten verwendet wird.
println!("Mein Name ist {0}, {1} {0}", "Bond");
// FIXME ^ Fügen Sie das fehlende Argument hinzu: "James"
// Nur Typen, die fmt::Display implementieren, können mit `{}` formatiert werden. Benutzerdefinierte
// Typen implementieren fmt::Display standardmäßig nicht.
#[allow(dead_code)] // deaktiviert `dead_code`, das Warnungen vor nicht verwendeten Modulen ausgibt
struct Structure(i32);
// Dies wird nicht kompilieren, da `Structure` fmt::Display nicht implementiert.
// println!("Dieses Struct `{}` wird nicht gedruckt...", Structure(3));
// TODO ^ Versuchen Sie, diese Zeile zu entsperren
// Ab Rust 1.58 können Sie das Argument direkt aus einer umgebenden Variable erfassen. Genau wie oben wird dies
// " 1" ausgeben, 4 Leerzeichen und eine "1".
let number: f64 = 1.0;
let width: usize = 5;
println!("{number:>width$}");
}
std::fmt
enthält viele Attribute
, die die Darstellung von Text steuern. Die grundlegenden Formen zweier wichtiger Attribute werden unten aufgeführt:
fmt::Debug
: Verwenden des {:?}
-Markers. Text für Debugging-Zwecke formatieren.
fmt::Display
: Verwenden des {}
-Markers. Text auf eine elegantere, benutzerfreundlichere Weise formatieren.
Hier haben wir fmt::Display
verwendet, da die std-Bibliothek Implementierungen für diese Typen bereitstellt. Um Text für benutzerdefinierte Typen zu drucken, sind weitere Schritte erforderlich.
Das Implementieren des fmt::Display
-Attributs implementiert automatisch das ToString
-Attribut, das uns ermöglicht, den Typ in eine String
umzuwandeln.
In Zeile 43 ist #[allow(dead_code)]
ein [Attribut], das nur auf das nachfolgende Modul anwendbar ist.
Aktivitäten
- Beheben Sie das Problem im obigen Code (siehe FIXME), so dass er ohne Fehler läuft.
- Versuchen Sie, die Zeile zu entsperren, in der versucht wird, das
Structure
-Struct zu formatieren (siehe TODO)
- Fügen Sie einen
println!
-Makros-Aufruf hinzu, der ausgibt: Pi ist ungefähr 3.142
, indem Sie die Anzahl der angezeigten Dezimalstellen steuern. Zu Zwecken dieses Übungs verwenden Sie let pi = 3.141592
als Schätzung für Pi. (Hinweis: Sie müssen möglicherweise die std::fmt
-Dokumentation überprüfen, um die Anzahl der anzuzeigenden Dezimalstellen festzulegen)