Rust/Grundlagen: Unterschied zwischen den Versionen

Aus Dokument
Zur Navigation springen Zur Suche springen
← Zum vorherigen VersionsunterschiedZum nächsten Versionsunterschied →

Thorsten (Diskussion | Beiträge)

3 Benutzergruppen
69 Bearbeitungen
VisuellWikitext
Keine Bearbeitungszusammenfassung
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 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!
Unsere Mission in den ersten zwei Wochen: Wir lernen die Werkzeuge kennen und schreiben unsere allerersten magischen Zeilen Code.
Diese Lernreise ist speziell für Kinder ab zehn Jahren und für absolute Code-Anfänger gedacht.


== Lernziele ==
== 1. Installation und Setup — Packen wir unseren Werkzeugkasten! ==
Am Ende dieser Etappe kannst du:
* Deinen eigenen Werkzeugkasten aufbauen (Installation).
* Dem Computer Befehle erteilen ("Hello World!").
* Daten in Kisten speichern (Variablen & Datentypen).
* 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 ==
Bevor ein Handwerker ein Baumhaus bauen kann, braucht er Hammer und Säge. Genauso brauchen wir als Entwickler unsere eigenen Werkzeuge.


=== Was brauchen wir zum Bauen? ===
=== Installation von `rustup`, `rustc` und `cargo` ===
Um Rust zu nutzen, brauchst du drei super Helfer auf deinem Computer:
Um Rust auf deinem Computer zu benutzen, brauchen wir einen magischen Installateur namens '''rustup'''.
* '''rustup''': Das ist dein Werkzeugkasten-Manager. Er holt dir immer die neueste Version von Rust aus dem Internet.
* '''rustup''': Das ist der Helfer, der Rust auf deinen Computer holt.
* '''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).
* '''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''': Dein allerbester Freund! Cargo erstellt neue Projekte für dich, startet deine Programme und lädt Erweiterungen aus dem Internet herunter.
* '''cargo''': Das ist dein persönlicher Butler! Er baut deine Programme, holt dir neue Bausteine (Bibliotheken) und hilft dir beim Starten.


'''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.
'''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 IDE-Setup (Dein Zauber-Schreibtisch) ===
=== Das „Hello World!“-Programm ===
Ein normaler Notizblock ist zu dumm zum Programmieren. Wir benutzen '''Visual Studio Code (VS Code)'''.
Das ist Tradition unter Programmierern: Das allererste Programm, das man schreibt, sagt immer "Hallo Welt". Lass uns das bauen!
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 ===
Öffne dein Terminal (die Kommandozeile) und tippe ein, um Cargo zu bitten, ein neues Projekt zu machen:
Lass uns den Computer dazu bringen, dich zu begrüßen!
Tippe in deinem Terminal:
<syntaxhighlight lang="bash">
<syntaxhighlight lang="bash">
cargo new hallo_welt
cargo new hallo_welt
Zeile 38: Zeile 29:
</syntaxhighlight>
</syntaxhighlight>


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!
Boom! Da steht „Hello, world!“ auf dem Bildschirm. Du hast gerade dein erstes Programm ausgeführt! 🥳
Wenn du in die Datei <code>src/main.rs</code> schaust, siehst du:
 
<syntaxhighlight lang="rust">
=== Einrichtung der IDE (VS Code) ===
fn main() {
Eine IDE ist dein Schreibtisch zum Programmieren. Wir empfehlen '''Visual Studio Code''' (VS Code).
    println!("Hello, world!");
# Lade dir VS Code aus dem Internet herunter.
}
# Öffne es und suche links nach "Erweiterungen" (Extensions) – das sind so kleine Bauklötze-Symbole.
</syntaxhighlight>
# Suche nach '''rust-analyzer''' und installiere es. Das ist dein magischer Assistent, der dir Fehler anzeigt und dir hilft, Code schneller zu schreiben!
* <code>fn main()</code>: Hier startet das Programm. Jeder Computer sucht nach der Hauptfunktion "main", um anzufangen. <code>fn</code> bedeutet "Funktion" (ein Rezept).
 
* <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!
== 2. Grundlegende Syntax — Die ersten Legosteine ==


Jetzt schauen wir uns an, woraus so ein Programm eigentlich besteht.


== Lektion 2: Grundlegende Syntax (Kisten und Schachteln) ==
=== Variablen und Veränderbarkeit (`let`, `let mut`) ===
Eine Variable ist wie eine Kiste, auf die du einen Namen schreibst und etwas hineinlegst.


=== Variablen und Mutabilität (let und let mut) ===
Stell dir Variablen wie Kisten vor, in die du Werte (wie Zahlen oder Wörter) packst. Jede Kiste hat ein Schildkleber mit einem Namen.
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let alter = 10;
     let alter = 10; // Eine Kiste namens "alter" mit der Zahl 10 drin.
     println!("Ich bin {} Jahre alt.", alter);
     println!("Ich bin {} Jahre alt.", alter);
}
}
</syntaxhighlight>
</syntaxhighlight>
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).
'''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!
 
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let mut punkte = 0; // Kiste ist offen!
     let mut taschengeld = 5; // mut bedeutet: Wir dürfen die Kiste öffnen!
     punkte = punkte + 5; // Juhu, 5 Punkte gefunden!
     taschengeld = 10; // Jetzt hast du mehr Taschengeld!
     println!("Punkte: {}", punkte);
     println!("Ich habe {} Euro.", taschengeld);
}
}
</syntaxhighlight>
</syntaxhighlight>


