Rust/Grundlagen

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

---

Hallo! Willkommen zu deiner ersten Reise in die Welt von Rust. Rust ist eine super coole Programmiersprache, mit der du Spiele, smarte Werkzeuge und rasante Computerprogramme bauen kannst. Sie ist wie ein Superhelden-Anzug für deinen Computer: sehr stark, sehr schnell und extrem sicher (damit dein Programm nicht einfach abstürzt)!

In diesem Kurs bauen wir alles Schritt für Schritt auf (Bottom-Up-Lernen). Wir fangen klein an und am Ende programmieren wir unsere eigenen kleinen Projekte! Außerdem mischen wir die Themen immer mal wieder durch (Interleaving), damit dein Gehirn richtig fit wird und du flexibel bleibst!

Ziel: Basiskonzepte von Rust und der Werkzeugkasten (Toolchain)

Bevor wir als Handwerker arbeiten können, brauchen wir unser Werkzeug! Bei Rust nennt man das die "Toolchain".

Lektion 1: Installation und Setup

rustup, rustc und cargo Stell dir vor, du bist der Chef in einer großen Werkstatt:

• rustup ist der Hausmeister, der dir immer die neuesten und besten Werkzeuge besorgt.
• rustc ist der eigentliche Roboter oder Übersetzer, der unseren Rust-Code in die Sprache des Computers ("Nullen und Einsen") übersetzt.
• cargo ist dein fleißiger Helfer und Projektmanager. Er besorgt dir neue Bauteile, baut dein Programm zusammen und startet es. Wir werden fast immer mit `cargo` arbeiten!

So installierst du Rust: Gehe auf die Webseite rustup.rs und folge den Anweisungen für deinen Computer.

IDE-Setup (Dein Schreibtisch) Du brauchst einen guten Texteditor ("IDE"), um deinen Code zu schreiben. Am besten nutzt du Visual Studio Code (VS Code).

• Installiere VS Code.
• Installiere die Erweiterung rust-analyzer. Diese Erweiterung ist wie dein persönlicher, unsichtbarer Programmierlehrer, der dir beim Tippen hilft, Fehler sofort rot anstreicht und dir tolle Tipps gibt!

Projekt: Dein erstes "Hello World!"-Programm

Wir bitten den Computer, uns "Hallo Welt!" zu sagen. Öffne dein Terminal (die schwarze Kommandozeile) und tippe:

cargo new hallo_welt
cd hallo_welt
cargo run

Was passiert hier genau? 1. `cargo new` legt einen neuen Projekt-Ordner für dich an ("Bauleiter cargo, bitte bereite einen Bauplatz vor!"). 2. `cd` bedeutet "change directory" – du gehst in den Ordner hinein. 3. `cargo run` startet das Einsteiger-Programm!

Wenn du in die Datei `src/main.rs` schaust, siehst du diesen Code:

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

• `fn main()` bedeutet: Hier fängt unser Programm an. `fn` steht für Funktion (ein Bauplan). Das `main()` ist das Haupttor in unser Programm.
• `println!` bedeutet "print line": Drucke eine Zeile auf den Bildschirm. Das Ausrufezeichen `!` bedeutet, dass es sich um ein "Makro" handelt. Ein Makro ist ein Spezialwerkzeug in Rust, das für uns sehr viel unsichtbare Arbeit übernimmt.
• `"Hello, world!"` ist der genaue Text, der auf dem Bildschirm erscheinen soll.

---

Lektion 2: Grundlegende Syntax

Jetzt wo der Werkzeugkoffer bereit ist, lernen wir die ersten eigenen Wörter in Rust!

Variablen und Veränderbarkeit (Mutabilität)

Eine Variable ist wie eine kleine Kiste mit einem Namensschild darauf. Du kannst dort eine Zahl oder einen Text hineinlegen und dir den Namen auf dem Schild merken. Aber Achtung! In Rust sind Kisten standardmäßig verschlossen (immutable = nicht veränderbar). Du kannst den Inhalt nicht so einfach austauschen. Das ist extrem sicher, damit aus Versehen nichts kaputtgeht. Wenn du die Kiste immer wieder neu befüllen willst, musst du `mut` (für "mutable" = veränderlich) dazuschreiben!

