Rust/Grundlagen: Unterschied zwischen den Versionen

← Zum vorherigen Versionsunterschied Zum nächsten Versionsunterschied →

Version vom 3. März 2026, 21:34 Uhr

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 in der spannenden Welt von Rust! Stell dir vor, du bist ein Erfinder, und dein Computer ist eine riesige Werkstatt. Rust ist dein cooles, neues Werkzeug, mit dem du super schnelle und sichere Maschinen (also Programme!) bauen kannst.

In diesem Lernpfad schauen wir uns an, wie du dieses Werkzeug benutzt. Wir machen viele kleine, spannende Projekte und mischen die Themen gut durch (das nennt man "Interleaving"), damit dein Gehirn immer wieder neu herausgefordert wird und du dir alles besser merken kannst! Wir fangen ganz unten bei den einfachen Dingen an und bauen darauf auf ("Bottom-Up").

Ziel: Verstehe die Bausteine von Rust!

Wir werden lernen, wie Rust denkt und funktioniert. Am Ende kannst du deinem Computer Befehle geben und eigene kleine Programme schreiben!

Modul 1: Deine Werkstatt einrichten (Installation & Setup)

Bevor wir bauen können, müssen wir unsere Werkstatt vorbereiten!

1. Installation: `rustup`, `rustc` und `cargo`

Um Rust zu sprechen, brauchen wir drei wichtige Helferlein:

`rustup`: Das ist der Werkstatt-Manager. Er holt dir immer die neuesten Werkzeuge.
`rustc`: Das ist der Übersetzer. Er übersetzt das, was du schreibst, in eine Sprache, die der Computer versteht (Maschinensprache).
`cargo`: Das ist dein Roboter-Assistent! Er baut deine Programme zusammen, packt sie ein und hilft dir beim Aufräumen.

So geht's auf dem Computer: Wenn du unter Linux oder macOS arbeitest, tippst du folgendes in ein schwarzes Fenster, das sich Terminal nennt:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Das sieht ein bisschen wie ein Zauberspruch aus, oder? Dieser Befehl holt die Helfer auf deinen Computer.

2. Dein erstes Programm: „Hello World!“

Lassen wir deinen Computer "Hallo Welt!" sagen! Rust freut sich nämlich, dich kennenzulernen. Öffne das Terminal und gib diesen Befehl ein (denk daran: Cargo ist dein Roboter-Assistent!):

cargo new hallo_welt
cd hallo_welt

Wenn du jetzt eine Datei namens `main.rs` (in deinem neuen Ordner `src`) öffnest, solltest du diesen Code sehen:

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

`fn main()` bedeutet: "Hier fangen wir an!". `fn` steht für Funktion – das ist ein Block aus Befehlen.
`println!` bedeutet: "Drucke eine Zeile (print line) Text auf den Bildschirm". Das `!` zeigt, dass das ein besonderer Taschenspielertrick in Rust ist (man nennt das ein "Makro").

Tippe jetzt in dein Terminal:

cargo run

Und tada! Der Computer sagt "Hello, world!" zu dir!

3. Dein Schreibtisch: IDE (z.B. VS Code) einrichten

Du kannst deinen Code nicht einfach auf einen Schmierzettel schreiben. Es gibt tolle Programme dafür. Ein beliebtes Programm heißt Visual Studio Code (kurz: VS Code). Das ist wie ein super schlaues Notizbuch. Wenn du VS Code installiert hast, lade dir die Erweiterung (ein kleines Extra-Werkzeug) namens "rust-analyzer" herunter. Er ist wie ein kluger Lehrer, der dir rote Striche zeigt, wenn du dich vertippst, und dir tolle Tipps gibt.

Modul 2: Die ersten Bausteine (Grundlegende Syntax)

1. Kisten für Notizen: Variablen (`let`, `let mut`)

Stell dir vor, du hast eine Kiste. In diese Kiste kannst du etwas reinlegen. Das nennt man in Rust eine "Variable". Um eine Kiste zu machen, sagen wir `let`:

fn main() {
    let alter = 10; // Wir erstellen eine Kiste "alter" und legen die 10 rein.
    println!("Ich bin {} Jahre alt.", alter); // Die {} machen Platz für unsere Zahl!
}

Achtung! In Rust sind Kisten normalerweise fest zugeklebt! Wenn du `let alter = 10;` machst, kannst du danach `alter` NICHT mehr auf 11 ändern. Wenn du eine Kiste haben willst, bei der du das, was drinnen ist, später austauschen darfst, musst du `mut` (wie mutabel oder veränderbar) dazu schreiben!

fn main() {
    let mut taschengeld = 5; // mut bedeutet: Ich darf den Wert ändern!
    println!("Ich habe {} Euro.", taschengeld);
    
    taschengeld = 10; // Jetzt habe ich mehr bekommen!
    println!("Juhu, jetzt habe ich {} Euro!", taschengeld);
}

2. Verschiedene Dinge aufbewahren: Datentypen

Es gibt nicht nur Zahlen! In deine Kisten passen verschiedene Dinge:

Ganze Zahlen (Integer): z.B. `10`, `42`, `-5`.
Kommazahlen (Float): z.B. `3.14` oder `2.5`.
Wahrheitswerte (Booleans): Das kann nur `true` (Wahr) oder `false` (Falsch) sein. Perfekt, um zu prüfen, ob das Licht an ist!
Buchstaben und Wörter (Char und String): Ein einzelner Buchstabe ist ein 'A', ein ganzer Text ist "Hallo!".

fn main() {
    let note = 1;               // Eine ganze Zahl
    let gewicht = 35.5;         // Eine Kommazahl
    let ist_es_tag = true;      // Boolean (Wahr)
    let anfangsbuchstabe = 'T'; // Ein Zeichen in einfachen Anführungszeichen
    let name = "Thorsten";      // Ein Text in doppelten Anführungszeichen
}

Manchmal packt man auch Dinge zusammen!

Tupel: Ein Regalbrett mit festen Dingen, z.B. deine Lieblingsfarbe und deine Glückszahl. `let mein_tupel = ("Blau", 7);`
Array: Eine Liste von mehreren Dingen, die aber alle vom gleichen Typ sein müssen. `let meine_noten = [1, 2, 1, 3];`

3. Mini-Fabriken: Funktionen

