Rust-Syntax

Jetzt, wo du Rust ausführen kannst, schauen wir uns in Ruhe an, was die einzelnen Teile eines Programms eigentlich bedeuten. Dafür nehmen wir das kleinste mögliche Beispiel und zerlegen es Stück für Stück.

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

Ausgabe:

Hallo, Welt!

▶ Selbst ausprobieren

Die main-Funktion

fn main() {
    // hier läuft dein Code
}

Jedes Rust-Programm beginnt in einer Funktion namens main. Wenn du dein Programm startest, sucht Rust nach main und führt den Code darin aus.

• fn ist das Schlüsselwort, mit dem du eine Funktion definierst (einen Codeblock mit Namen).
• main ist der Name der Funktion. Genau dieser Name ist besonders: Er markiert den Einstiegspunkt.
• () enthält die Eingaben der Funktion (hier leer – main bekommt keine).
• { } – die geschweiften Klammern umschließen den Rumpf, also den Code, der zur Funktion gehört.

Anweisungen enden mit einem Semikolon

Im Rumpf besteht der Code meistens aus Anweisungen (Statements), und Anweisungen enden mit einem Semikolon ;:

fn main() {
    let x = 5;
    let y = 10;
    println!("{}", x + y);
}

Ausgabe:

15

▶ Selbst ausprobieren

Ein vergessenes Semikolon ist einer der häufigsten Anfängerfehler. Keine Sorge: Der Compiler zeigt dir genau, wo es fehlt.

Ausdrücke: Code, der einen Wert liefert

Rust-Code besteht aus zwei Arten von Bausteinen. Der Unterschied ist in Rust wichtiger als in den meisten anderen Sprachen:

• Eine Anweisung (Statement) tut etwas, liefert aber keinen Wert zurück. let x = 5; ist eine Anweisung.
• Ein Ausdruck (Expression) erzeugt einen Wert. 5, x + 1 und x * 2 sind alles Ausdrücke.

Und jetzt der Teil, der viele überrascht: Auch ein Codeblock in geschweiften Klammern { } ist ein Ausdruck. Sein Wert ist die letzte Zeile, ohne Semikolon geschrieben:

fn main() {
    let x = 5;
    let y = {
        let doubled = x * 2; // eine Anweisung im Block
        doubled + 1          // kein Semikolon: das ist der Wert des Blocks
    };
    println!("y ist {y}");
}

Ausgabe:

y ist 11

▶ Selbst ausprobieren

Der Block führt seine Anweisungen aus und gibt dann doubled + 1 zurück, also 11. Dieser Wert landet in y. Achte auf das Semikolon nach der schließenden }: Die ganze Zeile let y = ...; ist trotzdem eine Anweisung.

Setzt du ein Semikolon hinter doubled + 1, ist das nicht mehr der Wert des Blocks. Der Block liefert dann „nichts“ zurück (Rust schreibt das als ()), und println! kann das nicht ausgeben – der Code lässt sich also nicht kompilieren. Genau mit dieser Regel „kein Semikolon in der letzten Zeile“ geben Funktionen Werte zurück. Sie begegnet dir wieder auf der Seite Funktionen und bei if als Ausdruck.

Makros und das !

Schau dir println! genau an: Das Ausrufezeichen ist kein Tippfehler. Das ! bedeutet, dass es sich um ein Makro handelt und nicht um eine normale Funktion.

Du musst Makros jetzt noch nicht komplett verstehen. Merk dir einfach: Wenn du ein ! siehst, ist es ein Makro. Fürs Erste brauchst du nur println!, um Text auszugeben.

fn main() {
    println!("Das ist ein Makroaufruf");
}

Hinweis

Der Unterschied zwischen Funktion und Makro wird später wichtig. Als Anfänger reicht es, wenn du dir merkst: println!, format! und vec! haben ein !, weil sie Makros sind. Normale Funktionen wie main() haben keins.

Werte mit {} ausgeben

In println! sind geschweifte Klammern {} Platzhalter. Sie werden mit den Werten gefüllt, die du nach dem Text übergibst:

fn main() {
    let name = "Ferris";
    let age = 10;
    println!("{} ist {} Jahre alt", name, age);
}

Ausgabe:

Ferris ist 10 Jahre alt

▶ Selbst ausprobieren