=== Datentypen (Was passt in die Kisten?) ===
=== Datentypen — Was passt in die Kiste? ===
Der Computer muss wissen, ob in der Kiste eine Zahl, ein Wort oder ein Schalter liegt.
Der Computer muss wissen, WAS in der Kiste ist. Eine Zahl? Ein Buchstabe? Ein ganzes Wort?
* '''Skalare (Einzelne Dinge):'''
* '''Integer (Zahlen ohne Komma):''' `let alter = 10;`
** Ganze Zahlen (z.B. <code>10</code> oder <code>-5</code>). In Rust oft <code>i32</code> genannt.
* '''Float (Zahlen mit Komma - wichtig: Im Englischen nimmt man den Punkt!):''' `let groesse = 1.45;`
** Kommazahlen (z.B. <code>3.14</code>). Genannt <code>f64</code>.
* '''Booleans (Ja oder Nein / Wahr oder Falsch):''' `let mag_eis = true;`
** Wahrheitswerte (Booleans). Wie ein Lichtschalter: <code>true</code> (An/Wahr) oder <code>false</code> (Aus/Falsch). Genannt <code>bool</code>.
* '''Strings (Wörter und Sätze):''' `let name = "Thorsten";`
** Buchstaben. Einzelne Zeichen wie <code>'A'</code> oder ein Emoji <code>'🚀'</code>. Genannt <code>char</code>.
* '''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 ===
=== Funktionen und Kommentare ===
Kommentare sind Notizen, die der Computer komplett ignoriert. Sie sind nur für dich! Starte sie mit <code>//</code>.
'''Kommentare''' (`//`) sind Notizen für dich! Der Computer liest sie nicht mit. Sie sind wie kleine Post-its in deinem Code.
Funktionen sind wie Backrezepte. Einmal aufschreiben, 100-mal Waffeln backen!
 
'''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">
<syntaxhighlight lang="rust">
// Das ist eine Funktion (unser Rezept), die uns begrüßt.
// Das ist eine Funktion, die "Wuff" sagt.
fn begruesse_hund(name: &str) {
fn hund_bellen() {
     println!("Wuff, hallo {}!", name);
     println!("Wuff! Wuff!");
}
}