Wenn du denselben Code oft brauchst, kannst du ihn verpacken. Das ist eine Funktion. Die `main()`-Funktion kennst du schon! Lass uns eine Fabrik bauen, die immer "Guten Morgen" sagt und den Namen dazu:

// Hier ist unsere neue Fabrik!
fn sage_hallo(name: &str) {
    println!("Guten Morgen, {}!", name);
}

fn main() {
    sage_hallo("Lukas"); // Wir rufen die Fabrik auf und geben ihr den Namen.
    sage_hallo("Mia");
}

Kommentare: Manchmal möchtest du dir was notieren, das der Computer ignorieren soll. Mach einfach `//`. Alles danach in der Zeile ist für dich!

Modul 3: Der Verkehrspolizist (Kontrollstrukturen)

Ein Programm muss auch Entscheidungen treffen können!

1. Wenn dies, dann das: `if`, `else if`, `else`

Stell dir vor, du stehst vor einer Ampel.

fn main() {
    let ampel = "Rot";

    if ampel == "Grün" {
        // Wenn Grün, dann gehen.
        println!("Du darfst über die Straße gehen!");
    } else if ampel == "Rot" {
        // Oder wenn Rot, dann stehen bleiben.
        println!("Halt! Warten!");
    } else {
        // Sonst (zum Beispiel wenn sie aus ist).
        println!("Pass gut auf!");
    }
}

Das ist ein Wegweiser für dein Programm! Analyzed ~/Übungen Thought for 118s

Edited thorsten.wiki +448 -0 Thought for 2s

2. Immer wieder: Schleifen (`loop`, `while`, `for`)

Manchmal möchtest du Dinge wiederholen, ohne sie tausendmal zu tippen.

Die Endlos-Schleife (`loop`): Das ist wie ein Hamsterrad, es dreht sich immer weiter, bis du "Stopp!" (`break`) rufst!

fn main() {
    let mut zähler = 0;
    loop {
        zähler = zähler + 1;
        println!("Wir sind bei {}!", zähler);
        if zähler == 3 {
            println!("Genug gedreht!");
            break; // Hier springen wir aus der Schleife raus
        }
    }
}

Solange etwas stimmt (`while`): Wiederhole etwas, solange eine Bedingung wahr ist.

fn main() {
    let mut kekse = 3;
    while kekse > 0 {
        println!("Ich esse einen Keks! Übrig sind: {}", kekse);
        kekse = kekse - 1; // Ein Keks ist weg!
    }
    println!("Alle Kekse aufgegessen!");
}

Für jedes Stück (`for`): Perfekt, um eine Liste oder einen bestimmten Zeitraum durchzugehen.

fn main() {
    // 1..4 bedeutet die Zahlen 1, 2 und 3 (die 4 ist nicht dabei!)
    for zahl in 1..4 {
        println!("Countdown: {}", zahl);
    }
    println!("Los geht's!");
}

Praxis-Projekte: Werde zum Meister-Erfinder!

Hier mischen wir alles (Interleaving!). Versuche, diese Projekte selber in VS Code zu schreiben!

Projekt 1: Der Taschengeld-Rechner

Was es tun soll: Lege fest, wie viel Taschengeld du pro Monat bekommst (z.B. `let pro_monat = 20;`). Berechne dann, wie viel du in einem ganzen Jahr (12 Monate) bekommst! Gib das Ergebnis mit `println!` aus.

Projekt 2: Der Geheimtür-Wächter

Was es tun soll: Lege ein Passwort fest `let geheimes_passwort = "Apfelsaft";`. Benutze dann eine `if`-Abfrage! Teste, ob jemand das richtige Passwort hat. Wenn ja, schreibe "Tür öffnet sich". Wenn nein, schreibe "Alarm!!!".

Projekt 3: Der Raketen-Start! (Countdown)

Was es tun soll: Schreibe ein Programm, das von 10 herunterzählt bis 1! Nutze dafür am besten eine `while`-Schleife. Wenn es bei 0 ist, soll der Computer "Rakete startet! Wuuuuuuusch!" auf den Bildschirm schreiben.

Projekt 4: Der Temperatur-Bewerter

Was es tun soll: Lege als Variable (Typ: ganze Zahl) das aktuelle Wetter in Grad Celsius fest. Wenn es über 25 Grad hat, schreibe "Lass uns Eis essen!". Unter 10 Grad "Zieh eine Jacke an!". Dazwischen "Perfektes Spielwetter!". Nutze dafür `if` und `else if`.

Projekt 5: Einmaleins-Trainer (Bottom-Up Aufgabe)

Was es tun soll: Schreibe eine `for`-Schleife, die dir die 7er-Reihe aufschreibt: 7, 14, 21 ... bis 70.
Extra schwer: Schreib das so, dass du die Zahl, z.B. die 7, nur oben in eine Variable packst (`let reihe = 7;`).

🧠 Großes Rust-Quiz 🧠

Teste jetzt dein neues Wissen aus dem Lernpfad!

<quiz display=simple> {Rust-Wissenstest 1: Vervollständige die Lücken |type="{}"} Um einen veränderbaren Wert in Rust zu speichern, schreibst du nach "let" das Wort { mut _3 }. Damit der Computer deinen Text auf den Bildschirm malt, benutzt du { println! _8 }("Hallo!"). Der Befehl in der Konsole, der ein neues Bauprojekt erstellt, fängt an mit { cargo _5 } new mein_projekt. Die Abkürzung für eine Funktion heisst { fn _2 } und die Hauptfunktion, in der dein Programm immer startet, nennt sich { main _4 }. </quiz>

