Ausgabe in Rust

println! hast du schon einige Male benutzt. Auf dieser Seite lernst du die anderen Makros zur Ausgabe kennen, die dir begegnen werden – und wann du welches nimmst.

println! und print!

println! gibt Text aus und hängt am Ende einen Zeilenumbruch an. print! macht dasselbe, hängt aber keinen Zeilenumbruch an:

fn main() {
    print!("Hallo, ");
    print!("Welt");
    println!("!");
}

Ausgabe:

Hallo, Welt!

▶ Selbst ausprobieren

Alle drei Aufrufe landen in derselben Zeile – nur println! springt in eine neue. In der Praxis nimmst du fast immer println!. print! ist vor allem dann nützlich, wenn du eine Zeile Stück für Stück zusammensetzt.

Platzhalter: {} und Variablennamen

Du hast {} schon als Platzhalter gesehen. Du kannst ihn auf zwei Arten füllen: Entweder übergibst du nach dem Text einen Wert, oder du schreibst den Variablennamen direkt in die Klammern:

fn main() {
    let name = "Ferris";
    let age = 10;

    println!("{} ist {} Jahre alt", name, age); // nach Position
    println!("{name} ist {age} Jahre alt");     // direkt im Text (gleiches Ergebnis)
}

Ausgabe:

Ferris ist 10 Jahre alt
Ferris ist 10 Jahre alt

▶ Selbst ausprobieren

Beide Zeilen geben dasselbe aus. Die Schreibweise direkt im Text ({name}) ist etwas neuer und meistens leichter zu lesen. Nimm sie also, wenn es geht.

format! – einen String bauen statt ihn auszugeben

Manchmal brauchst du den formatierten Text als String, statt ihn sofort auszugeben – zum Beispiel, um ihn zu speichern oder an eine andere Funktion weiterzugeben. Genau dafür gibt es format!. Es funktioniert genau wie println!, gibt aber einen String zurück, statt etwas auszugeben:

fn main() {
    let name = "Ferris";
    let message = format!("Hallo, {name}!");
    println!("{message}");
}

Ausgabe:

Hallo, Ferris!

▶ Selbst ausprobieren

Debug-Ausgabe mit {:?}

Ein einfaches {} funktioniert nur bei Werten, die wissen, wie sie sich als Text darstellen – Zahlen, Strings, Booleans. Bei komplexeren Werten wie Tupeln oder Structs lässt sich {} nicht kompilieren. Nimm stattdessen {:?} (das „Debug“-Format):

fn main() {
    let point = (3, 7);
    println!("{:?}", point);
}

Ausgabe:

(3, 7)

▶ Selbst ausprobieren

