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
 
(9 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 2: Zeile 2:
----
----


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!


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


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!
=== Lektion ===
 
Um Rust nutzen zu können, brauchen wir unser Werkzeug:
== Ziel: Basiskonzepte von Rust und der Werkzeugkasten (Toolchain) ==
* '''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.
Bevor wir als Handwerker arbeiten können, brauchen wir unser Werkzeug! Bei Rust nennt man das die "Toolchain".
* '''cargo''': Dein treuer Helfer und Paketmanager. Cargo erstellt neue Projekte, lädt Erweiterungen herunter und baut dein Programm zusammen.  
 
=== Lektion 1: Installation und Setup ===
 
'''rustup, rustc und cargo'''
Stell dir vor, du bist der Chef in einer großen Werkstatt:
* '''rustup''' ist der Hausmeister, der dir immer die neuesten und besten Werkzeuge besorgt.
* '''rustc''' ist der eigentliche Roboter oder Übersetzer, der unseren Rust-Code in die Sprache des Computers ("Nullen und Einsen") übersetzt.
* '''cargo''' ist dein fleißiger Helfer und Projektmanager. Er besorgt dir neue Bauteile, baut dein Programm zusammen und startet es. Wir werden fast immer mit `cargo` arbeiten!


'''So installierst du Rust:'''
'''So installierst du Rust:'''
Gehe auf die Webseite [https://rustup.rs rustup.rs] und folge den Anweisungen für deinen Computer.
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!
 
'''IDE-Setup (Dein Schreibtisch)'''
Du brauchst einen guten Texteditor ("IDE"), um deinen Code zu schreiben. Am besten nutzt du '''Visual Studio Code''' (VS Code).  
* Installiere VS Code.
* Installiere die Erweiterung '''rust-analyzer'''. Diese Erweiterung ist wie dein persönlicher, unsichtbarer Programmierlehrer, der dir beim Tippen hilft, Fehler sofort rot anstreicht und dir tolle Tipps gibt!
 
==== Projekt: Dein erstes "Hello World!"-Programm ====


Wir bitten den Computer, uns "Hallo Welt!" zu sagen.
'''Dein erstes Programm: "Hello World!"'''
Öffne dein Terminal (die schwarze Kommandozeile) und tippe:
Lass uns Cargo benutzen, um ein neues Projekt zu starten:
<pre>
<source lang="bash">
cargo new hallo_welt
cargo new hallo_welt
cd hallo_welt
cd hallo_welt
cargo run
cargo run
</pre>
</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!
Was passiert hier genau?
1. `cargo new` legt einen neuen Projekt-Ordner für dich an ("Bauleiter cargo, bitte bereite einen Bauplatz vor!").
2. `cd` bedeutet "change directory" – du gehst in den Ordner hinein.
3. `cargo run` startet das Einsteiger-Programm!
 
Wenn du in die Datei `src/main.rs` schaust, siehst du diesen Code:
<syntaxhighlight lang="rust">
fn main() {
    println!("Hello, world!");
}
</syntaxhighlight>
 
* `fn main()` bedeutet: Hier fängt unser Programm an. `fn` steht für Funktion (ein Bauplan). Das `main()` ist das Haupttor in unser Programm.
* `println!` bedeutet "print line": Drucke eine Zeile auf den Bildschirm. Das Ausrufezeichen `!` bedeutet, dass es sich um ein "Makro" handelt. Ein Makro ist ein Spezialwerkzeug in Rust, das für uns sehr viel unsichtbare Arbeit übernimmt.
* `"Hello, world!"` ist der genaue Text, der auf dem Bildschirm erscheinen soll.


---
=== Übungen ===
# Installiere Rust auf deinem Computer.
# Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
# Führe das Projekt mit `cargo run` aus.


=== Lektion 2: Grundlegende Syntax ===
== 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.


Jetzt wo der Werkzeugkoffer bereit ist, lernen wir die ersten eigenen Wörter in Rust!
=== 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!


==== Variablen und Veränderbarkeit (Mutabilität) ====
=== Ü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!


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.
== 3. Grundlegende Syntax ==
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!
=== 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 bedeutet: Hier ist eine neue Kiste.
     let name = "Thorsten"; // Das ist eine unveränderliche Kiste!
    let alter = 10;
     // name = "Peter"; // Das würde einen Fehler geben, der Name ist fest.
     // alter = 11; // 🛑 FEHLER! Diese Kiste ist verschlossen. Wir dürfen das "alter" nicht ändern.
      
 
     let mut alter = 10; // "mut" steht für "mutable" (veränderbar).
     // let mut bedeutet: Hier ist eine neue Kiste, die sich ändern darf!
     alter = 11; // Jetzt hat er Geburtstag gehabt!
     let mut punkte = 0;
   
    println!("Startpunkte: {}", punkte); // Die {} sind Platzhalter, dort wird unsere Zahl eingesetzt!
     println!("Hallo {}, du bist {} Jahre alt.", name, alter);
 
     punkte = 5; // Yay! Wir haben 5 Punkte in einem Spiel gesammelt!
     println!("Neue Punkte gesammelt! Jetzt sind es: {}", punkte);
}
}
</syntaxhighlight>
</source>


==== Kommentare ====
=== Lektion: Datentypen ===
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.
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`).


==== Datentypen (Was kommt in die Kiste?) ====
Verbundtypen:
Was genau packen wir in unsere Kisten? Hier sind die wichtigsten "Typen":
* '''Tupel:''' Eine Kiste mit unterschiedlichen Dingen.
* '''Zahlen, also Integers (Skalare):''' Normale Zahlen ohne Komma, z. B. `10`, `42`, `-5`.  
* '''Arrays:''' Eine Kiste mit vielen gleichen Dingen.
* '''Kommazahlen, also Floats (Skalare):''' z. B. `3.14` oder `0.5`.  
<source lang="rust">
* '''Wahrheitswerte, Booleans (Skalare):''' Gibt es nur zwei: `true` (wahr) oder `false` (falsch).
let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
* '''Text, also Strings (Verbundtypen):''' Wörter und Sätze in Anführungszeichen wie `"Hallo"`.
let mein_array: [i32; 3] = [1, 2, 3];
</source>


==== Funktionen (Eigene Baupläne schreiben) ====
=== Lektion: Funktionen und Kommentare ===
Wir haben das Haupttor `fn main()` schon kennengelernt. Du kannst aber auch eigene Unter-Baupläne (Funktionen) erstellen!
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.
<source lang="rust">
// Das ist eine Funktion, die "Hallo" sagt
fn sag_hallo() {
    println!("Hallo von der Funktion!");
}


<syntaxhighlight lang="rust">
fn main() {
fn main() {
     // Wir rufen unseren Unter-Bauplan auf und übergeben einen Namen:
     sag_hallo(); // Hier rufen wir unser Rezept auf!
    begruesse_spieler("Anna");
}
 
// Hier ist unser eigener cooler Bauplan!
// Er braucht eine Zutat "name". Das "&str" bedeutet, es muss Text (String) sein.
fn begruesse_spieler(name: &str) {
    println!("Willkommen im rustigen Abenteuer-Spiel, {}!", name);
}
}
</syntaxhighlight>
</source>
 
---


=== Lektion 3: Kontrollstrukturen (Wir fällen Entscheidungen!) ===
=== Ü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.


Programme wären sehr langweilig, wenn sie immer nur exakt das Gleiche tun. Wir wollen, dass unser Code kluge Entscheidungen trifft!
== 4. Kontrollstrukturen ==
=== Lernziele ===
* Bringe dem Programm bei, Entscheidungen zu treffen (`if`, `else`).
* Wiederhole Dinge automatisch mithilfe von '''Schleifen''' (`loop`, `while`, `for`).


==== if, else if, else (Wenn ... Dann ...) ====
=== Lektion: Wenn-Dann (if / else if / else) ===
Stell dir vor, du bist an einer Weggabelung und musst ein Schild lesen.
Dein Programm soll schlau sein!
<syntaxhighlight lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let alter = 10;
     let wetter = "Regen";


     if alter >= 18 {
     if wetter == "Regen" {
         println!("Du darfst ein echtes Auto fahren!");
         println!("Nimm einen Regenschirm mit!");
     } else if alter >= 10 {
     } else if wetter == "Schnee" {
         println!("Du darfst ein super cooles Fahrrad mit Gangschaltung fahren!");
         println!("Zieh warme Stiefel an!");
     } else {
     } else {
         println!("Fahr lieber sicher mit dem Roller auf dem Hof!");
         println!("Zieh ein T-Shirt an!");
     }
     }
}
}
</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!
=== Lektion: Schleifen (Wiederholungen) ===
* '''loop''': Läuft für immer und ewig im Kreis... bis du das magische Wort `break` sagst!
Computer sind toll darin, Dinge sehr oft zu tun, ohne sich zu langweilen.
* '''while''': Läuft SOLANGE eine einfache Bedingung `true` (wahr) ist.
* '''loop''': Läuft für immer (bis du `break` sagst).
* '''for''': Zählt einfach von einem Startpunkt zu einem Endpunkt durch. (Die beste Schleife für Anfänger und sehr sicher!)
* '''while''': Läuft solange eine Bedingung wahr ist.
* '''for''': Zählt eine bestimmte Anzahl durch.


<syntaxhighlight lang="rust">
<source lang="rust">
fn main() {
fn main() {
     // Die FOR-Schleife: Zählt von 1 bis 3
     // for-Schleife (zählt von 1 bis 3)
    println!("Achtung, Raketenstart in...");
     for zahl in 1..4 {
     for zahl in 1..4 { // Zählt 1, 2, 3 (die 4 am Ende gehört nicht mehr dazu!)
         println!("Ich zähle: {}", zahl);
         println!("{}...", zahl);
     }
     }
    println!("Zündung! 🚀");
}
</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 ==
 
=== 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.
 
#Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
#Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
#Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
#Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
#Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
#Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
#Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
#Einfacher Taschenrechner (Multiplikation): Eine Funktion, die zwei i32-Zahlen multipliziert.
#Einfacher Taschenrechner (Division): Eine Funktion, die zwei i32-Zahlen dividiert.
#Gerade oder Ungerade?: Prüfe mit if/else und % 2, ob eine Zahl gerade ist.
#Notenbewerter: Gib zu einer Zahl von 1-6 ein Textfeedback aus.
#Schleifen-Zähler: Nutze eine for-Schleife, um von 1 bis 10 zu zählen.
#Raketen-Countdown: Nutze eine for-Schleife (10..1), gefolgt von 'Ignition!'.
#Passwort-Prüfer: Ein if/else Check eines String-Passwortes gegen ein festes 'geheim123'.
#Tage-in-Monat-Rechner: Ordne einem Monatsnamen (als String) die Anzahl der Tage per if/else zu.
#Schachtel-Verschachteler: Nutze ein if/else in einem if/else (Nested If).
#FizzBuzz Mini: Iteriere von 1 bis 20 und ersetze durch fizz/buzz.
#Die unendliche Schleife mit Ausweg: Ein loop {}, der bei counter == 5 mit break beendet wird.
#while-Schleifen-Zähler: Das Gleiche wie Projekt 12, aber mit while.
#Array-Lesezeichen: Lege ein Array mit 5 Buchtiteln an und drucke das dritte Buch.
#Tuple-Lieblinge: Erstelle ein Tupel (Farbe, Zahl, Essen) und greife auf die Zahl zu.
#Funktions-Grüßer: Übergib einen Namen als Argument an eine Funktion, die hallo sagt.
#Mutabilitäts-Test: Lege variable X an, ändere sie danach dreimal und gib sie nach jeder Änderung aus.
#Schleifen-Summe: Addiere die Zahlen von 1 bis 100 in einer Schleife.
#Der kleine Papagei: Eine Funktion, der du einen Text übergibst und die ihn 3x nacheinander ausdruckt.
#Schaltjahr-Prüfer: if/else, um zu checken, ob Variable 'jahr' ein Schaltjahr ist.
#Tier-Laute: Funktion, die einen Tiernamen nimmt und das passende Geräusch (Miauen, Bellen) printet.
#Einkaufslisten-Array: Lege 5 Dinge an und printe jedes Element mit einer for-Schleife aus.
#Schatten-Ninja (Shadowing): Überschreibe eine let-Variable neu (let my_var = 1; let my_var = 'zwei').
#Wochentag-Anzeige: Speichere 1-7 in einer Variable und gib den passenden Wochentag aus.
#Zahlen-Rater-Mock: 'if geraten_zahl == zielzeug' check (ohne echten Input).
#Zeichenzähler in Schleife: Printe ein '*' 1x, 2x, 3x mithilfe von String::repeat().
#Wetter-Bot: Array von Wetter-Zuständen, das zufällig ausgegeben wird.
#Das vergessene Semikolon: Erzeuge absichtlich einen Compiler-Fehler, fix ihn.
#Einrückungs-Korrektur: Nimm unformatierten Code und schiebe ihn durch 'cargo fmt'.
#Das Typ-Experiment: Erzwinge verschiedene Typen für x (f32, f64, i8, i16).
#Kino-Alterskontrolle: if/else ab 12, 16 oder 18 Jahren.
#Umfangrechner Skript: Länge und Breite berechnen Umfang.
#Flächenrechner: Länge mal Breite.
#ASCII-Kunst: Nutze println! für kleine ASCII-Bilder (Hund, Haus).
#Fahrkarten-Automat: Wenn genug Geld (Variable) da ist -> Ticket drucken, sonst Fehlbetrag nennen.
#Vokabel-Tupel: (Deutsch, Englisch) in Variablen und geordnet ausgeben.
#Mittelwert-Berechner: Array von 3 Zahlen nehmen und Mittelwert (Addition / 3) errechnen.
#Gefahren-Ampel: Rot, Gelb, Grün -> Ausgaben wie Stop, Warnung, Go.
#while_let Anfänge (Optional): Optionale Option<i32> ausprobieren.
#Rustup-Check-Skript: Nutze std::process::Command (oder print!), um zu zeigen, dass du verstanden hast, was rustc --version ausgibt.
#Die Cargo.toml betrachten: Füge im Kommentarfeld die Erklärung des Cargo Manifests ein.
#Konstanten-Macht: Deklariere eine const MWST: f64 = 0.19; und rechne damit.
#Kleines Textadventure (Raumbeschreibung): Nutze Funktionen für 3 Räume.
#Würfelspiel-Simulation (ohne Random): Fest programmierte Würfel-Ergebnisse addieren.
#Würfelspiel-Anzeige: Array von [1,2,3,4,5,6] -> durchlaufen.
#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.
 
#Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife ('Wie möchtest du gehen?').
#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.


    // Die WHILE-Schleife (Mit Veränderbarkeit gemischt - "Interleaving"!):  
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
    let mut energie = 3;
* Installation und Einrichtung:
    while energie > 0 {
  * `rustup`, `rustc` und `cargo`.
        println!("Roboter stapft herum... Energie bei {}", energie);
  * Ein „Hello World!“-Programm.
        energie = energie - 1; // Energie wird pro Schritt weniger!
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
    }
* Grundlegende Syntax:
    println!("Dem Roboter fehlt Energie. Er schläft jetzt ein. 💤");
  * Variablen und Mutabilität (`let`, `let mut`).
}
  * Datentypen (Skalar- und Verbundtypen).
</syntaxhighlight>
  * Funktionen und Kommentare.
* Kontrollstrukturen:
  * `if`, `else if`, `else`.
  * Schleifen (`loop`, `while`, `for`).


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


== Projekte & Übungen ==
* 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.


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


=== Projekt Vorschlag 1: Der kluge Zahlen-Magier (Variablen & If) ===
Ausgabe und Speicherung:
'''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;`).
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
* Der Zahlen-Magier soll die beiden Zahlen zusammen addieren (+) und in einer neuen, veränderlichen Variablen speichern.  
* Das Ausgabeformat ist die MediaWiki-Syntax.
* Wenn das Ergebnis größer als 25 ist, soll das Programm "Magie! Der Angriff ist sehr stark!" ausgeben. Wenn es kleiner ist: "Der Angriff hat keine Wirkung, versammle mehr Stärke!".
'''Tipp:''' Verbinde hier Datentypen (Zahlen) mit Entweder/Oder-Entscheidungen (`if` / `else`)!


=== Projekt Vorschlag 2: Das tickende Sicherheitssystem (While & Mutabilität) ===
==Prompt==
'''Deine Aufgabe:''' Simuliere ein einfaches Sicherheitssystem.
<pre>
* Erstelle eine veränderliche Variable `let mut versuche = 3;`.
* Benutze eine `while`-Schleife, die nur solange läuft, wie `versuche > 0` ist.
* In der Schleife sagst du: `"Falsches Passwort! Noch {} Versuche übrig."` und reduzierst die Variable sofort um eins (`versuche = versuche - 1`).
* Nach der Schleife (wenn alles durchgelaufen ist) gibst du aus: `"Sicherheitssystem gesperrt! Alarm!"`


=== Projekt Vorschlag 3: Der nervige Papageien-Helfer (Funktionen & For-Schleifen) ===
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
'''Deine Aufgabe:''' Erstelle eine eigene Funktion `fn papagei(text: &str, anzahl: i32)`.
* Installation und Einrichtung:
* In dieser Funktion nutzt du eine `for`-Schleife, um den `text` genauso oft zu wiederholen (`anzahl`), wie die Zahl groß ist!
  * `rustup`, `rustc` und `cargo`.
* Rufe diese neue Funktion dann ganz oben in deiner `fn main()` auf, zum Beispiel so: `papagei("Polly will einen Keks!", 5)`.
  * Ein „Hello World!“-Programm.
'''Tipp:''' Hier bauen wir ganz klassisch von den Schleifen und Variablen auf (Bottom-Up) bis hin zur eigenen Funktion, in die man Werte hineinreicht!
* 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.


== Quiz (Teste dein Wissen) ==
* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
<quiz>
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
Lass uns überprüfen, was in deinem Kopf hängengeblieben ist! Fülle die Lücken aus.
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.


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


{Complete the text about Rust Control Structures.
Ausgabe und Speicherung:
|type="{}"}
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
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 Ausgabeformat ist die MediaWiki-Syntax.
</quiz>
</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“