<quiz display=simple> {Rust-Wissenstest 2: Datentypen und Variablen |type="{}"} Um eine Kommazahl wie 3.5 abzuspeichern, verwendet Rust den Typ { Float _5 } (Gleitkommazahl). Wahrheitswerte wie "true" und "false" nennt man auch { Booleans _8 }. Um eine Schleife zu bauen, die FÜR jede Zahl von 1 bis 10 durchläuft, nutzen wir das { for _3 }-Schlüsselwort. Mit einem doppelten { // _2 } sagst du Rust, dass du dir eine Notiz gemacht hast (Kommentar). Das Programm überspringt das einfach. Eine unendliche Schleife kannst du durch den Befehl { break _5 } beenden. </quiz>

<quiz display=simple> {Rust-Wissenstest 3: Vervollständige das Hallo-Welt Programm |type="{}"} fn { main _4 }() {

   println!("Hello, { world _5 }!");

} </quiz>

<quiz display=simple> {Rust-Wissenstest 4: Vervollständige die Variable |type="{}"} Um sicherzustellen, dass sich der Wert nicht ändert: { let _3 } alter = 10; Um den Wert später noch ändern zu können: let { mut _3 } guthaben = 5; guthaben = 10; </quiz>

<quiz display=simple> {Rust-Wissenstest 5: Vervollständige die If-Abfrage |type="{}"} let hunger = true; { if _2 } hunger == true {

   println!("Lass uns Kuchen essen!");

} { else _4 } {

   println!("Ich bin satt!");

} </quiz>

<quiz display=simple> {Rust-Wissenstest 6: Vervollständige die Loop-Schleife |type="{}"} let mut runden = 0; { loop _4 } {

   runden = runden + 1;
   if runden == 3 {
       { break _5 };
   }

} </quiz>

<quiz display=simple> {Rust-Wissenstest 7: Vervollständige die For-Schleife |type="{}"} // Wir zählen von 1 bis 5 (ohne 6) { for _3 } zahl in 1..6 {

   println!("Zahl: {}", { zahl _4 });

} </quiz>

<quiz display=simple> {Rust-Wissenstest 8: Funktionen |type="{}"} Vervollständige den Aufbau einer neuen Funktion, die "winken" heißt. { fn _2 } winken() {

   println!("*Winkt*");

} Um die Funktion auszuführen, schreibst du in der main() einfach { winken(); _9 } </quiz>

<quiz display=simple> {Rust-Wissenstest 9: Toolchain |type="{}"} Das Programm, das deinen Rust-Code "übersetzt", heißt { rustc _5 } . Das Programm, von dem man seine Bibliothek an Tools bekommt, also den Installer, nennt man { rustup _6 } . Ein "cargo { run _3 }" startet in der Konsole das fertig gebaute Programm. </quiz>

<quiz display=simple> {Rust-Wissenstest 10: Array und Tupel |type="{}"} Sollen verschiedene Werte, wie eine Note von der Schule (Zahl) und dein Name (Wort) eng zusammen stehen, verpackst du sie am geschicktesten in ein { Tupel _5 }. Möchtest du eine Liste von lauter gleichen Dingen, zum Beispiel fünf T-Shirts speichern, benutzt du am besten ein { Array _5 }. </quiz>

<quiz display=simple> {Rust-Wissenstest 11: While-Schleife |type="{}"} let mut wasser = 5; { while _5 } wasser > 0 {

   println!("Schluck trinken!");
   wasser = wasser - 1;

} </quiz>

<quiz display=simple> {Rust-Wissenstest 12: Fehler finden |type="{}"} Warum funktioniert der folgende Code nicht? let hund = "Bello"; hund = "Wuffi"; Weil vor "hund" in der ersten Zeile das Wort { mut _3 } fehlt! </quiz>

<quiz display=simple> {Rust-Wissenstest 13: IDE und Editor |type="{}"} Die intelligente Hilfe für VS Code, die Fehler beim Tippen direkt unterstreicht und das Leben eines Rust-Programmierers extrem vereinfacht, heißt rust-{ analyzer _8 } . </quiz>

<quiz display=simple> {Rust-Wissenstest 14: Konsolen-Befehl |type="{}"} Wenn ich ein neues Projekt machen möchte, das "Spiel" heisst, welche beiden Wörter schreibe ich am Anfang in meiner Konsole? { cargo new _9 } Spiel </quiz>

<quiz display=simple> {Rust-Wissenstest 15: If-Else-If |type="{}"} let alter = 10; if alter < 6 {

   println!("Kindergarten");

} else { if _2 } alter < 11 {

   println!("Grundschule");

} else {

   println!("Weiterführende Schule");

} </quiz>

<quiz display=simple> {Rust-Wissenstest 16: Code-Block Klammern |type="{}"} Eine Funktion braucht für ihren Code immer diese runden, gebogenen Klammern. Das sind { geschweifte _11 } Klammern. Auf der Tastatur tippt man "{" und "}". </quiz>

<quiz display=simple> {Rust-Wissenstest 17: Variablen überschreiben |type="{}"} let mut kekse = 2; kekse = 5; Welche Zahl ist nun in der Kiste gespeichert? Es ist die { 5 _1 }. </quiz>

<quiz display=simple> {Rust-Wissenstest 18: Platzhalter für Ausgaben |type="{}"} let name = "Fritz"; println!("Hallo, {}!", name); Die beiden Zeichen { {} _2 } sagen dem Programm, dass dort etwas eingefügt wird. </quiz>

<quiz display=simple> {Rust-Wissenstest 19: Das Ausrufezeichen bei Print |type="{}"} Ein "Makro" im Rust-Code wie "println" erkennt man immer sofort an einem speziellen Satzzeichen! Vor der runden Klammer steht immer ein { Ausrufezeichen _13 }. </quiz>

<quiz display=simple> {Rust-Wissenstest 20: Rechnen mit Plus |type="{}"} In Rust kann man rechnen wie auf dem Papier! let ergebnis = 5 { + _1 } 3; </quiz>

<quiz display=simple> {Rust-Wissenstest 21: Rechnen mit Mal |type="{}"} Und Malnehmen? let pfoten = 4 { * _1 } 2; // Dafür nimmt man ein Sternchen! </quiz>

<quiz display=simple> {Rust-Wissenstest 22: Boolean |type="{}"} Welcher Datentyp bist du? `false` ist vom Typ { Boolean _7 } </quiz>

<quiz display=simple> {Rust-Wissenstest 23: Integer |type="{}"} Welcher Datentyp bist du? `42` ist vom Typ { Integer _7 } (ganze Zahl) </quiz>

<quiz display=simple> {Rust-Wissenstest 24: String |type="{}"} Welcher Datentyp bist du? `"Hallo"` ist vom Typ { String _6 } (Text) </quiz>

<quiz display=simple> {Rust-Wissenstest 25: Char |type="{}"} Welcher Datentyp bist du? `'b'` ist vom Typ { Char _4 } (nur ein Zeichen) </quiz>