fn main() {
fn main() {
     // Hier nutzen wir das Rezept
     hund_bellen(); // Hier rufen wir die Maschine auf!
    begruesse_hund("Bello");
}
}
</syntaxhighlight>
</syntaxhighlight>


== 3. Kontrollstrukturen — Wer bestimmt hier den Weg? ==
Manchmal soll ein Programm Entscheidungen treffen. Wenn es regnet, nimm den Regenschirm. Wenn die Sonne scheint, nimm die Sonnenbrille.


== Lektion 3: Kontrollstrukturen (Der Computer denkt mit) ==
=== Bedingungen (`if`, `else if`, `else`) ===
Mit `if` (wenn) und `else` (sonst) können wir dem Computer sagen, was er bei Entscheidungen tun soll.


=== Entscheidungen treffen: if, else if, else ===
Stell dir eine Straßenkreuzung vor.
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let taschengeld = 10;
     let schoko_eis = true;


     if taschengeld >= 15 {
     if schoko_eis {
         println!("Ich kaufe mir das große Lego-Set!");
         println!("Oh lecker, Schokoeis!"); // Das wird gemacht, wenn schoko_eis "true" (wahr) ist.
    } else if taschengeld >= 5 {
        println!("Ein Eis reicht auch.");
     } else {
     } else {
         println!("Ich muss noch sparen.");
         println!("Ein anderes Eis ist auch okay."); // Das wird gemacht, wenn es nicht wahr ist.
     }
     }
}
}
</syntaxhighlight>
</syntaxhighlight>


=== Schleifen: loop, while, for ===
=== Schleifen (`loop`, `while`, `for`) — Immer wieder dasselbe! ===
Computer lieben Wiederholungen. Menschen hassen sie. Lassen wir die Arbeit vom Computer machen!
Wenn du 10-mal "Hallo" sagen willst, musst du das nicht 10-mal hinschreiben. Dafür gibt es Schleifen!
* '''`loop`''': Macht etwas für immer, bis du mit `break` (abbrechen) Stopp sagst.
* '''`while`''': Macht etwas, *solange* eine Bedingung wahr ist (z.B. solange du noch Bonbons hast).
* '''`for`''': Zählt automatisch mit!


'''1. Das endlose Karussell (loop):'''
Es dreht sich für immer, es sei denn du schreist STOPP (<code>break</code>).
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">
fn main() {
fn main() {
     let mut runden = 0;
     // Zählt von 1 bis 5
     loop {
     for zahl in 1..6 {
        runden = runden + 1;
         println!("Zahl ist: {}", zahl);
         println!("Runde {}!", runden);
        if runden == 3 {
            println!("Mir wird schlecht, aussteigen!");
            break; // Das STOPP-Wort
        }
     }
     }
}
}
</syntaxhighlight>
</syntaxhighlight>


'''2. Solange du ein Ticket hast (while):'''
---
<syntaxhighlight lang="rust">
 
