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 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).