<quiz display=simple> {Rust-Wissenstest 26: Ist gleich Zeichen |type="{}"} Wenn ein "if" kontrolliert, ob zwei Zahlen GLEICH sind, benutzt er ein Doppel-Gleichzeichen: if runden { == _2 } 5 {

 println!("Fünf Runden um!");

} </quiz>

<quiz display=simple> {Rust-Wissenstest 27: For-Schleifen Zähler |type="{}"} for zahl in 1.. { 4 _1 } {

  println!("{}", zahl); // Zeigt 1, 2 und 3 an, aber nicht das Maximum!

} </quiz>

<quiz display=simple> {Rust-Wissenstest 28: Projektbasiertes Lernen |type="{}"} Wenn man durch ein eigenes kleines Projekt, etwa ein Mini-Spiel, am besten lernt, ist man im { projektbasierten _16 } Lernen. </quiz>

<quiz display=simple> {Rust-Wissenstest 29: Interleaving Ansatz |type="{}"} Man lernt besser, wenn man Themen durcheinander mischt. Diese Methode nennt man { Interleaving _12 } . </quiz>

<quiz display=simple> {Rust-Wissenstest 30: Bottom-Up Ansatz |type="{}"} Das schrittweise Aufbauen von einfachen zu komplexen Teilen (von unten nach oben) nennt man den { Bottom-Up _9 } Ansatz! </quiz>

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

Rust/Grundlagen: Unterschied zwischen den Versionen

Thorsten (Diskussion | Beiträge)

Version vom 3. März 2026, 21:34 Uhr

Inhaltsverzeichnis

Ziel: Verstehe die Bausteine von Rust!

Modul 1: Deine Werkstatt einrichten (Installation & Setup)

1. Installation: `rustup`, `rustc` und `cargo`

2. Dein erstes Programm: „Hello World!“

3. Dein Schreibtisch: IDE (z.B. VS Code) einrichten

Modul 2: Die ersten Bausteine (Grundlegende Syntax)

1. Kisten für Notizen: Variablen (`let`, `let mut`)

2. Verschiedene Dinge aufbewahren: Datentypen

3. Mini-Fabriken: Funktionen

Modul 3: Der Verkehrspolizist (Kontrollstrukturen)

1. Wenn dies, dann das: `if`, `else if`, `else`

2. Immer wieder: Schleifen (`loop`, `while`, `for`)

Praxis-Projekte: Werde zum Meister-Erfinder!

🧠 Großes Rust-Quiz 🧠

Navigationsmenü