fn main() {
== Praxisbezogenes Lernen: 50 Magische Mini-Projekte ==
    let mut tickets = 3;
Programmieren lernt man durchs Selbermachen! Hier sind 50 kleine Aufgaben für dich zum Üben. Setz die neuen Legosteine zusammen!
    while tickets > 0 {
 
        println!("Autoscooter fahren! Tickets übrig: {}", tickets);
<ol>
        tickets = tickets - 1;
<li>'''Hallo-Welt-Roboter:''' Verändere dein Programm, sodass es "Hallo Meister!" sagt.</li>
    }
<li>'''Namensschild-Drucker:''' Erstelle eine Variable mit deinem Namen und gib aus: "Mein Name ist [Name]".</li>
    println!("Alle Tickets weg.");
<li>'''Alter in Tagen:''' Multipliziere dein Alter mit 365, um herauszufinden, wie viele Tage du lebst (Tipp: `*` ist malnehmen).</li>
}
<li>'''Lieblingsfarben-Zeiger:''' Drei Variablen mit Farben anlegen und kreativ auf dem Bildschirm ausdrucken.</li>
</syntaxhighlight>
<li>'''Einfacher Plus-Taschenrechner:''' Addiere Variablen `a = 10` und `b = 15`.</li>
<li>'''Minus-Taschenrechner:''' Ziehe zwei Zahlen voneinander ab.</li>
<li>'''Mal-Maschine:''' Multipliziere drei Variablen.</li>
<li>'''Teilen-Trainer:''' Teile dein Taschengeld (als Float) durch 2 (Tipp: `/`).</li>
<li>'''Satz-Zusammensetzer:''' Drucke mehrere Wörter aus Variablen in einem Satz.</li>
<li>'''Mein erster Kommentar:''' Schreibe einen Code und beschreibe ihn in 3 Kommentarzeilen.</li>
<li>'''Taschengeld-Update:''' Mache eine `mut` Variable, gib ihr 5 Euro, dann überschreibe sie mit 20 Euro. Drucke beides!</li>
<li>'''Level-Up:''' Ein `mut` Level in einem Spiel, zähle 1 Level hoch (`level = level + 1`).</li>
<li>'''Stimmungs-Bool:''' `let bin_froh = true;`. Drucke es aus.</li>
<li>'''Eis-Prüfer:''' if-Abfrage: Wenn `bin_froh == true`, dann print "Yay!".</li>
<li>'''Türsteher (Achterbahn):''' Erstelle `let groesse = 140;`. Wenn `groesse > 130`, dann "Darf fahren!", `else` "Leider noch zu klein."</li>
<li>'''Passwort-Labyrinth:''' `let code = 1234;`. Prüfe, ob `code == 1234` ist.</li>
<li>'''Ampel-Simulator:''' `let farbe = "Rot";`. `if` Rot -> "Stopp", `else if` Grün -> "Los!".</li>
<li>'''Wetter-Prophet:''' Bestimme mit if-else, was du anziehst (Regen vs. Sonne).</li>
<li>'''Schulnoten-Bewerter:''' Prüfe Noten 1 bis 6 und gib dazu passenden Text wie "Super!" oder "Oje." aus.</li>
<li>'''Lieblingstier:''' Wenn Tier == "Hund", bellen, bei "Katze" miauen.</li>
<li>'''Endlos-Bohrer:''' Nutze `loop { println!("Bohren..."); }` (Bohre endlos - breche mit Strg+C ab!).</li>
<li>'''Zahlenschloss-Knacker:''' Zähle in einem `loop` eine `mut`-Variable hoch und stoppe bei 10 mit `break`.</li>
<li>'''Raketen-Countdown:''' Mit einer `while`-Schleife von 10 herunterzählen, dann "Liftoff!".</li>
<li>'''Stammgast-Prüfer:''' `while hungrig == true`, iss einen Keks (simuliert).</li>
<li>'''Papagei-Programm:''' Sag 5 Mal "Hallo" in einer `for`-Schleife.</li>
<li>'''Das Einmaleins:''' Zähle von 1..11 und multipliziere den Zähler mit 2 (2er Reihe).</li>
<li>'''Zehner-Sprünge:''' Eine for-Schleife, die 10, 20, 30 ausgibt (Tipp: Multiplizieren).</li>
<li>'''Glückszahl-Finder:''' Finde in einer Schleife deine Glückszahl und schreibe "GEFUNDEN!" (mit if und break).</li>
<li>'''Ungerade Zahlen:''' Drucke nur ungerade Zahlen mit `if zahl % 2 != 0`.</li>
<li>'''Erste eigene Funktion:''' Mach eine Funktion `sag_tschuess()`.</li>
<li>'''Tierstimmen-Funktionen:''' Mach drei Funktionen: `hund()`, `katze()`, `kuh()`. Rufe alle in main auf.</li>
<li>'''Quadratmaschine (Funktion):''' Mach eine Variablen-Rechnung in einer separaten Funktion.</li>
<li>'''Wochentag-Anzeiger:''' Wenn Zahl = 1, dann Montag, usw.</li>
<li>'''Guten-Morgen-Schleife:''' Sage einer Liste von 3 Leuten (mit drei prints in der Schleife) Guten Morgen.</li>
<li>'''Hundejahre-Umrechner:''' Multipliziere dein Alter mit 7.</li>
<li>'''Kilometer-in-Meter:''' Rechne 5 km in Meter (mal 1000) um.</li>
<li>'''Pizza-Teiler:''' Wenn ich 8 Stücke habe und wir 3 Kinder sind, wie viel bleibt übrig? (Modulo `%`).</li>
<li>'''Spardosen-Checker:''' if Taschengeld > Spiele-Preis? "Du kannst es kaufen!"</li>
<li>'''Begrüßungs-Türsteher:''' Nutze `let name = "Dein Name";`. Wenn es dein Name ist, begrüße freundlich, sonst grimmig.</li>
<li>'''Ping-Pong-Zähler:''' Eine `for`-Schleife. Bei geraden Zahlen "Ping", bei ungeraden "Pong".</li>
<li>'''Wecker-Klingeln:''' Eine for-Schleife 1..4 mit "Klingeling!".</li>
<li>'''Lebenspunkte-Trank:''' `mut hp = 50;` -> `hp = hp + 20;` Wenn > 100, setze auf 100.</li>
<li>'''Geschwindigkeits-Blitzer:''' Schneller als 50 km/h? -> "Geknipst!".</li>
<li>'''Magisches Viereck:''' Berechne den Flächeninhalt (Seite mal Seite).</li>
<li>'''Würfel-Simulation (Manuell):''' Variablen für 3 Würfe. Zähle sie zusammen.</li>
<li>'''Die Geheim-Naricht:''' Drucke Buchstaben einzeln aus.</li>
<li>'''Bug-Fixer:''' Schreibe ein Programm, vergiss absichtlich ein Semikolon `;` und schau, wie nett der Cargo Compiler dir hilft!</li>
<li>'''Der Zornige Chef:''' Eine Funktion `schreien()`, die alles großschreibt (simuliert über println).</li>
<li>'''Kaffeemaschine:''' `let wasser_da = true; let kaffee_da = false;` if beides true -> "Kaffee machen", sonst Fehler.</li>
<li>'''Tagebuch-Einleitung:''' Nutze Variablen für Datum und Wetter und schreibe die Startzeile deines Tagebuchs.</li>
</ol>
 
 
== Strukturierung ins Top-Down-Lernen: 10 Große Projekte ==
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!
 
