Dein erstes Rust-Programm

In diesem Kapitel schreiben wir unser erstes Rust-Programm, schauen uns jede Zeile im Detail an und lernen die wichtigsten Cargo-Befehle kennen.

Hello, World!

Oeffne die Datei src/main.rs in deinem Projekt. Sie enthaelt standardmaessig:

fn main() {
    println!("Hello, world!");
}

Klein, oder? Lass uns das Zeile fuer Zeile anschauen.

`fn main()`

fn leitet eine Funktion ein (kurz fuer “function”).
main ist ein besonderer Name: Jede ausfuehrbare Rust-Datei braucht eine main-Funktion. Das ist der Startpunkt des Programms.
Die Klammern () zeigen, dass die Funktion keine Parameter nimmt.
Die geschweiften Klammern { ... } bilden den Funktionsrumpf.

`println!`

println! sieht aus wie ein Funktionsaufruf, ist aber ein Makro - erkennbar am !.
Das Makro gibt einen Text auf der Konsole aus und haengt einen Zeilenumbruch an.
Der String steht in doppelten Anfuehrungszeichen.
Am Ende der Zeile steht ein Semikolon ; - jede Anweisung (statement) endet in Rust mit einem Semikolon.

Das Programm anpassen

Ersetze den Inhalt deiner main.rs mit:

fn main() {
    let name = "Rust";
    println!("Hallo, {}!", name);
    println!("Du bist bereit zu lernen.");
}

Was ist hier neu?

let name = "Rust"; legt eine Variable an (dazu gleich mehr).
{} ist ein Platzhalter im println!-Makro. Er wird durch das erste Argument nach dem String ersetzt - hier name.

Cargo-Befehle, die du kennen solltest

`cargo run`

Kompiliert dein Projekt und fuehrt es direkt aus. Der Lieblingsbefehl waehrend der Entwicklung.

cargo run

`cargo check`

Prueft, ob dein Code kompiliert - ohne eine ausfuehrbare Datei zu erzeugen. Viel schneller als cargo build. Perfekt zum haeufigen Pruefen.

cargo check

`cargo build`

Kompiliert in den target/debug-Ordner. Fuer Release-Builds:

cargo build --release

Der Release-Modus optimiert den Code und erzeugt deutlich schnellere Binaries - dauert aber auch laenger zu kompilieren.

`cargo fmt`

Formatiert deinen Code nach dem offiziellen Rust-Style.

cargo fmt

`cargo clippy`

Ein Linter mit sehr guten Vorschlaegen. Gib ihm regelmaessig die Chance, deinen Code zu verbessern.

cargo clippy

Anweisungen vs. Ausdruecke

Rust unterscheidet zwischen Statements (Anweisungen) und Expressions (Ausdruecke):

Statement: let x = 5; - tut etwas, liefert aber keinen Wert
Expression: 5 + 3 - wertet zu einem Wert aus

Ein Block { ... } ist ebenfalls ein Ausdruck. Sein Wert ist die letzte Expression ohne Semikolon:

fn main() {
    let x = {
        let a = 5;
        a + 3      // keine Semikolon - das ist der Rueckgabewert
    };
    println!("x = {}", x); // gibt "x = 8" aus
}

Dieses Konzept ist am Anfang ungewohnt, wird dir aber schnell zur zweiten Natur.

Zusammenfassung

Jedes Rust-Programm startet in main().
println! ist ein Makro (daher das !) zur Konsolenausgabe.
cargo run, cargo check, cargo fmt, cargo clippy sind deine taeglichen Begleiter.
Rust unterscheidet zwischen Statements (mit ;) und Expressions (ohne ;).

Im naechsten Kapitel vertiefen wir Variablen und die Rust-Typen.