@@ Zeile 3: / Zeile 3: @@
-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)!
+Hallo! Willkommen in der spannenden Welt von Rust! Stell dir vor, du bist ein Erfinder, und dein Computer ist eine riesige Werkstatt. Rust ist dein cooles, neues Werkzeug, mit dem du super schnelle und sichere Maschinen (also Programme!) bauen kannst.
-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!
+In diesem Lernpfad schauen wir uns an, wie du dieses Werkzeug benutzt. Wir machen viele kleine, spannende Projekte und mischen die Themen gut durch (das nennt man "Interleaving"), damit dein Gehirn immer wieder neu herausgefordert wird und du dir alles besser merken kannst! Wir fangen ganz unten bei den einfachen Dingen an und bauen darauf auf ("Bottom-Up").
-== Ziel: Basiskonzepte von Rust und der Werkzeugkasten (Toolchain) ==
+== Ziel: Verstehe die Bausteine von Rust! ==
+Wir werden lernen, wie Rust denkt und funktioniert. Am Ende kannst du deinem Computer Befehle geben und eigene kleine Programme schreiben!
-Bevor wir als Handwerker arbeiten können, brauchen wir unser Werkzeug! Bei Rust nennt man das die "Toolchain".
+== Modul 1: Deine Werkstatt einrichten (Installation & Setup) ==
+Bevor wir bauen können, müssen wir unsere Werkstatt vorbereiten!
-=== Lektion 1: Installation und Setup ===
+=== 1. Installation: `rustup`, `rustc` und `cargo` ===
+Um Rust zu sprechen, brauchen wir drei wichtige Helferlein:
+* '''`rustup`''': Das ist der Werkstatt-Manager. Er holt dir immer die neuesten Werkzeuge.
+* '''`rustc`''': Das ist der Übersetzer. Er übersetzt das, was du schreibst, in eine Sprache, die der Computer versteht (Maschinensprache).
+* '''`cargo`''': Das ist dein Roboter-Assistent! Er baut deine Programme zusammen, packt sie ein und hilft dir beim Aufräumen.
-'''rustup, rustc und cargo'''
+'''So geht's auf dem Computer:'''
-Stell dir vor, du bist der Chef in einer großen Werkstatt:
+Wenn du unter Linux oder macOS arbeitest, tippst du folgendes in ein schwarzes Fenster, das sich Terminal nennt:
-* '''rustup''' ist der Hausmeister, der dir immer die neuesten und besten Werkzeuge besorgt.
+<source lang="bash">
-* '''rustc''' ist der eigentliche Roboter oder Übersetzer, der unseren Rust-Code in die Sprache des Computers ("Nullen und Einsen") übersetzt.
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-* '''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!
+</source>
+Das sieht ein bisschen wie ein Zauberspruch aus, oder? Dieser Befehl holt die Helfer auf deinen Computer.
-'''So installierst du Rust:'''
+=== 2. Dein erstes Programm: „Hello World!“ ===
-Gehe auf die Webseite [https://rustup.rs rustup.rs] und folge den Anweisungen für deinen Computer.
+Lassen wir deinen Computer "Hallo Welt!" sagen! Rust freut sich nämlich, dich kennenzulernen.
+Öffne das Terminal und gib diesen Befehl ein (denk daran: Cargo ist dein Roboter-Assistent!):
-'''IDE-Setup (Dein Schreibtisch)'''
+<source lang="bash">
-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:
-<pre>
 cargo new hallo_welt
 cd hallo_welt
-cargo run
+</source>
-</pre>
-Was passiert hier genau?
+Wenn du jetzt eine Datei namens `main.rs` (in deinem neuen Ordner `src`) öffnest, solltest du diesen Code sehen:
-. `cargo new` legt einen neuen Projekt-Ordner für dich an ("Bauleiter cargo, bitte bereite einen Bauplatz vor!").
+<source lang="rust">
-. `cd` bedeutet "change directory" – du gehst in den Ordner hinein.
-. `cargo run` startet das Einsteiger-Programm!
-Wenn du in die Datei `src/main.rs` schaust, siehst du diesen Code:
-<syntaxhighlight lang="rust">
 fn main() {
      println!("Hello, world!");
 }
-</syntaxhighlight>
+</source>
+* `fn main()` bedeutet: "Hier fangen wir an!". `fn` steht für Funktion – das ist ein Block aus Befehlen.
+* `println!` bedeutet: "Drucke eine Zeile (print line) Text auf den Bildschirm". Das `!` zeigt, dass das ein besonderer Taschenspielertrick in Rust ist (man nennt das ein "Makro").
-* `fn main()` bedeutet: Hier fängt unser Programm an. `fn` steht für Funktion (ein Bauplan). Das `main()` ist das Haupttor in unser Programm.
+Tippe jetzt in dein Terminal:
-* `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.
+<source lang="bash">
-* `"Hello, world!"` ist der genaue Text, der auf dem Bildschirm erscheinen soll.
+cargo run
+</source>
+Und tada! Der Computer sagt "Hello, world!" zu dir!
----
+=== 3. Dein Schreibtisch: IDE (z.B. VS Code) einrichten ===
+Du kannst deinen Code nicht einfach auf einen Schmierzettel schreiben. Es gibt tolle Programme dafür. Ein beliebtes Programm heißt '''Visual Studio Code''' (kurz: VS Code). Das ist wie ein super schlaues Notizbuch.
+Wenn du VS Code installiert hast, lade dir die Erweiterung (ein kleines Extra-Werkzeug) namens '''"rust-analyzer"''' herunter. Er ist wie ein kluger Lehrer, der dir rote Striche zeigt, wenn du dich vertippst, und dir tolle Tipps gibt.
-=== Lektion 2: Grundlegende Syntax ===
+== Modul 2: Die ersten Bausteine (Grundlegende Syntax) ==
-Jetzt wo der Werkzeugkoffer bereit ist, lernen wir die ersten eigenen Wörter in Rust!
+=== 1. Kisten für Notizen: Variablen (`let`, `let mut`) ===
+Stell dir vor, du hast eine Kiste. In diese Kiste kannst du etwas reinlegen. Das nennt man in Rust eine "Variable".
+Um eine Kiste zu machen, sagen wir `let`:
+<source lang="rust">
+fn main() {
+    let alter = 10; // Wir erstellen eine Kiste "alter" und legen die 10 rein.
+    println!("Ich bin {} Jahre alt.", alter); // Die {} machen Platz für unsere Zahl!
+}
+</source>
-==== Variablen und Veränderbarkeit (Mutabilität) ====
+'''Achtung!''' In Rust sind Kisten normalerweise fest zugeklebt! Wenn du `let alter = 10;` machst, kannst du danach `alter` NICHT mehr auf 11 ändern.
+Wenn du eine Kiste haben willst, bei der du das, was drinnen ist, später austauschen darfst, musst du `mut` (wie mutabel oder veränderbar) dazu schreiben!
+<source lang="rust">
+fn main() {
+    let mut taschengeld = 5; // mut bedeutet: Ich darf den Wert ändern!
+    println!("Ich habe {} Euro.", taschengeld);
+    taschengeld = 10; // Jetzt habe ich mehr bekommen!
+    println!("Juhu, jetzt habe ich {} Euro!", taschengeld);
+}
+</source>
-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.
+=== 2. Verschiedene Dinge aufbewahren: Datentypen ===
-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!
+Es gibt nicht nur Zahlen! In deine Kisten passen verschiedene Dinge:
+* '''Ganze Zahlen (Integer)''': z.B. `10`, `42`, `-5`.
+* '''Kommazahlen (Float)''': z.B. `3.14` oder `2.5`.
+* '''Wahrheitswerte (Booleans)''': Das kann nur `true` (Wahr) oder `false` (Falsch) sein. Perfekt, um zu prüfen, ob das Licht an ist!
+* '''Buchstaben und Wörter (Char und String)''': Ein einzelner Buchstabe ist ein 'A', ein ganzer Text ist "Hallo!".
-<syntaxhighlight lang="rust">
+<source lang="rust">
 fn main() {
-     // let bedeutet: Hier ist eine neue Kiste.
+     let note = 1;               // Eine ganze Zahl
-     let alter = 10;
+    let gewicht = 35.5;         // Eine Kommazahl
-     // alter = 11; // 🛑 FEHLER! Diese Kiste ist verschlossen. Wir dürfen das "alter" nicht ändern.
+     let ist_es_tag = true;      // Boolean (Wahr)
+     let anfangsbuchstabe = 'T'; // Ein Zeichen in einfachen Anführungszeichen
+    let name = "Thorsten";      // Ein Text in doppelten Anführungszeichen
+}
+</source>
-    // let mut bedeutet: Hier ist eine neue Kiste, die sich ändern darf!
+Manchmal packt man auch Dinge zusammen!
-    let mut punkte = 0;
+* '''Tupel''': Ein Regalbrett mit festen Dingen, z.B. deine Lieblingsfarbe und deine Glückszahl. `let mein_tupel = ("Blau", 7);`
-    println!("Startpunkte: {}", punkte); // Die {} sind Platzhalter, dort wird unsere Zahl eingesetzt!
+* '''Array''': Eine Liste von mehreren Dingen, die aber alle vom gleichen Typ sein müssen. `let meine_noten = [1, 2, 1, 3];`
-    punkte = 5; // Yay! Wir haben 5 Punkte in einem Spiel gesammelt!
+=== 3. Mini-Fabriken: Funktionen ===
-     println!("Neue Punkte gesammelt! Jetzt sind es: {}", punkte);
+Wenn du denselben Code oft brauchst, kannst du ihn verpacken. Das ist eine Funktion. Die `main()`-Funktion kennst du schon!
+Lass uns eine Fabrik bauen, die immer "Guten Morgen" sagt und den Namen dazu:
+<source lang="rust">
+// Hier ist unsere neue Fabrik!
+fn sage_hallo(name: &str) {
+     println!("Guten Morgen, {}!", name);
 }
-</syntaxhighlight>
-==== Kommentare ====
+fn main() {
-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.
+    sage_hallo("Lukas"); // Wir rufen die Fabrik auf und geben ihr den Namen.
+    sage_hallo("Mia");
+}
+</source>
-==== Datentypen (Was kommt in die Kiste?) ====
+* '''Kommentare''': Manchmal möchtest du dir was notieren, das der Computer ignorieren soll. Mach einfach `//`. Alles danach in der Zeile ist für dich!
-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) ====
+== Modul 3: Der Verkehrspolizist (Kontrollstrukturen) ==
-Wir haben das Haupttor `fn main()` schon kennengelernt. Du kannst aber auch eigene Unter-Baupläne (Funktionen) erstellen!
+Ein Programm muss auch Entscheidungen treffen können!
-<syntaxhighlight lang="rust">
+=== 1. Wenn dies, dann das: `if`, `else if`, `else` ===
+Stell dir vor, du stehst vor einer Ampel.
+<source lang="rust">
 fn main() {
-     // Wir rufen unseren Unter-Bauplan auf und übergeben einen Namen:
+     let ampel = "Rot";
-     begruesse_spieler("Anna");
+    if ampel == "Grün" {
+        // Wenn Grün, dann gehen.
+        println!("Du darfst über die Straße gehen!");
+    } else if ampel == "Rot" {
+        // Oder wenn Rot, dann stehen bleiben.
+        println!("Halt! Warten!");
+     } else {
+        // Sonst (zum Beispiel wenn sie aus ist).
+        println!("Pass gut auf!");
+    }
 }
+</source>
+Das ist ein Wegweiser für dein Programm!
+Analyzed
+~/Übungen
+Thought for 118s
-// 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);
-}
-</syntaxhighlight>
----
-=== 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.
-<syntaxhighlight lang="rust">
+Edited
+thorsten.wiki
++448
+-0
+Thought for 2s
+=== 2. Immer wieder: Schleifen (`loop`, `while`, `for`) ===
+Manchmal möchtest du Dinge wiederholen, ohne sie tausendmal zu tippen.
+* Die Endlos-Schleife (`loop`): Das ist wie ein Hamsterrad, es dreht sich immer weiter, bis du "Stopp!" (`break`) rufst!
+<source lang="rust">
+fn main() {
+    let mut zähler = 0;
+    loop {
+        zähler = zähler + 1;
+        println!("Wir sind bei {}!", zähler);
+        if zähler == 3 {
+            println!("Genug gedreht!");
+            break; // Hier springen wir aus der Schleife raus
+        }
+    }
+}
+</source>
+* Solange etwas stimmt (`while`): Wiederhole etwas, ''solange'' eine Bedingung wahr ist.
+<source lang="rust">
 fn main() {
-     let alter = 10;
+     let mut kekse = 3;
+    while kekse > 0 {
+        println!("Ich esse einen Keks! Übrig sind: {}", kekse);
+        kekse = kekse - 1; // Ein Keks ist weg!
+    }
+    println!("Alle Kekse aufgegessen!");
+}
+</source>
-    if alter >= 18 {
+* Für jedes Stück (`for`): Perfekt, um eine Liste oder einen bestimmten Zeitraum durchzugehen.
-        println!("Du darfst ein echtes Auto fahren!");
+<source lang="rust">
-     } else if alter >= 10 {
+fn main() {
-        println!("Du darfst ein super cooles Fahrrad mit Gangschaltung fahren!");
+     // 1..4 bedeutet die Zahlen 1, 2 und 3 (die 4 ist nicht dabei!)
-     } else {
+     for zahl in 1..4 {
-         println!("Fahr lieber sicher mit dem Roller auf dem Hof!");
+         println!("Countdown: {}", zahl);
      }
+    println!("Los geht's!");
 }
-</syntaxhighlight>
+</source>
-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!
+== Praxis-Projekte: Werde zum Meister-Erfinder! ==
-* '''loop''': Läuft für immer und ewig im Kreis... bis du das magische Wort `break` sagst!
+Hier mischen wir alles (Interleaving!). Versuche, diese Projekte selber in VS Code zu schreiben!
-* '''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!)
-<syntaxhighlight lang="rust">
+'''Projekt 1: Der Taschengeld-Rechner'''
-fn main() {
+* Was es tun soll: Lege fest, wie viel Taschengeld du pro Monat bekommst (z.B. `let pro_monat = 20;`). Berechne dann, wie viel du in einem ganzen Jahr (12 Monate) bekommst! Gib das Ergebnis mit `println!` aus.
-    // Die FOR-Schleife: Zählt von 1 bis 3
-    println!("Achtung, Raketenstart in...");
+'''Projekt 2: Der Geheimtür-Wächter'''
-    for zahl in 1..4 { // Zählt 1, 2, 3 (die 4 am Ende gehört nicht mehr dazu!)
+* Was es tun soll: Lege ein Passwort fest `let geheimes_passwort = "Apfelsaft";`. Benutze dann eine `if`-Abfrage! Teste, ob jemand das richtige Passwort hat. Wenn ja, schreibe "Tür öffnet sich". Wenn nein, schreibe "Alarm!!!".
-        println!("{}...", zahl);
+'''Projekt 3: Der Raketen-Start! (Countdown)'''
+* Was es tun soll: Schreibe ein Programm, das von 10 herunterzählt bis 1! Nutze dafür am besten eine `while`-Schleife. Wenn es bei 0 ist, soll der Computer "Rakete startet! Wuuuuuuusch!" auf den Bildschirm schreiben.
+'''Projekt 4: Der Temperatur-Bewerter'''
+* Was es tun soll: Lege als Variable (Typ: ganze Zahl) das aktuelle Wetter in Grad Celsius fest. Wenn es über 25 Grad hat, schreibe "Lass uns Eis essen!". Unter 10 Grad "Zieh eine Jacke an!". Dazwischen "Perfektes Spielwetter!". Nutze dafür `if` und `else if`.
+'''Projekt 5: Einmaleins-Trainer (Bottom-Up Aufgabe)'''
+* Was es tun soll: Schreibe eine `for`-Schleife, die dir die 7er-Reihe aufschreibt: 7, 14, 21 ... bis 70.
+* Extra schwer: Schreib das so, dass du die Zahl, z.B. die 7, nur oben in eine Variable packst (`let reihe = 7;`).
+== 🧠 Großes Rust-Quiz 🧠 ==
+Teste jetzt dein neues Wissen aus dem Lernpfad!
+<quiz display=simple>
+{Rust-Wissenstest 1: Vervollständige die Lücken
+|type="{}"}
+Um einen veränderbaren Wert in Rust zu speichern, schreibst du nach "let" das Wort { mut _3 }.
+Damit der Computer deinen Text auf den Bildschirm malt, benutzt du { println! _8 }("Hallo!").
+Der Befehl in der Konsole, der ein neues Bauprojekt erstellt, fängt an mit { cargo _5 } new mein_projekt.
+Die Abkürzung für eine Funktion heisst { fn _2 } und die Hauptfunktion, in der dein Programm immer startet, nennt sich { main _4 }.
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 2: Datentypen und Variablen
+|type="{}"}
+Um eine Kommazahl wie 3.5 abzuspeichern, verwendet Rust den Typ { Float _5 } (Gleitkommazahl).
+Wahrheitswerte wie "true" und "false" nennt man auch { Booleans _8 }.
+Um eine Schleife zu bauen, die FÜR jede Zahl von 1 bis 10 durchläuft, nutzen wir das { for _3 }-Schlüsselwort.
+Mit einem doppelten { // _2 } sagst du Rust, dass du dir eine Notiz gemacht hast (Kommentar). Das Programm überspringt das einfach.
+Eine unendliche Schleife kannst du durch den Befehl { break _5 } beenden.
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 3: Vervollständige das Hallo-Welt Programm
+|type="{}"}
+fn { main _4 }() {
+    println!("Hello, { world _5 }!");
+}
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 4: Vervollständige die Variable
+|type="{}"}
+Um sicherzustellen, dass sich der Wert nicht ändert:
+{ let _3 } alter = 10;
+Um den Wert später noch ändern zu können:
+let { mut _3 } guthaben = 5;
+guthaben = 10;
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 5: Vervollständige die If-Abfrage
+|type="{}"}
+let hunger = true;
+{ if _2 } hunger == true {
+    println!("Lass uns Kuchen essen!");
+} { else _4 } {
+    println!("Ich bin satt!");
+}
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 6: Vervollständige die Loop-Schleife
+|type="{}"}
+let mut runden = 0;
+{ loop _4 } {
+    runden = runden + 1;
+    if runden == 3 {
+        { break _5 };
      }
-     println!("Zündung! 🚀");
+}
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 7: Vervollständige die For-Schleife
+|type="{}"}
+// Wir zählen von 1 bis 5 (ohne 6)
+{ for _3 } zahl in 1..6 {
+     println!("Zahl: {}", { zahl _4 });
+}
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 8: Funktionen
+|type="{}"}
+Vervollständige den Aufbau einer neuen Funktion, die "winken" heißt.
+{ fn _2 } winken() {
+    println!("*Winkt*");
+}
+Um die Funktion auszuführen, schreibst du in der main() einfach { winken(); _9 }
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 9: Toolchain
+|type="{}"}
+Das Programm, das deinen Rust-Code "übersetzt", heißt { rustc _5 } .
+Das Programm, von dem man seine Bibliothek an Tools bekommt, also den Installer, nennt man { rustup _6 } .
+Ein "cargo { run _3 }" startet in der Konsole das fertig gebaute Programm.
+</quiz>
-    // Die WHILE-Schleife (Mit Veränderbarkeit gemischt - "Interleaving"!):
+<quiz display=simple>
-    let mut energie = 3;
+{Rust-Wissenstest 10: Array und Tupel
-    while energie > 0 {
+|type="{}"}
-        println!("Roboter stapft herum... Energie bei {}", energie);
+Sollen verschiedene Werte, wie eine Note von der Schule (Zahl) und dein Name (Wort) eng zusammen stehen, verpackst du sie am geschicktesten in ein { Tupel _5 }.
-        energie = energie - 1; // Energie wird pro Schritt weniger!
+Möchtest du eine Liste von lauter gleichen Dingen, zum Beispiel fünf T-Shirts speichern, benutzt du am besten ein { Array _5 }.
-     }
+</quiz>
-     println!("Dem Roboter fehlt Energie. Er schläft jetzt ein. 💤");
+<quiz display=simple>
+{Rust-Wissenstest 11: While-Schleife
+|type="{}"}
+let mut wasser = 5;
+{ while _5 } wasser > 0 {
+    println!("Schluck trinken!");
+    wasser = wasser - 1;
+}
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 12: Fehler finden
+|type="{}"}
+Warum funktioniert der folgende Code nicht?
+let hund = "Bello";
+hund = "Wuffi";
+Weil vor "hund" in der ersten Zeile das Wort { mut _3 } fehlt!
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 13: IDE und Editor
+|type="{}"}
+Die intelligente Hilfe für VS Code, die Fehler beim Tippen direkt unterstreicht und das Leben eines Rust-Programmierers extrem vereinfacht, heißt rust-{ analyzer _8 } .
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 14: Konsolen-Befehl
+|type="{}"}
+Wenn ich ein neues Projekt machen möchte, das "Spiel" heisst, welche beiden Wörter schreibe ich am Anfang in meiner Konsole?
+{ cargo new _9 } Spiel
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 15: If-Else-If
+|type="{}"}
+let alter = 10;
+if alter < 6 {
+    println!("Kindergarten");
+} else { if _2 } alter < 11 {
+     println!("Grundschule");
+} else {
+     println!("Weiterführende Schule");
 }