=== 1. Das "Magische Zahlenraten" Simulator ===
* '''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!".
 
=== 2. Text-Adventure: "Die Suche nach dem verlorenen Keks" ===
* '''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 ===
* '''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.
 
=== 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) ===
* '''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).
 
=== 6. Quiz-Master Console ===
* '''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.
 
=== 7. ASCII-Art Raketenbauer ===
* '''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.


'''3. Von 1 bis 10 zählen (for):'''
=== 8. Schere, Stein, Papier (Simuliert) ===
Perfekt, wenn du genau weißt, wie oft etwas passieren soll.
* '''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.  
<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>


=== 9. Der kleine Vokabeltrainer ===
* '''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.


== Projektbasiertes Lernen: 30 Mini-Projekte ==
=== 10. Ampel-Steuerung für eine Mega-City ===
Programmiere diese kleinen Aufgaben in eigenen <code>cargo new</code> Projekten, um super stark in Rust zu werden! So lernst du am schnellsten.
* '''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.


# '''Grüß-Maschine''': Drucke 3 Zeilen mit <code>println!</code>, die deine Eltern grüßen.
Viel Erfolg! Am Ende dieser zwei Wochen wirst du schon wie ein richtiger Programmierer denken. Bleib dran, mach Fehler und hab Spaß dabei!
# '''Variablen-Zaubertrick''': Erstelle eine <code>mut</code> Variable mit dem Wert 5. Verdopple sie im Code und gib das Ergebnis aus.
# '''Taschengeld-Rechner''': Lege zwei Variablen an (Geld von Oma, Geld von Opa). Addiere sie und lass den Computer das Ergebnis sprechen ausgeben.
# '''Hundejahre-Umrechner''': Speichere dein Alter in einer Variable und multipliziere es mit 7.
# '''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).''

