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
 
(5 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!


Willkommen zum großen Rust-Abenteuer! Stell dir Rust wie eine Kiste voller unkaputtbarer Lego-Bausteine vor. Wenn du damit eine Burg baust, weißt du: Sie wird extrem schnell fertig und bricht niemals zusammen!
== 1. Installation und Einrichtung ==
Diese Lernreise ist speziell für Kinder ab zehn Jahren und für absolute Code-Anfänger gedacht.
=== 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.


== Lernziele ==
=== Lektion ===
Am Ende dieser Etappe kannst du:
Um Rust nutzen zu können, brauchen wir unser Werkzeug:
* Deinen eigenen Werkzeugkasten aufbauen (Installation).
* '''rustup''': Das ist dein Installations-Roboter. Er holt dir die neueste Version von Rust.
* Dem Computer Befehle erteilen ("Hello World!").
* '''rustc''': Der Übersetzer (Compiler). Er liest deinen Code und verwandelt ihn in ein Programm, das der Computer versteht.
* Daten in Kisten speichern (Variablen & Datentypen).
* '''cargo''': Dein treuer Helfer und Paketmanager. Cargo erstellt neue Projekte, lädt Erweiterungen herunter und baut dein Programm zusammen.  
* Den Computer Entscheidungen treffen lassen (If/Else).
* Langweilige Aufgaben vom Computer schnell wiederholen lassen (Schleifen).
* Deine eigenen Mini-Programme komplett selbst schreiben!


== Lektion 1: Installation und dein erstes Programm ==
'''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!


=== Was brauchen wir zum Bauen? ===
'''Dein erstes Programm: "Hello World!"'''
Um Rust zu nutzen, brauchst du drei super Helfer auf deinem Computer:
Lass uns Cargo benutzen, um ein neues Projekt zu starten:
* '''rustup''': Das ist dein Werkzeugkasten-Manager. Er holt dir immer die neueste Version von Rust aus dem Internet.
<source lang="bash">
* '''rustc''': Der Übersetzer (Compiler). Er liest deinen Text-Code und übersetzt ihn in Maschinensprache – die einzige Sprache, die dein Computer versteht (nur Einsen und Nullen).
* '''cargo''': Dein allerbester Freund! Cargo erstellt neue Projekte für dich, startet deine Programme und lädt Erweiterungen aus dem Internet herunter.
 
'''Aufgabe für dich:''' Öffne ein Terminal (das schwarze Fenster deines Computers) und tippe ein, was die Rust-Webseite dir sagt, um es zu installieren.
 
=== Das IDE-Setup (Dein Zauber-Schreibtisch) ===
Ein normaler Notizblock ist zu dumm zum Programmieren. Wir benutzen '''Visual Studio Code (VS Code)'''.
Lade VS Code herunter und installiere die Erweiterung '''rust-analyzer'''. Diese Erweiterung ist wie ein Helfer, der dir noch beim Tippen Fehler mit roten Linien markiert – genau wie dein Lehrer beim Diktat!
 
=== Das "Hello World!"-Programm ===
Lass uns den Computer dazu bringen, dich zu begrüßen!
Tippe in deinem Terminal:
<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!


Was ist passiert? <code>cargo new</code> hat ein leeres Projekt gebaut. <code>cd</code> bedeutet "change directory" (gehe in den Ordner). Mit <code>cargo run</code> baust und startest du das Programm!
=== Übungen ===
Wenn du in die Datei <code>src/main.rs</code> schaust, siehst du:
# Installiere Rust auf deinem Computer.
<syntaxhighlight lang="rust">
# Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
fn main() {
# Führe das Projekt mit `cargo run` aus.
    println!("Hello, world!");
 
}
== 2. IDE-Einrichtung (Dein digitaler Schreibtisch) ==
</syntaxhighlight>
=== Lernziele ===
* <code>fn main()</code>: Hier startet das Programm. Jeder Computer sucht nach der Hauptfunktion "main", um anzufangen. <code>fn</code> bedeutet "Funktion" (ein Rezept).
* Du lernst, wie du "Visual Studio Code" (VS Code) einrichtest.
* <code>println!("...");</code>: Das sagt dem Computer: "Drucke diesen Text auf den Bildschirm". Das <code>!</code> bedeutet, dass es sich um ein Makro handelt. Stell es dir wie einen vorgefertigten Zauberspruch vor!
* 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.
# 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!


=== Ü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!


== Lektion 2: Grundlegende Syntax (Kisten und Schachteln) ==
== 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.


=== Variablen und Mutabilität (let und let mut) ===
=== Lektion: Variablen und Mutabilität ===
Stell dir Variablen wie Kisten vor, in die du Werte (wie Zahlen oder Wörter) packst. Jede Kiste hat ein Schildkleber mit einem Namen.
Stell dir eine Variable wie eine Kiste vor, in die du etwas hineinlegst.
<syntaxhighlight lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let alter = 10;
     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>
In Rust sind Kisten normalerweise **verschlossen**. Du kannst den Inhalt von <code>alter</code> nicht mehr ändern!
 
Wenn eine Kiste **offen** bleiben soll, damit du etwas Neues hineinlegen kannst, brauchst du das Zauberwort <code>mut</code> (das steht für mutabel, also veränderbar).
=== Lektion: Datentypen ===
<syntaxhighlight lang="rust">
Es gibt einfache Typen (Skalartypen) und zusammengesetzte Typen (Verbundtypen).
fn main() {
* '''Zahlen (Integer):''' Ganze Zahlen wie `5` oder `100` (`i32`, `u32`).
    let mut punkte = 0; // Kiste ist offen!
* '''Kommazahlen (Float):''' Zahlen wie `3.14` (`f64`).
    punkte = punkte + 5; // Juhu, 5 Punkte gefunden!
* '''Wahrheitswerte (Boolean):''' `true` (richtig) oder `false` (falsch) (`bool`).
    println!("Punkte: {}", punkte);
* '''Zeichen (Char):''' Ein einzelner Buchstabe oder Smiley wie `'A'` oder `'😊'` (`char`).
}
</syntaxhighlight>


=== Datentypen (Was passt in die Kisten?) ===
Verbundtypen:
Der Computer muss wissen, ob in der Kiste eine Zahl, ein Wort oder ein Schalter liegt.
* '''Tupel:''' Eine Kiste mit unterschiedlichen Dingen.
* '''Skalare (Einzelne Dinge):'''
* '''Arrays:''' Eine Kiste mit vielen gleichen Dingen.
** Ganze Zahlen (z.B. <code>10</code> oder <code>-5</code>). In Rust oft <code>i32</code> genannt.
<source lang="rust">
** Kommazahlen (z.B. <code>3.14</code>). Genannt <code>f64</code>.
let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
** Wahrheitswerte (Booleans). Wie ein Lichtschalter: <code>true</code> (An/Wahr) oder <code>false</code> (Aus/Falsch). Genannt <code>bool</code>.
let mein_array: [i32; 3] = [1, 2, 3];
** Buchstaben. Einzelne Zeichen wie <code>'A'</code> oder ein Emoji <code>'🚀'</code>. Genannt <code>char</code>.
</source>
* '''Verbundtypen (Mehrere Dinge):'''
** Arrays: Ein Eierkarton. Alle Dinge darin müssen gleich sein (z.B. nur Zahlen). Die Größe ist fest.
** Tupel: Eine Brotdose mit verschiedenen Fächern. In Fach 1 ist ein Brot (Text), in Fach 2 ein Apfel (Zahl).


=== Funktionen und Kommentare ===
=== Lektion: Funktionen und Kommentare ===
Kommentare sind Notizen, die der Computer komplett ignoriert. Sie sind nur für dich! Starte sie mit <code>//</code>.
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.
Funktionen sind wie Backrezepte. Einmal aufschreiben, 100-mal Waffeln backen!
<source lang="rust">
<syntaxhighlight lang="rust">
// Das ist eine Funktion, die "Hallo" sagt
// Das ist eine Funktion (unser Rezept), die uns begrüßt.
fn sag_hallo() {
fn begruesse_hund(name: &str) {
     println!("Hallo von der Funktion!");
     println!("Wuff, hallo {}!", name);
}
}


fn main() {
fn main() {
     // Hier nutzen wir das Rezept
     sag_hallo(); // Hier rufen wir unser Rezept auf!
    begruesse_hund("Bello");
}
}
</syntaxhighlight>
</source>


=== Ü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.


== Lektion 3: Kontrollstrukturen (Der Computer denkt mit) ==
== 4. Kontrollstrukturen ==
=== Lernziele ===
* Bringe dem Programm bei, Entscheidungen zu treffen (`if`, `else`).
* Wiederhole Dinge automatisch mithilfe von '''Schleifen''' (`loop`, `while`, `for`).


=== Entscheidungen treffen: if, else if, else ===
=== Lektion: Wenn-Dann (if / else if / else) ===
Stell dir eine Straßenkreuzung vor.
Dein Programm soll schlau sein!
<syntaxhighlight lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let taschengeld = 10;
     let wetter = "Regen";


     if taschengeld >= 15 {
     if wetter == "Regen" {
         println!("Ich kaufe mir das große Lego-Set!");
         println!("Nimm einen Regenschirm mit!");
     } else if taschengeld >= 5 {
     } else if wetter == "Schnee" {
         println!("Ein Eis reicht auch.");
         println!("Zieh warme Stiefel an!");
     } else {
     } else {
         println!("Ich muss noch sparen.");
         println!("Zieh ein T-Shirt an!");
     }
     }
}
}
</syntaxhighlight>
</source>


=== Schleifen: loop, while, for ===
=== Lektion: Schleifen (Wiederholungen) ===
Computer lieben Wiederholungen. Menschen hassen sie. Lassen wir die Arbeit vom Computer machen!
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.


'''1. Das endlose Karussell (loop):'''
<source lang="rust">
Es dreht sich für immer, es sei denn du schreist STOPP (<code>break</code>).
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let mut runden = 0;
     // for-Schleife (zählt von 1 bis 3)
     loop {
     for zahl in 1..4 {
        runden = runden + 1;
         println!("Ich zähle: {}", zahl);
         println!("Runde {}!", runden);
        if runden == 3 {
            println!("Mir wird schlecht, aussteigen!");
            break; // Das STOPP-Wort
        }
     }
     }
}
}
</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 ==
 
=== 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.


'''2. Solange du ein Ticket hast (while):'''
#Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
<syntaxhighlight lang="rust">
#Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
fn main() {
#Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
    let mut tickets = 3;
#Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
    while tickets > 0 {
#Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
        println!("Autoscooter fahren! Tickets übrig: {}", tickets);
#Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
        tickets = tickets - 1;
#Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
    }
#Einfacher Taschenrechner (Multiplikation): Eine Funktion, die zwei i32-Zahlen multipliziert.
    println!("Alle Tickets weg.");
#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.
</syntaxhighlight>
#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.
 
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==
<pre>
 
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`).


'''3. Von 1 bis 10 zählen (for):'''
Erkläre alle Inhalte leicht verständlich für Programmieranfänger.
Perfekt, wenn du genau weißt, wie oft etwas passieren soll.
<syntaxhighlight lang="rust">
fn main() {
    // 1..4 bedeutet: zähle 1, 2, 3 (die 4 ist NICHT mehr drin, wie ein Countdown)
    for zahl in 1..4 {
        println!("Ich zähle: {}", zahl);
    }
    // Willst du die letzte Zahl mitzählen, nutze 1..=3
}
</syntaxhighlight>


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


== Projektbasiertes Lernen: 30 Mini-Projekte ==
Programmiere diese kleinen Aufgaben in eigenen <code>cargo new</code> Projekten, um super stark in Rust zu werden! So lernst du am schnellsten.


# '''Grüß-Maschine''': Drucke 3 Zeilen mit <code>println!</code>, die deine Eltern grüßen.
Ausgabe und Speicherung:
# '''Variablen-Zaubertrick''': Erstelle eine <code>mut</code> Variable mit dem Wert 5. Verdopple sie im Code und gib das Ergebnis aus.
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
# '''Taschengeld-Rechner''': Lege zwei Variablen an (Geld von Oma, Geld von Opa). Addiere sie und lass den Computer das Ergebnis sprechen ausgeben.
* Das Ausgabeformat ist die MediaWiki-Syntax.
# '''Hundejahre-Umrechner''': Speichere dein Alter in einer Variable und multipliziere es mit 7.
</pre>
# '''Lieblingstier-Liste''': Erstelle ein Array (Listen-Eierkarton) mit 3 Tiernamen und drucke das erste Tier. (Achtung, Computer beginnen bei Index 0 zu zählen!)
# '''Türsteher (if)''': Wenn die Variable <code>alter</code> unter 12 ist, drucke "Film gesperrt". Sonst drucke "Viel Spaß im Kino".
# '''Wetter-Roboter''': Eine <code>bool</code> Variable <code>regnet_es = true</code>. Nutze <code>if x { ... } else { ... }</code>, um die Jacke zu wählen.
# '''Raketen-Countdown (for)''': Zähle von 5 bis 1 rückwärts in einer Schleife (Tipp: <code>(1..=5).rev()</code>). Danach "Lift-Off!".
# '''Das Sparschwein (while)''': Solange <code>geld < 20</code>, drucke "Ein Euro rein!", und rechne <code>geld = geld + 1</code>.
# '''Zahlen-Summierer''': Addiere alle Zahlen von 1 bis 100 in einer <code>for</code>-Schleife und gib das Ende aus.
# '''Rezept-Vergrößerer''': Schreibe eine Funktion, die die benötigten Eier für einen Kuchen anzeigt. Rufe sie auf.
# '''Gerade / Ungerade''': Prüfe mit <code>if zahl % 2 == 0</code>, ob eine Variable gerade ist. Modulo <code>%</code> hilft dir!
# '''Brotdosen-Tupel''': Ein Tupel speichert einen Text ("Apfel"), eine Zahl (2 Stück) und ein <code>bool</code> (Tastet es gut? true). Drucke es!
# '''Achterbahn-Loop''': Nutze <code>loop</code> und <code>break</code>, um genau 4 Runden Looping zu fahren.
# '''Strafarbeiten-Automat''': Nutze <code>for</code>, um 100 Mal den Satz "Ich darf nicht im Unterricht stören" "an die Tafel" zu drucken.
# '''Teilen-macht-Freunde''': 30 Bonbons, 4 Kinder. Wie viele bekommt jeder (Division <code>/</code>) und wie viele bleiben übrig (Modulo <code>%</code>)?
# '''Passwort-Alarm''': <code>if passwort == "Keks" { "Zugang erlaubt" } else { "ALARM" }</code>.
# '''Guthaben-Limit''': Wenn dein Handy-Guthaben unter 2 Euro fällt, warne dich. Sonst drucke das genaue Guthaben.
# '''Ampel-Simulator''': Erstelle eine Funktion <code>ampel_farbe(farbe)</code>, die sagt was man tun muss (Rot = Stehen, Grün = Gehen).
# '''Glückszahl-Finder''': <code>while</code>-Schleife, die zu 0 immer +3 addiert, und stoppt wenn es 15 ist.
# '''Zeugnis-Sprüche''': <code>if</code>, <code>else if</code> und <code>else</code>, um zu 1, 2, 3 passendes Lob zu geben. Bei 6 sagt es "Ohje".
# '''Puls-Messer''': Wenn Schläge unter 60 "zu langsam", wenn über 160 "zu schnell", dazwischen "perfekt!".
# '''Multiplikations-Reihe''': Gibt in einer Schleife 1x7, 2x7, 3x7... bis 10x7 aus.
# '''Tage-im-Jahr-Rechner''': Wenn <code>schaltjahr == true</code>, mach Ausgaben für 366 Tage, ansonsten für 365.
# '''Zeichen-Maler''': Drucke mit einer Schleife einen halben Baum (1 Sternchen, dann 2, dann 3).
# '''Notfall-Knopf''': Die Funktion <code>sos()</code> gibt "...---..." aus. Rufe sie dreimal auf.
# '''Schwarm-Intelligenz''': Zähle in einer Schleife Vögel. Jeder ist ein <code>println!("Vogel {} ist da!", x)</code>.
# '''Vokal-Quiz''': Prüfe ob ein Char gleich 'a', 'e', 'i', 'o' oder 'u' ist.
# '''Wochentags-Ansage''': Ein Array mit 7 Namen (Montag..Sonntag). Eine Funktion bekommt eine Zahl 0-6 und gibt den Namen aus.
# '''Tee-Timer''': Ein <code>loop</code>, wobei eine <code>minuten</code> Variable hochzählt. Bei 5 Minuten: <code>break</code> und "Tee fertig!".


----
----
''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“