-</syntaxhighlight>
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 16: Code-Block Klammern
+|type="{}"}
+Eine Funktion braucht für ihren Code immer diese runden, gebogenen Klammern.
+Das sind { geschweifte _11 } Klammern. Auf der Tastatur tippt man "{" und "}".
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 17: Variablen überschreiben
+|type="{}"}
+let mut kekse = 2;
+kekse = 5;
+Welche Zahl ist nun in der Kiste gespeichert? Es ist die { 5 _1 }.
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 18: Platzhalter für Ausgaben
+|type="{}"}
+let name = "Fritz";
+println!("Hallo, {}!", name);
+Die beiden Zeichen { {} _2 } sagen dem Programm, dass dort etwas eingefügt wird.
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 19: Das Ausrufezeichen bei Print
+|type="{}"}
+Ein "Makro" im Rust-Code wie "println" erkennt man immer sofort an einem speziellen Satzzeichen!
+Vor der runden Klammer steht immer ein { Ausrufezeichen _13 }.
+</quiz>
+<quiz display=simple>
+{Rust-Wissenstest 20: Rechnen mit Plus
+|type="{}"}
+In Rust kann man rechnen wie auf dem Papier!
+let ergebnis = 5 { + _1 } 3;
+</quiz>
----
+<quiz display=simple>
+{Rust-Wissenstest 21: Rechnen mit Mal
+|type="{}"}
+Und Malnehmen?
+let pfoten = 4 { * _1 } 2; // Dafür nimmt man ein Sternchen!
+</quiz>
-== Projekte & Übungen ==
+<quiz display=simple>
+{Rust-Wissenstest 22: Boolean
+|type="{}"}
+Welcher Datentyp bist du?
+`false` ist vom Typ { Boolean _7 }
+</quiz>
-Durch eigene, praxisnahe Mini-Projekte lernst du am besten! Hier darfst du selbst kreativ werden.
+<quiz display=simple>
+{Rust-Wissenstest 23: Integer
+|type="{}"}
+Welcher Datentyp bist du?
+`42` ist vom Typ { Integer _7 } (ganze Zahl)
+</quiz>
-=== Projekt Vorschlag 1: Der kluge Zahlen-Magier (Variablen & If) ===
+<quiz display=simple>
-'''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;`).
+{Rust-Wissenstest 24: String
-* Der Zahlen-Magier soll die beiden Zahlen zusammen addieren (+) und in einer neuen, veränderlichen Variablen speichern.
+|type="{}"}
-* 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!".
+Welcher Datentyp bist du?
-'''Tipp:''' Verbinde hier Datentypen (Zahlen) mit Entweder/Oder-Entscheidungen (`if` / `else`)!
+`"Hallo"` ist vom Typ { String _6 } (Text)
+</quiz>
-=== Projekt Vorschlag 2: Das tickende Sicherheitssystem (While & Mutabilität) ===
+<quiz display=simple>
-'''Deine Aufgabe:''' Simuliere ein einfaches Sicherheitssystem.
+{Rust-Wissenstest 25: Char
-* Erstelle eine veränderliche Variable `let mut versuche = 3;`.
+|type="{}"}
-* Benutze eine `while`-Schleife, die nur solange läuft, wie `versuche > 0` ist.
+Welcher Datentyp bist du?
-* In der Schleife sagst du: `"Falsches Passwort! Noch {} Versuche übrig."` und reduzierst die Variable sofort um eins (`versuche = versuche - 1`).
+`'b'` ist vom Typ { Char _4 } (nur ein Zeichen)
-* Nach der Schleife (wenn alles durchgelaufen ist) gibst du aus: `"Sicherheitssystem gesperrt! Alarm!"`
+</quiz>
-=== Projekt Vorschlag 3: Der nervige Papageien-Helfer (Funktionen & For-Schleifen) ===
+<quiz display=simple>
-'''Deine Aufgabe:''' Erstelle eine eigene Funktion `fn papagei(text: &str, anzahl: i32)`.
+{Rust-Wissenstest 26: Ist gleich Zeichen
-* In dieser Funktion nutzt du eine `for`-Schleife, um den `text` genauso oft zu wiederholen (`anzahl`), wie die Zahl groß ist!
+|type="{}"}
-* Rufe diese neue Funktion dann ganz oben in deiner `fn main()` auf, zum Beispiel so: `papagei("Polly will einen Keks!", 5)`.
+Wenn ein "if" kontrolliert, ob zwei Zahlen GLEICH sind, benutzt er ein Doppel-Gleichzeichen:
-'''Tipp:''' Hier bauen wir ganz klassisch von den Schleifen und Variablen auf (Bottom-Up) bis hin zur eigenen Funktion, in die man Werte hineinreicht!
+if runden { == _2 } 5 {
+  println!("Fünf Runden um!");
+}
+</quiz>
----
+<quiz display=simple>
+{Rust-Wissenstest 27: For-Schleifen Zähler
+|type="{}"}
+for zahl in 1.. { 4 _1 } {
+   println!("{}", zahl); // Zeigt 1, 2 und 3 an, aber nicht das Maximum!
+}
+</quiz>
-== Quiz (Teste dein Wissen) ==
+<quiz display=simple>
-<quiz>
+{Rust-Wissenstest 28: Projektbasiertes Lernen
-Lass uns überprüfen, was in deinem Kopf hängengeblieben ist! Fülle die Lücken aus.
+|type="{}"}
+Wenn man durch ein eigenes kleines Projekt, etwa ein Mini-Spiel, am besten lernt, ist man im { projektbasierten _16 } Lernen.
+</quiz>
-{Complete the text from the Rust Basics Lesson.
+<quiz display=simple>
+{Rust-Wissenstest 29: Interleaving Ansatz
 |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.
+Man lernt besser, wenn man Themen durcheinander mischt. Diese Methode nennt man { Interleaving _12 } .
+</quiz>
-{Complete the text about Rust Control Structures.
+<quiz display=simple>
+{Rust-Wissenstest 30: Bottom-Up Ansatz
 |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.
+Das schrittweise Aufbauen von einfachen zu komplexen Teilen (von unten nach oben) nennt man den { Bottom-Up _9 } Ansatz!
 </quiz>
 ----
 ''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''

Rust/Grundlagen: Unterschied zwischen den Versionen

Thorsten (Diskussion | Beiträge)

Version vom 3. März 2026, 21:34 Uhr

Ziel: Verstehe die Bausteine von Rust!

Modul 1: Deine Werkstatt einrichten (Installation & Setup)

1. Installation: `rustup`, `rustc` und `cargo`

2. Dein erstes Programm: „Hello World!“

3. Dein Schreibtisch: IDE (z.B. VS Code) einrichten

Modul 2: Die ersten Bausteine (Grundlegende Syntax)

1. Kisten für Notizen: Variablen (`let`, `let mut`)

2. Verschiedene Dinge aufbewahren: Datentypen

3. Mini-Fabriken: Funktionen

Modul 3: Der Verkehrspolizist (Kontrollstrukturen)

1. Wenn dies, dann das: `if`, `else if`, `else`

2. Immer wieder: Schleifen (`loop`, `while`, `for`)

Praxis-Projekte: Werde zum Meister-Erfinder!

🧠 Großes Rust-Quiz 🧠

Navigationsmenü

Suche