Version vom 4. März 2026, 00:26 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 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!

Unsere Mission in den ersten zwei Wochen: Wir lernen die Werkzeuge kennen und schreiben unsere allerersten magischen Zeilen Code.

1. Installation und Setup — Packen wir unseren Werkzeugkasten!

Bevor ein Handwerker ein Baumhaus bauen kann, braucht er Hammer und Säge. Genauso brauchen wir als Entwickler unsere eigenen Werkzeuge.

Installation von `rustup`, `rustc` und `cargo`

Um Rust auf deinem Computer zu benutzen, brauchen wir einen magischen Installateur namens rustup.

  • rustup: Das ist der Helfer, der Rust auf deinen Computer holt.
  • 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 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: 

cargo new hallo_welt
cd hallo_welt
cargo run

Boom! Da steht „Hello, world!“ auf dem Bildschirm. Du hast gerade dein erstes Programm ausgeführt! 🥳

Einrichtung der IDE (VS Code)

Eine IDE ist dein Schreibtisch zum Programmieren. Wir empfehlen Visual Studio Code (VS Code).

  1. Lade dir VS Code aus dem Internet herunter.
  2. Öffne es und suche links nach "Erweiterungen" (Extensions) – das sind so kleine Bauklötze-Symbole.
  3. 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

Jetzt schauen wir uns an, woraus so ein Programm eigentlich besteht.

Variablen und Veränderbarkeit (`let`, `let mut`)

Eine Variable ist wie eine Kiste, auf die du einen Namen schreibst und etwas hineinlegst. 

fn main() {
    let alter = 10; // Eine Kiste namens "alter" mit der Zahl 10 drin.
    println!("Ich bin {} Jahre alt.", alter);
}

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! 

fn main() {
    let mut taschengeld = 5; // mut bedeutet: Wir dürfen die Kiste öffnen!
    taschengeld = 10; // Jetzt hast du mehr Taschengeld!
    println!("Ich habe {} Euro.", taschengeld);
}

Datentypen — Was passt in die Kiste?

Der Computer muss wissen, WAS in der Kiste ist. Eine Zahl? Ein Buchstabe? Ein ganzes Wort?

  • Integer (Zahlen ohne Komma): `let alter = 10;`
  • Float (Zahlen mit Komma - wichtig: Im Englischen nimmt man den Punkt!): `let groesse = 1.45;`
  • Booleans (Ja oder Nein / Wahr oder Falsch): `let mag_eis = true;`
  • Strings (Wörter und Sätze): `let name = "Thorsten";`

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. 

// Das ist eine Funktion, die "Wuff" sagt.
fn hund_bellen() {
    println!("Wuff! Wuff!");
}

fn main() {
    hund_bellen(); // Hier rufen wir die Maschine auf!
}

3. Kontrollstrukturen — Wer bestimmt hier den Weg?

Manchmal soll ein Programm Entscheidungen treffen. Wenn es regnet, nimm den Regenschirm. Wenn die Sonne scheint, nimm die Sonnenbrille.

Bedingungen (`if`, `else if`, `else`)

Mit `if` (wenn) und `else` (sonst) können wir dem Computer sagen, was er bei Entscheidungen tun soll. 

