Rust/Grundlagen: Unterschied zwischen den Versionen

Aus Dokument
Zur Navigation springen Zur Suche springen
← Zum vorherigen Versionsunterschied

Thorsten (Diskussion | Beiträge)

3 Benutzergruppen
69 Bearbeitungen
VisuellWikitext
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
 
(4 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 2: Zeile 2:
----
----


Willkommen beim coolsten Programmier-Abenteuer überhaupt! Hast du dich schon mal gefragt, wie Videospiele, Apps oder Roboter funktionieren? Sie alle sprechen eine geheime Sprache: Code! Und wir lernen jetzt zusammen eine der schnellsten und sichersten Sprachen der Welt: '''Rust'''. Keine Sorge, es ist ganz einfach. Wenn du mit Lego bauen kannst, kannst du auch mit Rust programmieren!
Willkommen zu deinem Rust-Abenteuer! Rust ist eine superschnelle und sichere Programmiersprache. Stell dir vor, du hast einen magischen Werkzeugkasten, mit dem du alles bauen kannst, was du dir ausdenkst – von kleinen Spielen bis hin zu riesigen Welten. Lass uns anfangen!


Unsere Mission in den ersten zwei Wochen: Wir lernen die Werkzeuge kennen und schreiben unsere allerersten magischen Zeilen Code.
== 1. Installation und Einrichtung ==
=== Lernziele ===
* Du weißt, was `rustup`, `rustc` und `cargo` sind.
* Du kannst Rust auf deinem Computer installieren.
* Du kannst dein allererstes Programm (ein "Hello World!") schreiben und ausführen.


== 1. Installation und Setup — Packen wir unseren Werkzeugkasten! ==
=== Lektion ===
Um Rust nutzen zu können, brauchen wir unser Werkzeug:
* '''rustup''': Das ist dein Installations-Roboter. Er holt dir die neueste Version von Rust.
* '''rustc''': Der Übersetzer (Compiler). Er liest deinen Code und verwandelt ihn in ein Programm, das der Computer versteht.
* '''cargo''': Dein treuer Helfer und Paketmanager. Cargo erstellt neue Projekte, lädt Erweiterungen herunter und baut dein Programm zusammen.


Bevor ein Handwerker ein Baumhaus bauen kann, braucht er Hammer und Säge. Genauso brauchen wir als Entwickler unsere eigenen Werkzeuge.
'''So installierst du Rust:'''
Gehe auf [https://rustup.rs rustup.rs] und kopiere den Befehl dort in dein Terminal (oder deine Kommandozeile). Drücke Enter, und der Roboter fängt an zu arbeiten!


=== Installation von `rustup`, `rustc` und `cargo` ===
'''Dein erstes Programm: "Hello World!"'''
Um Rust auf deinem Computer zu benutzen, brauchen wir einen magischen Installateur namens '''rustup'''.
Lass uns Cargo benutzen, um ein neues Projekt zu starten:
* '''rustup''': Das ist der Helfer, der Rust auf deinen Computer holt.
<source lang="bash">
* '''rustc''': Das ist der Übersetzer (Compiler). Er übersetzt unseren für uns lesbaren Code in eine Sprache, die der Computer (Einsen und Nullen) versteht.
* '''cargo''': Das ist dein persönlicher Butler! Er baut deine Programme, holt dir neue Bausteine (Bibliotheken) und hilft dir beim Starten.
 
'''So geht's:'''
Gehe auf die Webseite [https://rustup.rs/ rustup.rs] und befolge die Anweisungen für deinen Computer (Windows, Mac oder Linux). Meistens musst du nur einen kleinen Befehl kopieren und ausführen.
 
=== Das „Hello World!“-Programm ===
Das ist Tradition unter Programmierern: Das allererste Programm, das man schreibt, sagt immer "Hallo Welt". Lass uns das bauen!
 
Öffne dein Terminal (die Kommandozeile) und tippe ein, um Cargo zu bitten, ein neues Projekt zu machen:
<syntaxhighlight lang="bash">
cargo new hallo_welt
cargo new hallo_welt
cd hallo_welt
cd hallo_welt
cargo run
cargo run
</syntaxhighlight>
</source>
Cargo hat gerade eine Datei namens `main.rs` im Ordner `src` für dich erstellt und ausgeführt. Auf dem Bildschirm sollte nun "Hello, world!" stehen. Toll gemacht!


Boom! Da steht „Hello, world!“ auf dem Bildschirm. Du hast gerade dein erstes Programm ausgeführt! 🥳
=== Übungen ===
# Installiere Rust auf deinem Computer.
# Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
# Führe das Projekt mit `cargo run` aus.


=== Einrichtung der IDE (VS Code) ===
== 2. IDE-Einrichtung (Dein digitaler Schreibtisch) ==
Eine IDE ist dein Schreibtisch zum Programmieren. Wir empfehlen '''Visual Studio Code''' (VS Code).
=== Lernziele ===
# Lade dir VS Code aus dem Internet herunter.
* Du lernst, wie du "Visual Studio Code" (VS Code) einrichtest.
# Öffne es und suche links nach "Erweiterungen" (Extensions) – das sind so kleine Bauklötze-Symbole.
* Du installierst die Erweiterung "rust-analyzer", die dir beim Coden hilft.
# Suche nach '''rust-analyzer''' und installiere es. Das ist dein magischer Assistent, der dir Fehler anzeigt und dir hilft, Code schneller zu schreiben!


== 2. Grundlegende Syntax — Die ersten Legosteine ==
=== Lektion ===
Programmieren in einem einfachen Texteditor ist wie Malen ohne Pinsel. Wir benutzen '''Visual Studio Code (VS Code)'''. Das ist unser digitaler Schreibtisch.
# Lade dir "VS Code" aus dem Internet herunter und installiere es.
# Öffne VS Code und klicke links auf die kleinen Quadrate (das sind die Erweiterungen).
# Suche nach '''rust-analyzer''' und klicke auf "Installieren".
Dieser kleine Spickzettel zeigt dir Fehler an, bevor sie passieren und hilft dir mit cleveren Vorschlägen!


Jetzt schauen wir uns an, woraus so ein Programm eigentlich besteht.
=== Übungen ===
# Installiere VS Code.
# Installiere "rust-analyzer".
# Öffne dein Projekt "hallo_welt" in VS Code und schau, wie schön bunt der Code jetzt ist!


=== Variablen und Veränderbarkeit (`let`, `let mut`) ===
== 3. Grundlegende Syntax ==
Eine Variable ist wie eine Kiste, auf die du einen Namen schreibst und etwas hineinlegst.
=== Lernziele ===
* Du verstehst, wie man Werte in '''Variablen''' speichert.
* Du lernst den Unterschied zwischen statischen (`let`) und veränderbaren (`let mut`) Dingen.
* Du lernst Zahlen, Texte und mehrypen kennen.
* Du weißt, wie man eigene '''Funktionen''' schreibt und '''Kommentare''' hinterlässt.


<syntaxhighlight lang="rust">
=== Lektion: Variablen und Mutabilität ===
Stell dir eine Variable wie eine Kiste vor, in die du etwas hineinlegst.
<source lang="rust">
fn main() {
fn main() {
     let alter = 10; // Eine Kiste namens "alter" mit der Zahl 10 drin.
     let name = "Thorsten"; // Das ist eine unveränderliche Kiste!
     println!("Ich bin {} Jahre alt.", alter);
    // name = "Peter"; // Das würde einen Fehler geben, der Name ist fest.
   
    let mut alter = 10; // "mut" steht für "mutable" (veränderbar).
    alter = 11; // Jetzt hat er Geburtstag gehabt!
   
     println!("Hallo {}, du bist {} Jahre alt.", name, alter);
}
}
</syntaxhighlight>
</source>


'''Achtung, Falle!''' In Rust sind Kisten normalerweise verschlossen (unveränderbar, in Englisch: ''immutable''). Wenn du den Inhalt der Kiste später ändern willst, musst du das magische Wort '''mut''' (für mutabel/veränderbar) benutzen!
=== Lektion: Datentypen ===
Es gibt einfache Typen (Skalartypen) und zusammengesetzte Typen (Verbundtypen).
* '''Zahlen (Integer):''' Ganze Zahlen wie `5` oder `100` (`i32`, `u32`).
* '''Kommazahlen (Float):''' Zahlen wie `3.14` (`f64`).
* '''Wahrheitswerte (Boolean):''' `true` (richtig) oder `false` (falsch) (`bool`).
* '''Zeichen (Char):''' Ein einzelner Buchstabe oder Smiley wie `'A'` oder `'😊'` (`char`).


<syntaxhighlight lang="rust">
Verbundtypen:
fn main() {
* '''Tupel:''' Eine Kiste mit unterschiedlichen Dingen.
    let mut taschengeld = 5; // mut bedeutet: Wir dürfen die Kiste öffnen!
* '''Arrays:''' Eine Kiste mit vielen gleichen Dingen.
    taschengeld = 10; // Jetzt hast du mehr Taschengeld!
<source lang="rust">
    println!("Ich habe {} Euro.", taschengeld);
let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
}
let mein_array: [i32; 3] = [1, 2, 3];
</syntaxhighlight>
</source>


=== Datentypen — Was passt in die Kiste? ===
=== Lektion: Funktionen und Kommentare ===
Der Computer muss wissen, WAS in der Kiste ist. Eine Zahl? Ein Buchstabe? Ein ganzes Wort?
Funktionen sind wie Rezepte. Du beschreibst einmal, wie etwas gemacht wird, und kannst es immer wieder aufrufen. Kommentare (`// ...`) sind kleine Notizen für dich oder andere, der Computer ignoriert sie völlig.
* '''Integer (Zahlen ohne Komma):''' `let alter = 10;`
<source lang="rust">
* '''Float (Zahlen mit Komma - wichtig: Im Englischen nimmt man den Punkt!):''' `let groesse = 1.45;`
// Das ist eine Funktion, die "Hallo" sagt
* '''Booleans (Ja oder Nein / Wahr oder Falsch):''' `let mag_eis = true;`
fn sag_hallo() {
* '''Strings (Wörter und Sätze):''' `let name = "Thorsten";`
     println!("Hallo von der Funktion!");
 
=== Funktionen und Kommentare ===
'''Kommentare''' (`//`) sind Notizen für dich! Der Computer liest sie nicht mit. Sie sind wie kleine Post-its in deinem Code.
 
'''Funktionen''' sind wie kleine Maschinen. Du gibst ihnen einen Namen und was sie tun sollen, und dann kannst du sie immer wieder anwerfen. Unser Programm startet immer in der `main` Funktion.
 
<syntaxhighlight lang="rust">
// Das ist eine Funktion, die "Wuff" sagt.
fn hund_bellen() {
     println!("Wuff! Wuff!");
}
}


fn main() {
fn main() {
     hund_bellen(); // Hier rufen wir die Maschine auf!
     sag_hallo(); // Hier rufen wir unser Rezept auf!
}
}
</syntaxhighlight>
</source>


== 3. Kontrollstrukturen — Wer bestimmt hier den Weg? ==
=== Übungen ===
# Erstelle ein Programm, in dem du eine veränderbare Variable `punktestand` anlegst, sie um 10 erhöhst und dann ausgibst.
# Schreibe eine Funktion `lieblingsessen`, die dein Lieblingsessen als Text auf dem Bildschirm ausdruckt.


Manchmal soll ein Programm Entscheidungen treffen. Wenn es regnet, nimm den Regenschirm. Wenn die Sonne scheint, nimm die Sonnenbrille.
== 4. Kontrollstrukturen ==
=== Lernziele ===
* Bringe dem Programm bei, Entscheidungen zu treffen (`if`, `else`).
* Wiederhole Dinge automatisch mithilfe von '''Schleifen''' (`loop`, `while`, `for`).


=== Bedingungen (`if`, `else if`, `else`) ===
=== Lektion: Wenn-Dann (if / else if / else) ===
Mit `if` (wenn) und `else` (sonst) können wir dem Computer sagen, was er bei Entscheidungen tun soll.
Dein Programm soll schlau sein!
 
<source lang="rust">
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let schoko_eis = true;
     let wetter = "Regen";


     if schoko_eis {
     if wetter == "Regen" {
         println!("Oh lecker, Schokoeis!"); // Das wird gemacht, wenn schoko_eis "true" (wahr) ist.
         println!("Nimm einen Regenschirm mit!");
    } else if wetter == "Schnee" {
        println!("Zieh warme Stiefel an!");
     } else {
     } else {
         println!("Ein anderes Eis ist auch okay."); // Das wird gemacht, wenn es nicht wahr ist.
         println!("Zieh ein T-Shirt an!");
     }
     }
}
}
</syntaxhighlight>
</source>


=== Schleifen (`loop`, `while`, `for`) — Immer wieder dasselbe! ===
=== Lektion: Schleifen (Wiederholungen) ===
Wenn du 10-mal "Hallo" sagen willst, musst du das nicht 10-mal hinschreiben. Dafür gibt es Schleifen!
Computer sind toll darin, Dinge sehr oft zu tun, ohne sich zu langweilen.
* '''`loop`''': Macht etwas für immer, bis du mit `break` (abbrechen) Stopp sagst.
* '''loop''': Läuft für immer (bis du `break` sagst).
* '''`while`''': Macht etwas, *solange* eine Bedingung wahr ist (z.B. solange du noch Bonbons hast).
* '''while''': Läuft solange eine Bedingung wahr ist.
* '''`for`''': Zählt automatisch mit!
* '''for''': Zählt eine bestimmte Anzahl durch.


<syntaxhighlight lang="rust">
<source lang="rust">
fn main() {
fn main() {
     // Zählt von 1 bis 5
     // for-Schleife (zählt von 1 bis 3)
     for zahl in 1..6 {
     for zahl in 1..4 {
         println!("Zahl ist: {}", zahl);
         println!("Ich zähle: {}", zahl);
     }
     }
}
}
</syntaxhighlight>
</source>
 
=== Übungen ===
# Schreibe ein Programm, das mit `if` prüft, ob eine Zahl größer als 10 ist und dann eine Nachricht ausgibt.
# Nutze eine `for`-Schleife, um die Zahlen von 1 bis 5 auszudrucken.
 


---
== Projektbasiertes Lernen ==


== Praxisbezogenes Lernen: 50 Magische Mini-Projekte ==
=== 75 Mini-Projekte für den schnellen Praxisbezug ===
Programmieren lernt man durchs Selbermachen! Hier sind 50 kleine Aufgaben für dich zum Üben. Setz die neuen Legosteine zusammen!
Diese Mini-Projekte sind super kurz und fokussiert, damit du schnell Erfolgserlebnisse hast. Sie behandeln Variablen, Funktionen, Schleifen und If-Abfragen.


<ol>
#Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
<li>'''Hallo-Welt-Roboter:''' Verändere dein Programm, sodass es "Hallo Meister!" sagt.</li>
#Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
<li>'''Namensschild-Drucker:''' Erstelle eine Variable mit deinem Namen und gib aus: "Mein Name ist [Name]".</li>
#Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
<li>'''Alter in Tagen:''' Multipliziere dein Alter mit 365, um herauszufinden, wie viele Tage du lebst (Tipp: `*` ist malnehmen).</li>
#Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
<li>'''Lieblingsfarben-Zeiger:''' Drei Variablen mit Farben anlegen und kreativ auf dem Bildschirm ausdrucken.</li>
#Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
<li>'''Einfacher Plus-Taschenrechner:''' Addiere Variablen `a = 10` und `b = 15`.</li>
#Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
<li>'''Minus-Taschenrechner:''' Ziehe zwei Zahlen voneinander ab.</li>
#Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
<li>'''Mal-Maschine:''' Multipliziere drei Variablen.</li>
#Einfacher Taschenrechner (Multiplikation): Eine Funktion, die zwei i32-Zahlen multipliziert.
<li>'''Teilen-Trainer:''' Teile dein Taschengeld (als Float) durch 2 (Tipp: `/`).</li>
#Einfacher Taschenrechner (Division): Eine Funktion, die zwei i32-Zahlen dividiert.
<li>'''Satz-Zusammensetzer:''' Drucke mehrere Wörter aus Variablen in einem Satz.</li>
#Gerade oder Ungerade?: Prüfe mit if/else und % 2, ob eine Zahl gerade ist.
<li>'''Mein erster Kommentar:''' Schreibe einen Code und beschreibe ihn in 3 Kommentarzeilen.</li>
#Notenbewerter: Gib zu einer Zahl von 1-6 ein Textfeedback aus.
<li>'''Taschengeld-Update:''' Mache eine `mut` Variable, gib ihr 5 Euro, dann überschreibe sie mit 20 Euro. Drucke beides!</li>
#Schleifen-Zähler: Nutze eine for-Schleife, um von 1 bis 10 zu zählen.
<li>'''Level-Up:''' Ein `mut` Level in einem Spiel, zähle 1 Level hoch (`level = level + 1`).</li>
#Raketen-Countdown: Nutze eine for-Schleife (10..1), gefolgt von 'Ignition!'.
<li>'''Stimmungs-Bool:''' `let bin_froh = true;`. Drucke es aus.</li>
#Passwort-Prüfer: Ein if/else Check eines String-Passwortes gegen ein festes 'geheim123'.
<li>'''Eis-Prüfer:''' if-Abfrage: Wenn `bin_froh == true`, dann print "Yay!".</li>
#Tage-in-Monat-Rechner: Ordne einem Monatsnamen (als String) die Anzahl der Tage per if/else zu.
<li>'''Türsteher (Achterbahn):''' Erstelle `let groesse = 140;`. Wenn `groesse > 130`, dann "Darf fahren!", `else` "Leider noch zu klein."</li>
#Schachtel-Verschachteler: Nutze ein if/else in einem if/else (Nested If).
<li>'''Passwort-Labyrinth:''' `let code = 1234;`. Prüfe, ob `code == 1234` ist.</li>
#FizzBuzz Mini: Iteriere von 1 bis 20 und ersetze durch fizz/buzz.
<li>'''Ampel-Simulator:''' `let farbe = "Rot";`. `if` Rot -> "Stopp", `else if` Grün -> "Los!".</li>
#Die unendliche Schleife mit Ausweg: Ein loop {}, der bei counter == 5 mit break beendet wird.
<li>'''Wetter-Prophet:''' Bestimme mit if-else, was du anziehst (Regen vs. Sonne).</li>
#while-Schleifen-Zähler: Das Gleiche wie Projekt 12, aber mit while.
<li>'''Schulnoten-Bewerter:''' Prüfe Noten 1 bis 6 und gib dazu passenden Text wie "Super!" oder "Oje." aus.</li>
#Array-Lesezeichen: Lege ein Array mit 5 Buchtiteln an und drucke das dritte Buch.
<li>'''Lieblingstier:''' Wenn Tier == "Hund", bellen, bei "Katze" miauen.</li>
#Tuple-Lieblinge: Erstelle ein Tupel (Farbe, Zahl, Essen) und greife auf die Zahl zu.
<li>'''Endlos-Bohrer:''' Nutze `loop { println!("Bohren..."); }` (Bohre endlos - breche mit Strg+C ab!).</li>
#Funktions-Grüßer: Übergib einen Namen als Argument an eine Funktion, die hallo sagt.
<li>'''Zahlenschloss-Knacker:''' Zähle in einem `loop` eine `mut`-Variable hoch und stoppe bei 10 mit `break`.</li>
#Mutabilitäts-Test: Lege variable X an, ändere sie danach dreimal und gib sie nach jeder Änderung aus.
<li>'''Raketen-Countdown:''' Mit einer `while`-Schleife von 10 herunterzählen, dann "Liftoff!".</li>
#Schleifen-Summe: Addiere die Zahlen von 1 bis 100 in einer Schleife.
<li>'''Stammgast-Prüfer:''' `while hungrig == true`, iss einen Keks (simuliert).</li>
#Der kleine Papagei: Eine Funktion, der du einen Text übergibst und die ihn 3x nacheinander ausdruckt.
<li>'''Papagei-Programm:''' Sag 5 Mal "Hallo" in einer `for`-Schleife.</li>
#Schaltjahr-Prüfer: if/else, um zu checken, ob Variable 'jahr' ein Schaltjahr ist.
<li>'''Das Einmaleins:''' Zähle von 1..11 und multipliziere den Zähler mit 2 (2er Reihe).</li>
#Tier-Laute: Funktion, die einen Tiernamen nimmt und das passende Geräusch (Miauen, Bellen) printet.
<li>'''Zehner-Sprünge:''' Eine for-Schleife, die 10, 20, 30 ausgibt (Tipp: Multiplizieren).</li>
#Einkaufslisten-Array: Lege 5 Dinge an und printe jedes Element mit einer for-Schleife aus.
<li>'''Glückszahl-Finder:''' Finde in einer Schleife deine Glückszahl und schreibe "GEFUNDEN!" (mit if und break).</li>
#Schatten-Ninja (Shadowing): Überschreibe eine let-Variable neu (let my_var = 1; let my_var = 'zwei').
<li>'''Ungerade Zahlen:''' Drucke nur ungerade Zahlen mit `if zahl % 2 != 0`.</li>
#Wochentag-Anzeige: Speichere 1-7 in einer Variable und gib den passenden Wochentag aus.
<li>'''Erste eigene Funktion:''' Mach eine Funktion `sag_tschuess()`.</li>
#Zahlen-Rater-Mock: 'if geraten_zahl == zielzeug' check (ohne echten Input).
<li>'''Tierstimmen-Funktionen:''' Mach drei Funktionen: `hund()`, `katze()`, `kuh()`. Rufe alle in main auf.</li>
#Zeichenzähler in Schleife: Printe ein '*' 1x, 2x, 3x mithilfe von String::repeat().
<li>'''Quadratmaschine (Funktion):''' Mach eine Variablen-Rechnung in einer separaten Funktion.</li>
#Wetter-Bot: Array von Wetter-Zuständen, das zufällig ausgegeben wird.
<li>'''Wochentag-Anzeiger:''' Wenn Zahl = 1, dann Montag, usw.</li>
#Das vergessene Semikolon: Erzeuge absichtlich einen Compiler-Fehler, fix ihn.
<li>'''Guten-Morgen-Schleife:''' Sage einer Liste von 3 Leuten (mit drei prints in der Schleife) Guten Morgen.</li>
#Einrückungs-Korrektur: Nimm unformatierten Code und schiebe ihn durch 'cargo fmt'.
<li>'''Hundejahre-Umrechner:''' Multipliziere dein Alter mit 7.</li>
#Das Typ-Experiment: Erzwinge verschiedene Typen für x (f32, f64, i8, i16).
<li>'''Kilometer-in-Meter:''' Rechne 5 km in Meter (mal 1000) um.</li>
#Kino-Alterskontrolle: if/else ab 12, 16 oder 18 Jahren.
<li>'''Pizza-Teiler:''' Wenn ich 8 Stücke habe und wir 3 Kinder sind, wie viel bleibt übrig? (Modulo `%`).</li>
#Umfangrechner Skript: Länge und Breite berechnen Umfang.
<li>'''Spardosen-Checker:''' if Taschengeld > Spiele-Preis? "Du kannst es kaufen!"</li>
#Flächenrechner: Länge mal Breite.
<li>'''Begrüßungs-Türsteher:''' Nutze `let name = "Dein Name";`. Wenn es dein Name ist, begrüße freundlich, sonst grimmig.</li>
#ASCII-Kunst: Nutze println! für kleine ASCII-Bilder (Hund, Haus).
<li>'''Ping-Pong-Zähler:''' Eine `for`-Schleife. Bei geraden Zahlen "Ping", bei ungeraden "Pong".</li>
#Fahrkarten-Automat: Wenn genug Geld (Variable) da ist -> Ticket drucken, sonst Fehlbetrag nennen.
<li>'''Wecker-Klingeln:''' Eine for-Schleife 1..4 mit "Klingeling!".</li>
#Vokabel-Tupel: (Deutsch, Englisch) in Variablen und geordnet ausgeben.
<li>'''Lebenspunkte-Trank:''' `mut hp = 50;` -> `hp = hp + 20;` Wenn > 100, setze auf 100.</li>
#Mittelwert-Berechner: Array von 3 Zahlen nehmen und Mittelwert (Addition / 3) errechnen.
<li>'''Geschwindigkeits-Blitzer:''' Schneller als 50 km/h? -> "Geknipst!".</li>
#Gefahren-Ampel: Rot, Gelb, Grün -> Ausgaben wie Stop, Warnung, Go.
<li>'''Magisches Viereck:''' Berechne den Flächeninhalt (Seite mal Seite).</li>
#while_let Anfänge (Optional): Optionale Option<i32> ausprobieren.
<li>'''Würfel-Simulation (Manuell):''' Variablen für 3 Würfe. Zähle sie zusammen.</li>
#Rustup-Check-Skript: Nutze std::process::Command (oder print!), um zu zeigen, dass du verstanden hast, was rustc --version ausgibt.
<li>'''Die Geheim-Naricht:''' Drucke Buchstaben einzeln aus.</li>
#Die Cargo.toml betrachten: Füge im Kommentarfeld die Erklärung des Cargo Manifests ein.
<li>'''Bug-Fixer:''' Schreibe ein Programm, vergiss absichtlich ein Semikolon `;` und schau, wie nett der Cargo Compiler dir hilft!</li>
#Konstanten-Macht: Deklariere eine const MWST: f64 = 0.19; und rechne damit.
<li>'''Der Zornige Chef:''' Eine Funktion `schreien()`, die alles großschreibt (simuliert über println).</li>
#Kleines Textadventure (Raumbeschreibung): Nutze Funktionen für 3 Räume.
<li>'''Kaffeemaschine:''' `let wasser_da = true; let kaffee_da = false;` if beides true -> "Kaffee machen", sonst Fehler.</li>
#Würfelspiel-Simulation (ohne Random): Fest programmierte Würfel-Ergebnisse addieren.
<li>'''Tagebuch-Einleitung:''' Nutze Variablen für Datum und Wetter und schreibe die Startzeile deines Tagebuchs.</li>
#Würfelspiel-Anzeige: Array von [1,2,3,4,5,6] -> durchlaufen.
</ol>
#Kommentar-Kunstwerk: Ein Programm, wo jeder Schritt absolut überdokumentiert ist (zum Lernen!).
#Rostige Strings: Unterscheide &str und String::from() bei ein, zwei Zuweisungen.
#Namens-Kombinator: Vorname und Nachname (Strings) zusammenfügen.
#Rabatt-Rechner: Wenn Preis > 100, ziehe 10% ab.
#Dreiecks-Prüfer: Sind die Winkel zusammen 180 Grad?
#Zahlen-Muster: Drucke 1, 22, 333, 4444.
#Gedichte-Formatierer: Verwende \n für Zeilenumbrüche in einem Print.
#Cargo check - Speed: Mach einen Syntax-Fehler, nutze cargo check statt run.
#Zufalls_Platzhalter: Setze Kommentare 'TODO: Hier später random' in Code.
#Bmi-Rechner: Gewicht / (Größe*Größe).
#Geschwindigkeitsanzeige: km/h in mp/h umrechnen.
#E-Mail-Mockup-Macher: setze 'An', 'Von', 'Betreff' aus Variablen zusammen.
#Ressourcen-Planer: Array aus ['Holz', 'Stein', 'Gold'].
#Inventar-Liste (Tupel-Array): Menge und Name kombinieren.
#Beste-Freunde-Sucher: In einem Array schauen, ob Name x dabei ist.
#Kleiner Roboter-Timer: Nutze thread::sleep, um zu warten (optional).
#Schleifen-Continue: Zähle auf 10, bei 5 sagst du 'continue'.
#Schleifen-Break: Endet, wenn eine bestimmte Taste/Zahl erreicht ist.
#Verdeckte Variablen: Rufe dieselbe Funktion 5x auf.
#Tagebuch-Drucker: Printe Datum + Text-Variable.
#Rust-Maskottchen: Drucke Infos zu 'Ferris' der Krabbe.
#Versions-Checker: Gibt 1.0.0 als Variable an.
#Hello-World-Multi: Hello World in 5 Sprachen über If-Else.
#Debug-Print: Nutze {:?} statt {} bei Arrays.


=== 20 Große Projekte (Top-Down-Lernen) ===
Bei diesen Projekten startest du mit der großen Vision (Top-Down) und nutzt dein neues Wissen aus den Modulen, um das Projekt nach und nach funktionsfähig zu machen.


== Strukturierung ins Top-Down-Lernen: 10 Große Projekte ==
#Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife ('Wie möchtest du gehen?').
Du willst mehr? Hier kommen die epischen Herausforderungen! Diese großen Projekte fordern all dein Wissen und setzen mehrere kleine Lego-Konzepte zusammen. Nimm dir Zeit!
#Taschenrechner mit Kommandozeile: Ein echtes Terminal-Tool, um Zahlen zu berechnen.
#Zahlenraten-Simulator: Ein komplexeres Rate-Spiel mit Feedback (wärmer, kälter) in einer Loop.
#Todo-Listen-Verwaltung (im Speicher): Ein Array mutabel halten und Aufgaben abhaken (ohne echten User-Input).
#Persönliches Haushaltsbuch (Mockup): Ein- und Ausgaben aus Arrays zusammenrechnen und bewerten.
#Schere, Stein, Papier - Automat: Zwei voreingestellte oder simulierte Spieler treten gegeneinander an.
#Vokabel-Trainer: Tupel abfragen, Zähler für richtige und falsche Antworten.
#Der Quiz-Master: 5 Fragen hintereinander via Terminal Output, mit Punkteauswertung.
#ASCII-Tamagotchi: Ein kleines Haustier, das Hunger-/Durst-/Müdigkeits-Variablen in einer Loop verändert.
#Wetterstation-Simulator: Durchschnittsberechnung aus großen Arrays von simulierten Temperaturdaten.
#Morsen-Übersetzer: Nutze if/else oder Arrays, um Buchstaben in Morsecode (Text) zu verwandeln.
#Ein einfacher Passwort-Generator (Mockup): Strings aus verschiedenen Zeichen zusammenfügen.
#Bankkonto-Simulation: Funktionen für einzahlen(), abheben() und kontostand().
#Pizzabestellung-System: Wähle Größe, Belag aus und berechne den Preis am Ende.
#Schatzsuche auf dem Raster: Ein 2D-Array als Spielfeld (Karte), laufe mit Koordinaten x,y.
#Lottozahlen-Checker: Gleiche eine Liste deiner getippten Zahlen mit einer simulierten Ziehung ab.
#Krimi-Dateien: Verwalte Verdächtige mit ihren Alibis und filtere über Schleifen.
#Zeiterfassungs-Helfer: Erfasse Stunden für fiktive Projekte und rechne Lohn aus.
#Das Geometrie-Genie: Ein Tool, das für jede abgefahrene Flächenform (Kreis, Zylinder) das Volumen als Sub-Funktionen nutzt.
#Das Cargo-Meisterwerk: Dein Abschlussprojekt – Erstelle mehrere Module (Dateien) in Cargo für ein mini RPG-Spiel.


=== 1. Das "Magische Zahlenraten" Simulator ===
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
* '''Was du baust:''' Ein Programm, das so tut, als hätte es eine Geheimzahl (z.B. 42). Du erstellst eine Variable mit einer "geratenen" Zahl. Mit `if`, `else if` und `else` sagst du dem Benutzer: "Zu hoch!", "Zu niedrig!" oder "Treffer!".
* Installation und Einrichtung:
  * `rustup`, `rustc` und `cargo`.
  * Ein „Hello World!“-Programm.
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
* Grundlegende Syntax:
  * Variablen und Mutabilität (`let`, `let mut`).
  * Datentypen (Skalar- und Verbundtypen).
  * Funktionen und Kommentare.
* Kontrollstrukturen:
  * `if`, `else if`, `else`.
  * Schleifen (`loop`, `while`, `for`).


=== 2. Text-Adventure: "Die Suche nach dem verlorenen Keks" ===
Erkläre alle Inhalte leicht verständlich für Programmieranfänger.
* '''Was du baust:''' Ein interaktives Geschichten-Spiel. Nutze Variablen wie `let hat_schluessel = true;`. Schreibe `if`-Abfragen: Wenn du am Drachen vorbei willst und keinen Schlüssel hast -> Spielende. Wenn du den Schlüssel hast -> Du kommst zum Raum mit dem Keks! Nutze eigene Funktionen für verschiedene "Räume" (z.B. `fn drachenhöhle()`).


=== 3. Virtuelles Alien-Tamagotchi ===
* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
* '''Was du baust:''' Deine `mut`-Variablen heißen `hunger` und `muedigkeit`. Mit einer `loop`-Schleife vergeht simuliert die Zeit (der Hunger steigt). Wenn Hunger > 10, stirbt das Tamagotchi (break). Du simulierst "Füttern", indem du den Hunger-Wert mit if-Abfragen zwischendurch reduzierst.
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.


=== 4. Der Taschengeld-Manager 3000 ===
* '''Was du baust:''' Eine Schleife (`while` oder `for`), in der du "Ausgaben" simulierst. Du startest mit 50 Euro. Du kaufst (durch Code) ein Eis (-2€), ein Spiel (-30€). Der Manager druckt immer den neuen Kontostand. Gehst du unter 0, warnt er "Du bist pleite!" und stoppt die Schleife.


=== 5. Der Geheimcode-Generator (Verschlüsselung) ===
Ausgabe und Speicherung:
* '''Was du baust:''' Das Programm nimmt feste Wörter. Es zerlegt das Problem in Funktionen, z.B. eine Funktion, die "Hallo" rückwärts ausgibt oder bestimmte Buchstaben wie das 'a' gegen ein 'x' tauscht (durch mehrere `if`-Abfragen).
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
* Das Ausgabeformat ist die MediaWiki-Syntax.


=== 6. Quiz-Master Console ===
==Prompt==
* '''Was du baust:''' Ein Frage-und-Antwort-Spiel. Du hast 3 Fragen. Wenn die simulierte Antwort des Spielers richtig ist, gibt es einen Punkt (`mut punkte = punkte + 1`). Am Ende der Funktion sagt dir das Programm mit `if`, ob du Gold, Silber oder Bronze gewonnen hast.
<pre>


=== 7. ASCII-Art Raketenbauer ===
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
* '''Was du baust:''' Male komplexe Gebilde mithilfe von Code! Nutze `for`-Schleifen, um Pyramidenmustern aus Sternchen (`*`) oder eine riesige Rakete aufs Terminal zu malen. Hier trainierst du Schleifen-Logik par excellence.
* Installation und Einrichtung:
  * `rustup`, `rustc` und `cargo`.
  * Ein „Hello World!“-Programm.
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
* Grundlegende Syntax:
  * Variablen und Mutabilität (`let`, `let mut`).
  * Datentypen (Skalar- und Verbundtypen).
  * Funktionen und Kommentare.
* Kontrollstrukturen:
  * `if`, `else if`, `else`.
  * Schleifen (`loop`, `while`, `for`).


=== 8. Schere, Stein, Papier (Simuliert) ===
Erkläre alle Inhalte leicht verständlich für Programmieranfänger.
* '''Was du baust:''' Variablen für Spieler 1 und Spieler 2 stellen "Schere", "Stein" oder "Papier" dar. Konstruiere tief verschachtelte `if / else if`-Bedingungen, um zu ermitteln, wer das Match gewonnen hat.  


=== 9. Der kleine Vokabeltrainer ===
* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
* '''Was du baust:''' Mache drei Funktionen: `lerne_englisch()`, `lerne_spanisch()`, `lerne_chinesisch()`. Baue einen Kontroll-Fluss (if-else), um je nach gewählter Sprache (Zahl 1, 2 oder 3) in die richtige Funktion zu springen, wo Vokabeln geprintet werden.
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.


=== 10. Ampel-Steuerung für eine Mega-City ===
* '''Was du baust:''' Eine `while`-Schleife läuft 10 mal (simuliert 10 Tage). Jede Ampel (es gibt Fußgänger und Autos) ist eine Variable. Die Schleifen wechseln die Farben. Wenn Autofarbe = Grün, MUSS Fußgänger = Rot sein, sonst löst du im Terminal einen "Crash-Alarm!" (println) aus.


Viel Erfolg! Am Ende dieser zwei Wochen wirst du schon wie ein richtiger Programmierer denken. Bleib dran, mach Fehler und hab Spaß dabei!
Ausgabe und Speicherung:
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
* Das Ausgabeformat ist die MediaWiki-Syntax.
</pre>


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

Aktuelle Version vom 4. März 2026, 04:35 Uhr

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

Willkommen zu deinem Rust-Abenteuer! Rust ist eine superschnelle und sichere Programmiersprache. Stell dir vor, du hast einen magischen Werkzeugkasten, mit dem du alles bauen kannst, was du dir ausdenkst – von kleinen Spielen bis hin zu riesigen Welten. Lass uns anfangen!

1. Installation und Einrichtung

Lernziele

  • Du weißt, was `rustup`, `rustc` und `cargo` sind.
  • Du kannst Rust auf deinem Computer installieren.
  • Du kannst dein allererstes Programm (ein "Hello World!") schreiben und ausführen.

Lektion

Um Rust nutzen zu können, brauchen wir unser Werkzeug:

  • rustup: Das ist dein Installations-Roboter. Er holt dir die neueste Version von Rust.
  • rustc: Der Übersetzer (Compiler). Er liest deinen Code und verwandelt ihn in ein Programm, das der Computer versteht.
  • cargo: Dein treuer Helfer und Paketmanager. Cargo erstellt neue Projekte, lädt Erweiterungen herunter und baut dein Programm zusammen.

So installierst du Rust: Gehe auf rustup.rs und kopiere den Befehl dort in dein Terminal (oder deine Kommandozeile). Drücke Enter, und der Roboter fängt an zu arbeiten!

Dein erstes Programm: "Hello World!" Lass uns Cargo benutzen, um ein neues Projekt zu starten: 

cargo new hallo_welt
cd hallo_welt
cargo run

Cargo hat gerade eine Datei namens `main.rs` im Ordner `src` für dich erstellt und ausgeführt. Auf dem Bildschirm sollte nun "Hello, world!" stehen. Toll gemacht!

Übungen

  1. Installiere Rust auf deinem Computer.
  2. Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
  3. Führe das Projekt mit `cargo run` aus.

2. IDE-Einrichtung (Dein digitaler Schreibtisch)

Lernziele

  • Du lernst, wie du "Visual Studio Code" (VS Code) einrichtest.
  • Du installierst die Erweiterung "rust-analyzer", die dir beim Coden hilft.

Lektion

Programmieren in einem einfachen Texteditor ist wie Malen ohne Pinsel. Wir benutzen Visual Studio Code (VS Code). Das ist unser digitaler Schreibtisch.

  1. Lade dir "VS Code" aus dem Internet herunter und installiere es.
  2. Öffne VS Code und klicke links auf die kleinen Quadrate (das sind die Erweiterungen).
  3. Suche nach rust-analyzer und klicke auf "Installieren".

Dieser kleine Spickzettel zeigt dir Fehler an, bevor sie passieren und hilft dir mit cleveren Vorschlägen!

Übungen

  1. Installiere VS Code.
  2. Installiere "rust-analyzer".
  3. Öffne dein Projekt "hallo_welt" in VS Code und schau, wie schön bunt der Code jetzt ist!

3. Grundlegende Syntax

Lernziele

  • Du verstehst, wie man Werte in Variablen speichert.
  • Du lernst den Unterschied zwischen statischen (`let`) und veränderbaren (`let mut`) Dingen.
  • Du lernst Zahlen, Texte und mehrypen kennen.
  • Du weißt, wie man eigene Funktionen schreibt und Kommentare hinterlässt.

Lektion: Variablen und Mutabilität

Stell dir eine Variable wie eine Kiste vor, in die du etwas hineinlegst. 

fn main() {
    let name = "Thorsten"; // Das ist eine unveränderliche Kiste!
    // name = "Peter"; // Das würde einen Fehler geben, der Name ist fest.
    
    let mut alter = 10; // "mut" steht für "mutable" (veränderbar).
    alter = 11; // Jetzt hat er Geburtstag gehabt!
    
    println!("Hallo {}, du bist {} Jahre alt.", name, alter);
}

Lektion: Datentypen

Es gibt einfache Typen (Skalartypen) und zusammengesetzte Typen (Verbundtypen).

  • Zahlen (Integer): Ganze Zahlen wie `5` oder `100` (`i32`, `u32`).
  • Kommazahlen (Float): Zahlen wie `3.14` (`f64`).
  • Wahrheitswerte (Boolean): `true` (richtig) oder `false` (falsch) (`bool`).
  • Zeichen (Char): Ein einzelner Buchstabe oder Smiley wie `'A'` oder `'😊'` (`char`).

Verbundtypen:

  • Tupel: Eine Kiste mit unterschiedlichen Dingen.
  • Arrays: Eine Kiste mit vielen gleichen Dingen.
let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
let mein_array: [i32; 3] = [1, 2, 3];

Lektion: Funktionen und Kommentare

Funktionen sind wie Rezepte. Du beschreibst einmal, wie etwas gemacht wird, und kannst es immer wieder aufrufen. Kommentare (`// ...`) sind kleine Notizen für dich oder andere, der Computer ignoriert sie völlig. 

// Das ist eine Funktion, die "Hallo" sagt
fn sag_hallo() {
    println!("Hallo von der Funktion!");
}

fn main() {
    sag_hallo(); // Hier rufen wir unser Rezept auf!
}

Übungen

  1. Erstelle ein Programm, in dem du eine veränderbare Variable `punktestand` anlegst, sie um 10 erhöhst und dann ausgibst.
  2. Schreibe eine Funktion `lieblingsessen`, die dein Lieblingsessen als Text auf dem Bildschirm ausdruckt.

4. Kontrollstrukturen

Lernziele

  • Bringe dem Programm bei, Entscheidungen zu treffen (`if`, `else`).
  • Wiederhole Dinge automatisch mithilfe von Schleifen (`loop`, `while`, `for`).

Lektion: Wenn-Dann (if / else if / else)

Dein Programm soll schlau sein! 

fn main() {
    let wetter = "Regen";

    if wetter == "Regen" {
        println!("Nimm einen Regenschirm mit!");
    } else if wetter == "Schnee" {
        println!("Zieh warme Stiefel an!");
    } else {
        println!("Zieh ein T-Shirt an!");
    }
}

Lektion: Schleifen (Wiederholungen)

Computer sind toll darin, Dinge sehr oft zu tun, ohne sich zu langweilen.

  • loop: Läuft für immer (bis du `break` sagst).
  • while: Läuft solange eine Bedingung wahr ist.
  • for: Zählt eine bestimmte Anzahl durch.
fn main() {
    // for-Schleife (zählt von 1 bis 3)
    for zahl in 1..4 {
        println!("Ich zähle: {}", zahl);
    }
}

Übungen

  1. Schreibe ein Programm, das mit `if` prüft, ob eine Zahl größer als 10 ist und dann eine Nachricht ausgibt.
  2. Nutze eine `for`-Schleife, um die Zahlen von 1 bis 5 auszudrucken.


Projektbasiertes Lernen

75 Mini-Projekte für den schnellen Praxisbezug

Diese Mini-Projekte sind super kurz und fokussiert, damit du schnell Erfolgserlebnisse hast. Sie behandeln Variablen, Funktionen, Schleifen und If-Abfragen.

  1. Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
  2. Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
  3. Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
  4. Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
  5. Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
  6. Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
  7. Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
  8. Einfacher Taschenrechner (Multiplikation): Eine Funktion, die zwei i32-Zahlen multipliziert.
  9. Einfacher Taschenrechner (Division): Eine Funktion, die zwei i32-Zahlen dividiert.
  10. Gerade oder Ungerade?: Prüfe mit if/else und % 2, ob eine Zahl gerade ist.
  11. Notenbewerter: Gib zu einer Zahl von 1-6 ein Textfeedback aus.
  12. Schleifen-Zähler: Nutze eine for-Schleife, um von 1 bis 10 zu zählen.
  13. Raketen-Countdown: Nutze eine for-Schleife (10..1), gefolgt von 'Ignition!'.
  14. Passwort-Prüfer: Ein if/else Check eines String-Passwortes gegen ein festes 'geheim123'.
  15. Tage-in-Monat-Rechner: Ordne einem Monatsnamen (als String) die Anzahl der Tage per if/else zu.
  16. Schachtel-Verschachteler: Nutze ein if/else in einem if/else (Nested If).
  17. FizzBuzz Mini: Iteriere von 1 bis 20 und ersetze durch fizz/buzz.
  18. Die unendliche Schleife mit Ausweg: Ein loop {}, der bei counter == 5 mit break beendet wird.
  19. while-Schleifen-Zähler: Das Gleiche wie Projekt 12, aber mit while.
  20. Array-Lesezeichen: Lege ein Array mit 5 Buchtiteln an und drucke das dritte Buch.
  21. Tuple-Lieblinge: Erstelle ein Tupel (Farbe, Zahl, Essen) und greife auf die Zahl zu.
  22. Funktions-Grüßer: Übergib einen Namen als Argument an eine Funktion, die hallo sagt.
  23. Mutabilitäts-Test: Lege variable X an, ändere sie danach dreimal und gib sie nach jeder Änderung aus.
  24. Schleifen-Summe: Addiere die Zahlen von 1 bis 100 in einer Schleife.
  25. Der kleine Papagei: Eine Funktion, der du einen Text übergibst und die ihn 3x nacheinander ausdruckt.
  26. Schaltjahr-Prüfer: if/else, um zu checken, ob Variable 'jahr' ein Schaltjahr ist.
  27. Tier-Laute: Funktion, die einen Tiernamen nimmt und das passende Geräusch (Miauen, Bellen) printet.
  28. Einkaufslisten-Array: Lege 5 Dinge an und printe jedes Element mit einer for-Schleife aus.
  29. Schatten-Ninja (Shadowing): Überschreibe eine let-Variable neu (let my_var = 1; let my_var = 'zwei').
  30. Wochentag-Anzeige: Speichere 1-7 in einer Variable und gib den passenden Wochentag aus.
  31. Zahlen-Rater-Mock: 'if geraten_zahl == zielzeug' check (ohne echten Input).
  32. Zeichenzähler in Schleife: Printe ein '*' 1x, 2x, 3x mithilfe von String::repeat().
  33. Wetter-Bot: Array von Wetter-Zuständen, das zufällig ausgegeben wird.
  34. Das vergessene Semikolon: Erzeuge absichtlich einen Compiler-Fehler, fix ihn.
  35. Einrückungs-Korrektur: Nimm unformatierten Code und schiebe ihn durch 'cargo fmt'.
  36. Das Typ-Experiment: Erzwinge verschiedene Typen für x (f32, f64, i8, i16).
  37. Kino-Alterskontrolle: if/else ab 12, 16 oder 18 Jahren.
  38. Umfangrechner Skript: Länge und Breite berechnen Umfang.
  39. Flächenrechner: Länge mal Breite.
  40. ASCII-Kunst: Nutze println! für kleine ASCII-Bilder (Hund, Haus).
  41. Fahrkarten-Automat: Wenn genug Geld (Variable) da ist -> Ticket drucken, sonst Fehlbetrag nennen.
  42. Vokabel-Tupel: (Deutsch, Englisch) in Variablen und geordnet ausgeben.
  43. Mittelwert-Berechner: Array von 3 Zahlen nehmen und Mittelwert (Addition / 3) errechnen.
  44. Gefahren-Ampel: Rot, Gelb, Grün -> Ausgaben wie Stop, Warnung, Go.
  45. while_let Anfänge (Optional): Optionale Option<i32> ausprobieren.
  46. Rustup-Check-Skript: Nutze std::process::Command (oder print!), um zu zeigen, dass du verstanden hast, was rustc --version ausgibt.
  47. Die Cargo.toml betrachten: Füge im Kommentarfeld die Erklärung des Cargo Manifests ein.
  48. Konstanten-Macht: Deklariere eine const MWST: f64 = 0.19; und rechne damit.
  49. Kleines Textadventure (Raumbeschreibung): Nutze Funktionen für 3 Räume.
  50. Würfelspiel-Simulation (ohne Random): Fest programmierte Würfel-Ergebnisse addieren.
  51. Würfelspiel-Anzeige: Array von [1,2,3,4,5,6] -> durchlaufen.
  52. Kommentar-Kunstwerk: Ein Programm, wo jeder Schritt absolut überdokumentiert ist (zum Lernen!).
  53. Rostige Strings: Unterscheide &str und String::from() bei ein, zwei Zuweisungen.
  54. Namens-Kombinator: Vorname und Nachname (Strings) zusammenfügen.
  55. Rabatt-Rechner: Wenn Preis > 100, ziehe 10% ab.
  56. Dreiecks-Prüfer: Sind die Winkel zusammen 180 Grad?
  57. Zahlen-Muster: Drucke 1, 22, 333, 4444.
  58. Gedichte-Formatierer: Verwende \n für Zeilenumbrüche in einem Print.
  59. Cargo check - Speed: Mach einen Syntax-Fehler, nutze cargo check statt run.
  60. Zufalls_Platzhalter: Setze Kommentare 'TODO: Hier später random' in Code.
  61. Bmi-Rechner: Gewicht / (Größe*Größe).
  62. Geschwindigkeitsanzeige: km/h in mp/h umrechnen.
  63. E-Mail-Mockup-Macher: setze 'An', 'Von', 'Betreff' aus Variablen zusammen.
  64. Ressourcen-Planer: Array aus ['Holz', 'Stein', 'Gold'].
  65. Inventar-Liste (Tupel-Array): Menge und Name kombinieren.
  66. Beste-Freunde-Sucher: In einem Array schauen, ob Name x dabei ist.
  67. Kleiner Roboter-Timer: Nutze thread::sleep, um zu warten (optional).
  68. Schleifen-Continue: Zähle auf 10, bei 5 sagst du 'continue'.
  69. Schleifen-Break: Endet, wenn eine bestimmte Taste/Zahl erreicht ist.
  70. Verdeckte Variablen: Rufe dieselbe Funktion 5x auf.
  71. Tagebuch-Drucker: Printe Datum + Text-Variable.
  72. Rust-Maskottchen: Drucke Infos zu 'Ferris' der Krabbe.
  73. Versions-Checker: Gibt 1.0.0 als Variable an.
  74. Hello-World-Multi: Hello World in 5 Sprachen über If-Else.
  75. Debug-Print: Nutze {:?} statt {} bei Arrays.

20 Große Projekte (Top-Down-Lernen)

Bei diesen Projekten startest du mit der großen Vision (Top-Down) und nutzt dein neues Wissen aus den Modulen, um das Projekt nach und nach funktionsfähig zu machen.

  1. Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife ('Wie möchtest du gehen?').
  2. Taschenrechner mit Kommandozeile: Ein echtes Terminal-Tool, um Zahlen zu berechnen.
  3. Zahlenraten-Simulator: Ein komplexeres Rate-Spiel mit Feedback (wärmer, kälter) in einer Loop.
  4. Todo-Listen-Verwaltung (im Speicher): Ein Array mutabel halten und Aufgaben abhaken (ohne echten User-Input).
  5. Persönliches Haushaltsbuch (Mockup): Ein- und Ausgaben aus Arrays zusammenrechnen und bewerten.
  6. Schere, Stein, Papier - Automat: Zwei voreingestellte oder simulierte Spieler treten gegeneinander an.
  7. Vokabel-Trainer: Tupel abfragen, Zähler für richtige und falsche Antworten.
  8. Der Quiz-Master: 5 Fragen hintereinander via Terminal Output, mit Punkteauswertung.
  9. ASCII-Tamagotchi: Ein kleines Haustier, das Hunger-/Durst-/Müdigkeits-Variablen in einer Loop verändert.
  10. Wetterstation-Simulator: Durchschnittsberechnung aus großen Arrays von simulierten Temperaturdaten.
  11. Morsen-Übersetzer: Nutze if/else oder Arrays, um Buchstaben in Morsecode (Text) zu verwandeln.
  12. Ein einfacher Passwort-Generator (Mockup): Strings aus verschiedenen Zeichen zusammenfügen.
  13. Bankkonto-Simulation: Funktionen für einzahlen(), abheben() und kontostand().
  14. Pizzabestellung-System: Wähle Größe, Belag aus und berechne den Preis am Ende.
  15. Schatzsuche auf dem Raster: Ein 2D-Array als Spielfeld (Karte), laufe mit Koordinaten x,y.
  16. Lottozahlen-Checker: Gleiche eine Liste deiner getippten Zahlen mit einer simulierten Ziehung ab.
  17. Krimi-Dateien: Verwalte Verdächtige mit ihren Alibis und filtere über Schleifen.
  18. Zeiterfassungs-Helfer: Erfasse Stunden für fiktive Projekte und rechne Lohn aus.
  19. Das Geometrie-Genie: Ein Tool, das für jede abgefahrene Flächenform (Kreis, Zylinder) das Volumen als Sub-Funktionen nutzt.
  20. Das Cargo-Meisterwerk: Dein Abschlussprojekt – Erstelle mehrere Module (Dateien) in Cargo für ein mini RPG-Spiel.

Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:

  • Installation und Einrichtung:
 * `rustup`, `rustc` und `cargo`.
 * Ein „Hello World!“-Programm.
  • IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
  • Grundlegende Syntax:
 * Variablen und Mutabilität (`let`, `let mut`).
 * Datentypen (Skalar- und Verbundtypen).
 * Funktionen und Kommentare.
  • Kontrollstrukturen:
 * `if`, `else if`, `else`.
 * Schleifen (`loop`, `while`, `for`).

Erkläre alle Inhalte leicht verständlich für Programmieranfänger.

  • Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
  • Top-Down-Lernen: 20 große Projekte zu diesen Themen.
  • Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.


Ausgabe und Speicherung:

  • Das Ergebnis soll auf thorsten.wiki gespeichert werden.
  • Das Ausgabeformat ist die MediaWiki-Syntax.

Prompt


Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
* Installation und Einrichtung:
  * `rustup`, `rustc` und `cargo`.
  * Ein „Hello World!“-Programm.
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
* Grundlegende Syntax:
  * Variablen und Mutabilität (`let`, `let mut`).
  * Datentypen (Skalar- und Verbundtypen).
  * Funktionen und Kommentare.
* Kontrollstrukturen:
  * `if`, `else if`, `else`.
  * Schleifen (`loop`, `while`, `for`).

Erkläre alle Inhalte leicht verständlich für Programmieranfänger.

* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.


Ausgabe und Speicherung:
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
* Das Ausgabeformat ist die MediaWiki-Syntax.

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

Abgerufen von „https://mediawiki.wissen-ahrensburg.de/index.php?title=Rust/Grundlagen&oldid=3289“