fn main() {
    // let bedeutet: Hier ist eine neue Kiste.
    let alter = 10; 
    // alter = 11; // 🛑 FEHLER! Diese Kiste ist verschlossen. Wir dürfen das "alter" nicht ändern.

    // let mut bedeutet: Hier ist eine neue Kiste, die sich ändern darf!
    let mut punkte = 0;
    println!("Startpunkte: {}", punkte); // Die {} sind Platzhalter, dort wird unsere Zahl eingesetzt!

    punkte = 5; // Yay! Wir haben 5 Punkte in einem Spiel gesammelt!
    println!("Neue Punkte gesammelt! Jetzt sind es: {}", punkte);
}

Kommentare

Siehst du die `//` im Code oben? Das sind Kommentare. Der Computer ignoriert alles, was nach einem `//` in der Zeile steht. Es sind geheime Notizen nur für dich oder für deine Freunde, die deinen Code lesen.

Datentypen (Was kommt in die Kiste?)

Was genau packen wir in unsere Kisten? Hier sind die wichtigsten "Typen":

• Zahlen, also Integers (Skalare): Normale Zahlen ohne Komma, z. B. `10`, `42`, `-5`.
• Kommazahlen, also Floats (Skalare): z. B. `3.14` oder `0.5`.
• Wahrheitswerte, Booleans (Skalare): Gibt es nur zwei: `true` (wahr) oder `false` (falsch).
• Text, also Strings (Verbundtypen): Wörter und Sätze in Anführungszeichen wie `"Hallo"`.

Funktionen (Eigene Baupläne schreiben)

Wir haben das Haupttor `fn main()` schon kennengelernt. Du kannst aber auch eigene Unter-Baupläne (Funktionen) erstellen!

fn main() {
    // Wir rufen unseren Unter-Bauplan auf und übergeben einen Namen:
    begruesse_spieler("Anna");
}

// Hier ist unser eigener cooler Bauplan!
// Er braucht eine Zutat "name". Das "&str" bedeutet, es muss Text (String) sein.
fn begruesse_spieler(name: &str) {
    println!("Willkommen im rustigen Abenteuer-Spiel, {}!", name);
}

---

Lektion 3: Kontrollstrukturen (Wir fällen Entscheidungen!)

Programme wären sehr langweilig, wenn sie immer nur exakt das Gleiche tun. Wir wollen, dass unser Code kluge Entscheidungen trifft!

if, else if, else (Wenn ... Dann ...)

Stell dir vor, du bist an einer Weggabelung und musst ein Schild lesen.

fn main() {
    let alter = 10;

    if alter >= 18 {
        println!("Du darfst ein echtes Auto fahren!");
    } else if alter >= 10 {
        println!("Du darfst ein super cooles Fahrrad mit Gangschaltung fahren!");
    } else {
        println!("Fahr lieber sicher mit dem Roller auf dem Hof!");
    }
}

Erklärung: Das Programm prüft die erste Bedingung (ist alter 18 oder mehr?). Wenn ja, führt es den Block aus. Wenn nein, fragt es das `else if`. Wenn auch das nicht stimmt, führt es die letzte Möglichkeit beim `else` aus.

Schleifen (Wir wiederholen Dinge, bis wir müde sind!)

Wir möchten nicht denselben Code 100 Mal als Text tippen. Dafür gibt es Schleifen!

• loop: Läuft für immer und ewig im Kreis... bis du das magische Wort `break` sagst!
• while: Läuft SOLANGE eine einfache Bedingung `true` (wahr) ist.
• for: Zählt einfach von einem Startpunkt zu einem Endpunkt durch. (Die beste Schleife für Anfänger und sehr sicher!)

fn main() {
    // Die FOR-Schleife: Zählt von 1 bis 3
    println!("Achtung, Raketenstart in...");
    for zahl in 1..4 { // Zählt 1, 2, 3 (die 4 am Ende gehört nicht mehr dazu!)
        println!("{}...", zahl);
    }
    println!("Zündung! 🚀");

    // Die WHILE-Schleife (Mit Veränderbarkeit gemischt - "Interleaving"!): 
    let mut energie = 3;
    while energie > 0 {
        println!("Roboter stapft herum... Energie bei {}", energie);
        energie = energie - 1; // Energie wird pro Schritt weniger!
    }
    println!("Dem Roboter fehlt Energie. Er schläft jetzt ein. 💤");
}