fn main() {
    let schoko_eis = true;

    if schoko_eis {
        println!("Oh lecker, Schokoeis!"); // Das wird gemacht, wenn schoko_eis "true" (wahr) ist.
    } else {
        println!("Ein anderes Eis ist auch okay."); // Das wird gemacht, wenn es nicht wahr ist.
    }
}

Schleifen (`loop`, `while`, `for`) — Immer wieder dasselbe!

Wenn du 10-mal "Hallo" sagen willst, musst du das nicht 10-mal hinschreiben. Dafür gibt es Schleifen!

  • `loop`: Macht etwas für immer, bis du mit `break` (abbrechen) Stopp sagst.
  • `while`: Macht etwas, *solange* eine Bedingung wahr ist (z.B. solange du noch Bonbons hast).
  • `for`: Zählt automatisch mit!
fn main() {
    // Zählt von 1 bis 5
    for zahl in 1..6 {
        println!("Zahl ist: {}", zahl);
    }
}

---

Praxisbezogenes Lernen: 50 Magische Mini-Projekte

Programmieren lernt man durchs Selbermachen! Hier sind 50 kleine Aufgaben für dich zum Üben. Setz die neuen Legosteine zusammen!

  1. Hallo-Welt-Roboter: Verändere dein Programm, sodass es "Hallo Meister!" sagt.
  2. Namensschild-Drucker: Erstelle eine Variable mit deinem Namen und gib aus: "Mein Name ist [Name]".
  3. Alter in Tagen: Multipliziere dein Alter mit 365, um herauszufinden, wie viele Tage du lebst (Tipp: `*` ist malnehmen).
  4. Lieblingsfarben-Zeiger: Drei Variablen mit Farben anlegen und kreativ auf dem Bildschirm ausdrucken.
  5. Einfacher Plus-Taschenrechner: Addiere Variablen `a = 10` und `b = 15`.
  6. Minus-Taschenrechner: Ziehe zwei Zahlen voneinander ab.
  7. Mal-Maschine: Multipliziere drei Variablen.
  8. Teilen-Trainer: Teile dein Taschengeld (als Float) durch 2 (Tipp: `/`).
  9. Satz-Zusammensetzer: Drucke mehrere Wörter aus Variablen in einem Satz.
  10. Mein erster Kommentar: Schreibe einen Code und beschreibe ihn in 3 Kommentarzeilen.
  11. Taschengeld-Update: Mache eine `mut` Variable, gib ihr 5 Euro, dann überschreibe sie mit 20 Euro. Drucke beides!
  12. Level-Up: Ein `mut` Level in einem Spiel, zähle 1 Level hoch (`level = level + 1`).
  13. Stimmungs-Bool: `let bin_froh = true;`. Drucke es aus.
  14. Eis-Prüfer: if-Abfrage: Wenn `bin_froh == true`, dann print "Yay!".
  15. Türsteher (Achterbahn): Erstelle `let groesse = 140;`. Wenn `groesse > 130`, dann "Darf fahren!", `else` "Leider noch zu klein."
  16. Passwort-Labyrinth: `let code = 1234;`. Prüfe, ob `code == 1234` ist.
  17. Ampel-Simulator: `let farbe = "Rot";`. `if` Rot -> "Stopp", `else if` Grün -> "Los!".
  18. Wetter-Prophet: Bestimme mit if-else, was du anziehst (Regen vs. Sonne).
  19. Schulnoten-Bewerter: Prüfe Noten 1 bis 6 und gib dazu passenden Text wie "Super!" oder "Oje." aus.
  20. Lieblingstier: Wenn Tier == "Hund", bellen, bei "Katze" miauen.
  21. Endlos-Bohrer: Nutze `loop { println!("Bohren..."); }` (Bohre endlos - breche mit Strg+C ab!).
  22. Zahlenschloss-Knacker: Zähle in einem `loop` eine `mut`-Variable hoch und stoppe bei 10 mit `break`.
  23. Raketen-Countdown: Mit einer `while`-Schleife von 10 herunterzählen, dann "Liftoff!".
  24. Stammgast-Prüfer: `while hungrig == true`, iss einen Keks (simuliert).
  25. Papagei-Programm: Sag 5 Mal "Hallo" in einer `for`-Schleife.
  26. Das Einmaleins: Zähle von 1..11 und multipliziere den Zähler mit 2 (2er Reihe).
  27. Zehner-Sprünge: Eine for-Schleife, die 10, 20, 30 ausgibt (Tipp: Multiplizieren).
  28. Glückszahl-Finder: Finde in einer Schleife deine Glückszahl und schreibe "GEFUNDEN!" (mit if und break).
  29. Ungerade Zahlen: Drucke nur ungerade Zahlen mit `if zahl % 2 != 0`.
  30. Erste eigene Funktion: Mach eine Funktion `sag_tschuess()`.
  31. Tierstimmen-Funktionen: Mach drei Funktionen: `hund()`, `katze()`, `kuh()`. Rufe alle in main auf.
  32. Quadratmaschine (Funktion): Mach eine Variablen-Rechnung in einer separaten Funktion.
  33. Wochentag-Anzeiger: Wenn Zahl = 1, dann Montag, usw.
  34. Guten-Morgen-Schleife: Sage einer Liste von 3 Leuten (mit drei prints in der Schleife) Guten Morgen.
  35. Hundejahre-Umrechner: Multipliziere dein Alter mit 7.
  36. Kilometer-in-Meter: Rechne 5 km in Meter (mal 1000) um.
  37. Pizza-Teiler: Wenn ich 8 Stücke habe und wir 3 Kinder sind, wie viel bleibt übrig? (Modulo `%`).
  38. Spardosen-Checker: if Taschengeld > Spiele-Preis? "Du kannst es kaufen!"
  39. Begrüßungs-Türsteher: Nutze `let name = "Dein Name";`. Wenn es dein Name ist, begrüße freundlich, sonst grimmig.
  40. Ping-Pong-Zähler: Eine `for`-Schleife. Bei geraden Zahlen "Ping", bei ungeraden "Pong".
  41. Wecker-Klingeln: Eine for-Schleife 1..4 mit "Klingeling!".
  42. Lebenspunkte-Trank: `mut hp = 50;` -> `hp = hp + 20;` Wenn > 100, setze auf 100.
  43. Geschwindigkeits-Blitzer: Schneller als 50 km/h? -> "Geknipst!".
  44. Magisches Viereck: Berechne den Flächeninhalt (Seite mal Seite).
  45. Würfel-Simulation (Manuell): Variablen für 3 Würfe. Zähle sie zusammen.
  46. Die Geheim-Naricht: Drucke Buchstaben einzeln aus.
  47. Bug-Fixer: Schreibe ein Programm, vergiss absichtlich ein Semikolon `;` und schau, wie nett der Cargo Compiler dir hilft!
  48. Der Zornige Chef: Eine Funktion `schreien()`, die alles großschreibt (simuliert über println).
  49. Kaffeemaschine: `let wasser_da = true; let kaffee_da = false;` if beides true -> "Kaffee machen", sonst Fehler.
  50. Tagebuch-Einleitung: Nutze Variablen für Datum und Wetter und schreibe die Startzeile deines Tagebuchs.


Strukturierung ins Top-Down-Lernen: 10 Große Projekte

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!

1. Das "Magische Zahlenraten" Simulator

  • 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!".

2. Text-Adventure: "Die Suche nach dem verlorenen Keks"

  • 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

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

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)

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

6. Quiz-Master Console

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

7. ASCII-Art Raketenbauer

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

8. Schere, Stein, Papier (Simuliert)

  • 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

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

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!

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=3285“