Für eine schönere, mehrzeilige Darstellung größerer Werte nimmst du {:#?} (Pretty-Print):

fn main() {
    let point = (3, 7);
    println!("{:#?}", point);
}

Ausgabe:

(
    3,
    7,
)

▶ Selbst ausprobieren

Hinweis

Wenn Rust dir meldet, dass ein Typ „doesn’t implement Display“ (also Display nicht implementiert), ist das dein Signal: Versuch es mit {:?} statt {}. Das ist einer der häufigsten Fehler, über die Anfänger beim Ausgeben stolpern.

Zahlen formatieren

Ein paar Formatierungstricks, die du oft brauchen wirst:

fn main() {
    let pi = 3.14159;
    println!("{:.2}", pi);   // 2 Nachkommastellen -> 3.14
    println!("{:5}", 42);    // auf Breite 5 auffüllen -> "   42"
    println!("{:08.2}", pi); // mit Nullen auffüllen -> 00003.14
}

Ausgabe:

3.14
   42
00003.14

▶ Selbst ausprobieren

Auswendig lernen musst du das nicht. Es reicht zu wissen, dass es diese Möglichkeiten gibt – für den Fall, dass du Zahlen ausrichten oder Dezimalzahlen runden willst.

Text ausrichten und geschweifte Klammern ausgeben

Eine Breite funktioniert auch bei Text, und du kannst wählen, an welcher Seite der Wert klebt. Schreib nach dem : ein < (links), > (rechts) oder ^ (mittig) und dann die Breite. Davor kannst du noch ein Füllzeichen setzen, zum Beispiel -:

fn main() {
    let coffee = 3.5;
    let bagel = 2.25;

    println!("{:-^20}", " MENU ");
    println!("{:<12}{:>8}", "Item", "Price");
    println!("{:<12}{:>8.2}", "Coffee", coffee);
    println!("{:<12}{:>8.2}", "Bagel", bagel);
    println!("{:<12}{:>8.2}", "Total", coffee + bagel);
}

Ausgabe:

------- MENU -------
Item           Price
Coffee          3.50
Bagel           2.25
Total           5.75

▶ Selbst ausprobieren

Die Texte der Speisekarte bleiben hier auf Englisch, weil es um die Ausrichtung in Spalten geht – so sieht die Tabelle in jeder Sprache gleich aus.

So liest du {:>8.2} Stück für Stück: > heißt rechtsbündig, 8 ist die Breite, und .2 bedeutet zwei Nachkommastellen. Rechtsbündige Zahlen sorgen dafür, dass die Dezimalpunkte untereinanderstehen. Deshalb machen Kassenbons und Tabellen das so.

Und wenn du ein echtes { ausgeben willst? Da geschweifte Klammern „Platzhalter“ bedeuten, verdoppelst du sie: {{ gibt { aus und }} gibt } aus.

fn main() {
    println!("Menge: {{{}, {}}}", 1, 2);
}

Ausgabe:

Menge: {1, 2}

▶ Selbst ausprobieren

Fehler ausgeben

Es gibt auch eprintln! (und eprint!). Es funktioniert genau wie println!, schreibt aber in die Fehlerausgabe statt in die normale Ausgabe. Das Terminal zeigt beide an. Speichert aber jemand die Ausgabe deines Programms in eine Datei, bleiben die Fehlermeldungen draußen. Nimm es für Warnungen und Fehlermeldungen.

Übungen

1. Ein Preisschild

Speichere den Artikel "Notizbuch" und den Preis 2.5. Gib dann Notizbuch kostet 2.50 € aus. Tipp: {:.2} rundet auf zwei Nachkommastellen, und das geht auch direkt im Text: {price:.2}.

Lösung anzeigen

fn main() {
    let item = "Notizbuch";
    let price = 2.5;
    println!("{item} kostet {price:.2} €");
}

Ausgabe:

Notizbuch kostet 2.50 €

▶ Selbst ausprobieren

2. Ein Label bauen und auf zwei Arten ausgeben

Bau mit format! aus dem Namen "ferris" und der Zahl 7 ein Label ferris-7. Gib es einmal mit {} und einmal mit {:?} aus und finde den Unterschied. Tipp: format! nimmt genau dieselben Platzhalter wie println!.

Lösung anzeigen

fn main() {
    let name = "ferris";
    let id = 7;
    let label = format!("{name}-{id}");

    println!("{label}");
    println!("{label:?}");
}

Ausgabe:

ferris-7
"ferris-7"

▶ Selbst ausprobieren

Die Debug-Ausgabe zeigt Text mit Anführungszeichen. So siehst du genau, wo er anfängt und aufhört. Das ist praktisch, wenn ein Wert versehentlich Leerzeichen enthält.

Zusammenfassung

• println! gibt mit Zeilenumbruch aus, print! ohne.
• {} und {name} sind Platzhalter für Werte, die sich per Display als Text darstellen können.
• format! funktioniert wie println!, gibt aber einen String zurück, statt etwas auszugeben.
• {:?} (und {:#?}) gibt Werte zum Debuggen aus – auch solche, mit denen {} nicht klarkommt.
• {:.2} rundet Dezimalzahlen; <, > und ^ mit einer Breite richten Text aus; {{ und }} geben echte geschweifte Klammern aus.

Kurzer Check

Kurzer Check

1. Was ist der Unterschied zwischen println! und print!?

println! hängt am Ende einen Zeilenumbruch an, print! nicht print! hängt am Ende einen Zeilenumbruch an, println! nicht Es gibt keinen Unterschied

2. Warum nimmst du {:?} statt {}, um ein Tupel auszugeben?

{:?} ist schneller Tupel implementieren Display nicht, deshalb lässt sich {} nicht kompilieren {} funktioniert nur in print!, nicht in println!

Punkte: 0 / 2

Weiterlesen

• std::fmt – Doku der Standardbibliothek (auf Englisch): alle Formatierungsoptionen, auch Breite, Füllzeichen, Ausrichtung und Genauigkeit.
• Formatted print – Rust by Example (auf Englisch): lauffähige Beispiele für Positions- und benannte Argumente, Auffüllen und Ausrichten.
• Debug – Rust by Example (auf Englisch): wie {:?} und {:#?} funktionieren und wie deine eigenen Typen sie bekommen.
• println! – Doku der Standardbibliothek (auf Englisch): die offizielle Referenz zu println!, mit Links zu print! und eprintln!.
• format! – Doku der Standardbibliothek (auf Englisch): einen String nach denselben Formatierungsregeln bauen.