Du kannst den Variablennamen auch direkt in die Klammern schreiben. Das ist oft übersichtlicher:

println!("{name} ist {age} Jahre alt");

Leerzeichen und Einrückung

Anders als Python kümmert sich Rust nicht um Einrückung. Es erkennt an den geschweiften Klammern { }, wo Blöcke anfangen und aufhören. Die Einrückung ist nur dafür da, dass Menschen den Code leichter lesen können.

Trotzdem gibt es in der Community einen Standardstil, und Rust bringt ein Tool mit, das ihn automatisch anwendet:

cargo fmt

cargo fmt formatiert deinen Code im offiziellen Stil. Am besten gewöhnst du dir das gleich an.

Kommentare

Du kannst in deinem Code Notizen hinterlassen, die Rust ignoriert. Das sind Kommentare, und sie beginnen mit //:

fn main() {
    // Das ist ein Kommentar – Rust überspringt ihn
    println!("Hallo!"); // Kommentare können auch am Zeilenende stehen
}

Mehr zu Kommentaren erfährst du auf der nächsten Seite.

Übungen

1. Zeig deine Rechnung

Lege zwei Variablen an, a = 7 und b = 3, und gib 7 + 3 = 10 aus. Das Addieren soll Rust übernehmen. Tipp: Ein println! kann mehrere {}-Platzhalter haben. Sie werden der Reihe nach mit den Werten nach dem Text gefüllt.

Lösung anzeigen

fn main() {
    let a = 7;
    let b = 3;
    println!("{} + {} = {}", a, b, a + b);
}

Ausgabe:

7 + 3 = 10

▶ Selbst ausprobieren

2. Ein Block, der eine Summe berechnet

Ein Shop verkauft 3 Artikel zu je 4, plus 2 für den Versand. Berechne total mit einem { }-Block: Lege darin eine Variable subtotal an und gib dann subtotal + 2 zurück. Gib Gesamt: 14 aus. Tipp: Die letzte Zeile im Block darf kein Semikolon haben.

Lösung anzeigen

fn main() {
    let price = 4;
    let quantity = 3;
    let total = {
        let subtotal = price * quantity;
        subtotal + 2 // Versand
    };
    println!("Gesamt: {total}");
}

Ausgabe:

Gesamt: 14

▶ Selbst ausprobieren

Zusammenfassung

• Jedes Programm startet in der Funktion main.
• Code steht in geschweiften Klammern { }; die meisten Anweisungen enden mit ;.
• Anweisungen tun etwas, Ausdrücke erzeugen einen Wert. Die letzte Zeile eines Blocks ohne ; ist sein Wert.
• Ein ! (wie in println!) bedeutet: Das ist ein Makro.
• {} in println! sind Platzhalter, die mit den übergebenen Werten gefüllt werden.
• Einrückung dient der Lesbarkeit – mit cargo fmt formatierst du automatisch.

Kurzer Check

Kurzer Check

1. Was ist das Besondere an der main-Funktion in einem Rust-Programm?

Sie ist der Einstiegspunkt, an dem die Ausführung beginnt Sie muss immer einen Wert zurückgeben Sie muss die erste Funktion in der Datei sein

2. Was bedeutet das ! nach println?

Es verneint die Ausgabe Es ist ein Makro, keine normale Funktion Es ist ein Syntaxfehler

3. Welchen Wert hat y nach let y = { let a = 2; a + 1 };?

2 3 Keinen, denn Blöcke können keinen Wert haben

Punkte: 0 / 3

Weiterlesen

• Die Anatomie eines Rust-Programms – Die Programmiersprache Rust: der offizielle Rundgang durch fn main, println! und Semikolons.
• Anweisungen und Ausdrücke – Die Programmiersprache Rust: weitere Beispiele zur Unterscheidung von Anweisung und Ausdruck, auch mit Blöcken.
• Hello World – Rust by Example (auf Englisch): ein winziges lauffähiges Programm und wie du es direkt mit rustc kompilierst.
• Expressions – Rust by Example (auf Englisch): kurze Beispiele für Blöcke als Werte – und was ein Semikolon am Ende bewirkt.
• Statements and expressions – The Rust Reference (auf Englisch): die genauen, formalen Regeln, falls du später neugierig wirst.