Formatierter Druck in Rust

RustRustBeginner
Jetzt üben

This tutorial is from open-source community. Access the source code

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab wird die formatierte Druckfunktionalität in Rust erklärt. Das Modul std::fmt bietet Makros wie format!, print!, println!, eprint! und eprintln! zum Handhaben von Druckaufgaben. Diese Makros ermöglichen es, Text mit Platzhaltern zu formatieren, die durch entsprechende Argumente ersetzt werden. Es können positionale und benannte Argumente verwendet werden, und verschiedene Formatierungen können mit Formatzeichen angewendet werden. Die Makros unterstützen auch die Ausrichtung von Text, das Ausfüllen von Zahlen und die Einstellung der Genauigkeit für Dezimalzahlen. Das fmt::Display-Attribut wird verwendet, um Text auf benutzerfreundliche Weise zu formatieren, während das fmt::Debug-Attribut für Debugging-Zwecke verwendet wird. Rust prüft auch die Formatierkorrektheit zur Compile-Zeit. Darüber hinaus wird erwähnt, dass das Implementieren des fmt::Display-Attributs automatisch das ToString-Attribut implementiert, und benutzerdefinierte Typen müssen das fmt::Display-Attribut implementieren, um druckbar zu sein. Das Lab enthält auch Aktivitäten, um die Verwendung der formatierten Druckmakros und Attribute zu üben.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/DataTypesGroup -.-> rust/floating_types("Floating-point Types") rust/DataTypesGroup -.-> rust/string_type("String Type") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/MemorySafetyandManagementGroup -.-> rust/lifetime_specifiers("Lifetime Specifiers") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/integer_types -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/floating_types -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/string_type -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/function_syntax -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/expressions_statements -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/lifetime_specifiers -.-> lab-99186{{"Formatierter Druck in Rust"}} rust/operator_overloading -.-> lab-99186{{"Formatierter Druck in Rust"}} end

Formatierter Druck

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)

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu formatiertem Druck abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.