---

Projekte & Übungen

Durch eigene, praxisnahe Mini-Projekte lernst du am besten! Hier darfst du selbst kreativ werden.

Projekt Vorschlag 1: Der kluge Zahlen-Magier (Variablen & If)

Deine Aufgabe: Erstelle ein Projekt und schreibe ein Programm, das zwei verschiedene Zahlen in Variablen speichert (z. B. `let ritter_stärke = 10; let drachen_stärke = 20;`).

• Der Zahlen-Magier soll die beiden Zahlen zusammen addieren (+) und in einer neuen, veränderlichen Variablen speichern.
• Wenn das Ergebnis größer als 25 ist, soll das Programm "Magie! Der Angriff ist sehr stark!" ausgeben. Wenn es kleiner ist: "Der Angriff hat keine Wirkung, versammle mehr Stärke!".

Tipp: Verbinde hier Datentypen (Zahlen) mit Entweder/Oder-Entscheidungen (`if` / `else`)!

Projekt Vorschlag 2: Das tickende Sicherheitssystem (While & Mutabilität)

Deine Aufgabe: Simuliere ein einfaches Sicherheitssystem.

• Erstelle eine veränderliche Variable `let mut versuche = 3;`.
• Benutze eine `while`-Schleife, die nur solange läuft, wie `versuche > 0` ist.
• In der Schleife sagst du: `"Falsches Passwort! Noch {} Versuche übrig."` und reduzierst die Variable sofort um eins (`versuche = versuche - 1`).
• Nach der Schleife (wenn alles durchgelaufen ist) gibst du aus: `"Sicherheitssystem gesperrt! Alarm!"`

Projekt Vorschlag 3: Der nervige Papageien-Helfer (Funktionen & For-Schleifen)

Deine Aufgabe: Erstelle eine eigene Funktion `fn papagei(text: &str, anzahl: i32)`.

• In dieser Funktion nutzt du eine `for`-Schleife, um den `text` genauso oft zu wiederholen (`anzahl`), wie die Zahl groß ist!
• Rufe diese neue Funktion dann ganz oben in deiner `fn main()` auf, zum Beispiel so: `papagei("Polly will einen Keks!", 5)`.

Tipp: Hier bauen wir ganz klassisch von den Schleifen und Variablen auf (Bottom-Up) bis hin zur eigenen Funktion, in die man Werte hineinreicht!

---

Quiz (Teste dein Wissen)

<quiz> Lass uns überprüfen, was in deinem Kopf hängengeblieben ist! Fülle die Lücken aus.

{Complete the text from the Rust Basics Lesson. |type="{}"} In Rust ist eine Variable { verschlossen|immutable _10 }, wenn man nur `let` ohne Zusätze schreibt, man kann den Wert dann nicht mehr ändern. Um eine Kiste doch veränderbar zu machen, muss man das magische Wort { mut _5 } dazuschreiben. Unser fleißiger Hausmeister und Helfer, der neue Projekte mit `new` anlegt und mit `run` direkt ausführt, heißt { cargo _5 }. Um einen tollen Text auf dem Bildschirm auszugeben, nutzen wir das eingebaute Makro { println! _8 } mit einem Ausrufezeichen am Ende.

{Complete the text about Rust Control Structures. |type="{}"} Wenn ein Stück Code nur ausgeführt werden soll, falls eine bestimmte Bedingung wahr ist, nutzen wir die Entweder-Oder-Verzweigung namens { if _5 }. Um ein paar Zahlen in einer Schleife zum Beispiel von 1 bis 10 durchzuzählen, nehmen wir am besten die praktische { for _5 }-Schleife. Wenn wir aber etwas "solange" wiederholen wollen, wie eine bestimmte Bedingung "wahr" ist, eignet sich die { while _5 }-Schleife. Eine Schleife, die ewig für immer läuft und unsichtbare Runden dreht, nennt man { loop _5 } und man kann sie nur mit dem Not-Aus-Befehl { break _8 } mitten im Flug stoppen. </quiz>

---

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).