Rust Tutorial
Erste Schritte mit Rust

Bemerkungen

Versionen

Erweiterte Nutzung von Println!

println! (und sein gleichgeordnetes Element, print! ) bietet einen bequemen Mechanismus zum Erstellen und Drucken von Text, der dynamische Daten enthält, ähnlich wie bei der printf Funktionsfamilie in vielen anderen Sprachen. Das erste Argument ist eine Formatzeichenfolge , die festlegt, wie die anderen Argumente als Text gedruckt werden sollen. Die Formatzeichenfolge kann Platzhalter (eingeschlossen in {} ) enthalten, um anzugeben, dass eine Ersetzung erfolgen soll:

// No substitution -- the simplest kind of format string
println!("Hello World");
// Output: Hello World

// The first {} is substituted with a textual representation of
// the first argument following the format string. The second {}
// is substituted with the second argument, and so on.
println!("{} {} {}", "Hello", true, 42);
// Output: Hello true 42

An diesem Punkt fragen Sie vielleicht: Wie haben Sie println! wissen, dass der boolesche Wert true als Zeichenfolge "true" ausgegeben wird? {} ist wirklich eine Anweisung an den Formatierer, dass der Wert mit der Eigenschaft Display in Text konvertiert werden soll. Diese Eigenschaft wird für die meisten primitiven Rust-Typen (Zeichenfolgen, Zahlen, Boolesche Elemente usw.) implementiert und ist für die "benutzerorientierte Ausgabe" gedacht. Daher wird die Zahl 42 dezimal als 42 ausgegeben und nicht etwa binär, so wie sie intern gespeichert wird.

Wie drucken wir also Typen, die keine Display implementieren, Beispiele sind Slices ( [i32] ), Vektoren ( Vec<i32> ) oder Optionen ( Option<&str> )? Es gibt keine eindeutige Textdarstellung für den Benutzer (dh eine, die Sie trivial in einen Satz einfügen könnten). Um das Drucken dieser Werte zu erleichtern, verfügt Rust auch über die Eigenschaft Debug und den entsprechenden Platzhalter {:?} . Aus der Dokumentation: " Debug sollte die Ausgabe in einem für den Programmierer gerichteten Debugging-Kontext formatieren." Sehen wir uns einige Beispiele an:

println!("{:?}", vec!["a", "b", "c"]);
// Output: ["a", "b", "c"]

println!("{:?}", Some("fantastic"));
// Output: Some("fantastic")

println!("{:?}", "Hello");
// Output: "Hello"
// Notice the quotation marks around "Hello" that indicate
// that a string was printed.

Debug verfügt außerdem über einen eingebauten Pretty-Print-Mechanismus, den Sie mit dem Modifikator # nach dem Doppelpunkt aktivieren können:

println!("{:#?}", vec![Some("Hello"), None, Some("World")]);
// Output: [
//    Some(
//        "Hello"
//    ),
//    None,
//    Some(
//        "World"
//    )
// ]

Mit den Formatzeichenfolgen können Sie ziemlich komplexe Ersetzungen ausdrücken:

// You can specify the position of arguments using numerical indexes.
println!("{1} {0}", "World", "Hello");
// Output: Hello World

// You can use named arguments with format
println!("{greeting} {who}!", greeting="Hello", who="World");
// Output: Hello World

// You can mix Debug and Display prints:
println!("{greeting} {1:?}, {0}", "and welcome", Some(42), greeting="Hello");
// Output: Hello Some(42), and welcome

println! und Freunde werden Sie auch warnen, wenn Sie versuchen, etwas zu tun, das nicht funktioniert und nicht zur Laufzeit abstürzt:

// This does not compile, since we don't use the second argument.
println!("{}", "Hello World", "ignored");

// This does not compile, since we don't give the second argument.
println!("{} {}", "Hello");

// This does not compile, since Option type does not implement Display
println!("{}", Some(42));

Im Grunde sind die Rust-Druckmakros einfach das format! umhüllen format! Makro, das das Erstellen einer Zeichenfolge durch Zusammenfügen von Textdarstellungen verschiedener Datenwerte ermöglicht. Für alle obigen Beispiele können Sie println! für das format! um die formatierte Zeichenfolge zu speichern, anstatt sie zu drucken:

let x: String = format!("{} {}", "Hello", 42);
assert_eq!(x, "Hello 42");

Konsolenausgabe ohne Makros

// use Write trait that contains write() function
use std::io::Write;

fn main() {
    std::io::stdout().write(b"Hello, world!\n").unwrap();
}

• Die Eigenschaft std::io::Write wurde für Objekte entwickelt, die Byte-Streams akzeptieren. In diesem Fall wird ein Handle für die Standardausgabe mit std::io::stdout() .

• Write::write() akzeptiert ein Byte-Slice ( &[u8] ), das mit einem Byte-String-Literal ( b"<string>" ) erstellt wird. Write::write() gibt ein Result<usize, IoError> , das entweder die Anzahl der geschriebenen Bytes (bei Erfolg) oder einen Fehlerwert (bei Fehler) enthält.

• Der Aufruf von Result::unwrap() zeigt an, dass der Aufruf erfolgreich ausgeführt werden soll ( Result<usize, IoError> -> usize ) und der Wert wird verworfen.

Minimales Beispiel

Um das traditionelle Hello World-Programm in Rust zu schreiben, erstellen Sie eine Textdatei mit dem Namen hello.rs die den folgenden Quellcode enthält:

fn main() {
    println!("Hello World!");
}

Dies definiert eine neue Funktion namens main , die keine Parameter übernimmt und keine Daten zurückgibt. Hier beginnt Ihr Programm, wenn es ausgeführt wird. Darin hast du einen println! Dies ist ein Makro, das Text in die Konsole druckt.

Um eine binäre Anwendung zu generieren, rufen Sie den Rust-Compiler auf, indem Sie ihm den Namen der Quelldatei übergeben:

$ rustc hello.rs

Die resultierende ausführbare Datei hat denselben Namen wie das Hauptquellenmodul. Um das Programm auf einem Linux- oder MacOS-System auszuführen, führen Sie folgendes aus

$ ./hello
Hello World!

Führen Sie auf einem Windows-System Folgendes aus:

C:\Rust> hello.exe
Hello World!

Fertig machen

Installieren

Bevor Sie etwas mit der Programmiersprache Rust machen können, müssen Sie sie erwerben. Entweder für Windows oder durch Verwendung Ihres Terminals auf Unix-ähnlichen Systemen, wobei $ die Eingabe in das Terminal symbolisiert:

$ curl https://sh.rustup.rs -sSf | sh

Dadurch werden die erforderlichen Dateien abgerufen und die neueste Version von Rust für Sie eingerichtet, unabhängig davon, auf welchem ​​System Sie sich gerade befinden. Weitere Informationen finden Sie auf der Projektseite .

Hinweis: Einige Linux-Distributionen (z. B. Arch Linux ) bieten rustup als Paket an, das stattdessen installiert werden kann. Obwohl viele Unix-ähnliche Systeme rustc und cargo als separate Pakete bereitstellen, rustc es sich dennoch, stattdessen rustup verwenden, da dies die Verwaltung mehrerer Freigabekanäle und die rustup erheblich vereinfacht.

Rust Compiler

Wir können nun prüfen, ob Rust tatsächlich erfolgreich auf unseren Computern installiert wurde. Führen Sie dazu den folgenden Befehl in unserem Terminal (unter UNIX) oder an der Eingabeaufforderung (unter Windows) aus:

$ rustc --version

Wenn dieser Befehl erfolgreich ist, wird die auf unseren Computern installierte Version von Rusts Compiler vor unseren Augen angezeigt.

Ladung

Mit Rust kommt Cargo , ein Build-Tool zum Verwalten Ihrer Rust- Pakete und -Projekte. Um sicherzustellen, dass dies auch auf Ihrem Computer vorhanden ist, führen Sie die folgenden Schritte in der Konsole aus - Konsole - entweder Terminal oder Eingabeaufforderung, je nachdem, auf welchem ​​System Sie sich gerade befinden:

$ cargo --version

Genau wie der entsprechende Befehl für den Rust- Compiler wird dieser zurückgegeben und die aktuelle Version von Cargo angezeigt.

Um Ihr erstes Cargo-Projekt zu erstellen, können Sie zu Cargo gehen .

Alternativ können Sie Programme auch mithilfe von rustc kompilieren, wie im Minimal-Beispiel gezeigt .