Rust/Grundlagen: Unterschied zwischen den Versionen

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

Thorsten (Diskussion | Beiträge)

3 Benutzergruppen
69 Bearbeitungen
VisuellWikitext
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
 
(8 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 in der spannenden Welt von Rust! Stell dir vor, du bist ein Erfinder, und dein Computer ist eine riesige Werkstatt. Rust ist dein cooles, neues Werkzeug, mit dem du super schnelle und sichere Maschinen (also Programme!) bauen kannst.  
== 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 Lernpfad schauen wir uns an, wie du dieses Werkzeug benutzt. Wir machen viele kleine, spannende Projekte und mischen die Themen gut durch (das nennt man "Interleaving"), damit dein Gehirn immer wieder neu herausgefordert wird und du dir alles besser merken kannst! Wir fangen ganz unten bei den einfachen Dingen an und bauen darauf auf ("Bottom-Up").
=== 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.  


== Ziel: Verstehe die Bausteine von Rust! ==
'''So installierst du Rust:'''
Wir werden lernen, wie Rust denkt und funktioniert. Am Ende kannst du deinem Computer Befehle geben und eigene kleine Programme schreiben!
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!


== Modul 1: Deine Werkstatt einrichten (Installation & Setup) ==
'''Dein erstes Programm: "Hello World!"'''
Bevor wir bauen können, müssen wir unsere Werkstatt vorbereiten!
Lass uns Cargo benutzen, um ein neues Projekt zu starten:
 
=== 1. Installation: `rustup`, `rustc` und `cargo` ===
Um Rust zu sprechen, brauchen wir drei wichtige Helferlein:
* '''`rustup`''': Das ist der Werkstatt-Manager. Er holt dir immer die neuesten Werkzeuge.
* '''`rustc`''': Das ist der Übersetzer. Er übersetzt das, was du schreibst, in eine Sprache, die der Computer versteht (Maschinensprache).
* '''`cargo`''': Das ist dein Roboter-Assistent! Er baut deine Programme zusammen, packt sie ein und hilft dir beim Aufräumen.
 
'''So geht's auf dem Computer:'''
Wenn du unter Linux oder macOS arbeitest, tippst du folgendes in ein schwarzes Fenster, das sich Terminal nennt:
<source lang="bash">
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
</source>
Das sieht ein bisschen wie ein Zauberspruch aus, oder? Dieser Befehl holt die Helfer auf deinen Computer.
 
=== 2. Dein erstes Programm: „Hello World!“ ===
Lassen wir deinen Computer "Hallo Welt!" sagen! Rust freut sich nämlich, dich kennenzulernen.
Öffne das Terminal und gib diesen Befehl ein (denk daran: Cargo ist dein Roboter-Assistent!):
<source lang="bash">
<source lang="bash">
cargo new hallo_welt
cargo new hallo_welt
cd hallo_welt
cd hallo_welt
cargo run
</source>
</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!


Wenn du jetzt eine Datei namens `main.rs` (in deinem neuen Ordner `src`) öffnest, solltest du diesen Code sehen:
=== Übungen ===
<source lang="rust">
# Installiere Rust auf deinem Computer.
fn main() {
# Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
    println!("Hello, world!");
# Führe das Projekt mit `cargo run` aus.
}
</source>
* `fn main()` bedeutet: "Hier fangen wir an!". `fn` steht für Funktion – das ist ein Block aus Befehlen.
* `println!` bedeutet: "Drucke eine Zeile (print line) Text auf den Bildschirm". Das `!` zeigt, dass das ein besonderer Taschenspielertrick in Rust ist (man nennt das ein "Makro").


Tippe jetzt in dein Terminal:
== 2. IDE-Einrichtung (Dein digitaler Schreibtisch) ==
<source lang="bash">
=== Lernziele ===
cargo run
* Du lernst, wie du "Visual Studio Code" (VS Code) einrichtest.
</source>
* Du installierst die Erweiterung "rust-analyzer", die dir beim Coden hilft.
Und tada! Der Computer sagt "Hello, world!" zu dir!


=== 3. Dein Schreibtisch: IDE (z.B. VS Code) einrichten ===
=== Lektion ===
Du kannst deinen Code nicht einfach auf einen Schmierzettel schreiben. Es gibt tolle Programme dafür. Ein beliebtes Programm heißt '''Visual Studio Code''' (kurz: VS Code). Das ist wie ein super schlaues Notizbuch.
Programmieren in einem einfachen Texteditor ist wie Malen ohne Pinsel. Wir benutzen '''Visual Studio Code (VS Code)'''. Das ist unser digitaler Schreibtisch.
Wenn du VS Code installiert hast, lade dir die Erweiterung (ein kleines Extra-Werkzeug) namens '''"rust-analyzer"''' herunter. Er ist wie ein kluger Lehrer, der dir rote Striche zeigt, wenn du dich vertippst, und dir tolle Tipps gibt.
# 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!


== Modul 2: Die ersten Bausteine (Grundlegende Syntax) ==
=== Ü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!


=== 1. Kisten für Notizen: Variablen (`let`, `let mut`) ===
== 3. Grundlegende Syntax ==
Stell dir vor, du hast eine Kiste. In diese Kiste kannst du etwas reinlegen. Das nennt man in Rust eine "Variable".
=== Lernziele ===
Um eine Kiste zu machen, sagen wir `let`:
* Du verstehst, wie man Werte in '''Variablen''' speichert.
<source lang="rust">
* Du lernst den Unterschied zwischen statischen (`let`) und veränderbaren (`let mut`) Dingen.
fn main() {
* Du lernst Zahlen, Texte und mehrypen kennen.
    let alter = 10; // Wir erstellen eine Kiste "alter" und legen die 10 rein.
* Du weißt, wie man eigene '''Funktionen''' schreibt und '''Kommentare''' hinterlässt.
    println!("Ich bin {} Jahre alt.", alter); // Die {} machen Platz für unsere Zahl!
}
</source>


'''Achtung!''' In Rust sind Kisten normalerweise fest zugeklebt! Wenn du `let alter = 10;` machst, kannst du danach `alter` NICHT mehr auf 11 ändern.
=== Lektion: Variablen und Mutabilität ===
Wenn du eine Kiste haben willst, bei der du das, was drinnen ist, später austauschen darfst, musst du `mut` (wie mutabel oder veränderbar) dazu schreiben!
Stell dir eine Variable wie eine Kiste vor, in die du etwas hineinlegst.
<source lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let mut taschengeld = 5; // mut bedeutet: Ich darf den Wert ändern!
     let name = "Thorsten"; // Das ist eine unveränderliche Kiste!
     println!("Ich habe {} Euro.", taschengeld);
     // name = "Peter"; // Das würde einen Fehler geben, der Name ist fest.
      
      
     taschengeld = 10; // Jetzt habe ich mehr bekommen!
     let mut alter = 10; // "mut" steht für "mutable" (veränderbar).
     println!("Juhu, jetzt habe ich {} Euro!", taschengeld);
    alter = 11; // Jetzt hat er Geburtstag gehabt!
   
     println!("Hallo {}, du bist {} Jahre alt.", name, alter);
}
}
</source>
</source>


=== 2. Verschiedene Dinge aufbewahren: Datentypen ===
=== Lektion: Datentypen ===
Es gibt nicht nur Zahlen! In deine Kisten passen verschiedene Dinge:
Es gibt einfache Typen (Skalartypen) und zusammengesetzte Typen (Verbundtypen).
* '''Ganze Zahlen (Integer)''': z.B. `10`, `42`, `-5`.  
* '''Zahlen (Integer):''' Ganze Zahlen wie `5` oder `100` (`i32`, `u32`).
* '''Kommazahlen (Float)''': z.B. `3.14` oder `2.5`.
* '''Kommazahlen (Float):''' Zahlen wie `3.14` (`f64`).
* '''Wahrheitswerte (Booleans)''': Das kann nur `true` (Wahr) oder `false` (Falsch) sein. Perfekt, um zu prüfen, ob das Licht an ist!
* '''Wahrheitswerte (Boolean):''' `true` (richtig) oder `false` (falsch) (`bool`).
* '''Buchstaben und Wörter (Char und String)''': Ein einzelner Buchstabe ist ein 'A', ein ganzer Text ist "Hallo!".
* '''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.
<source lang="rust">
<source lang="rust">
fn main() {
let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
    let note = 1;              // Eine ganze Zahl
let mein_array: [i32; 3] = [1, 2, 3];
    let gewicht = 35.5;        // Eine Kommazahl
    let ist_es_tag = true;      // Boolean (Wahr)
    let anfangsbuchstabe = 'T'; // Ein Zeichen in einfachen Anführungszeichen
    let name = "Thorsten";     // Ein Text in doppelten Anführungszeichen
}
</source>
</source>


Manchmal packt man auch Dinge zusammen!
=== Lektion: Funktionen und Kommentare ===
* '''Tupel''': Ein Regalbrett mit festen Dingen, z.B. deine Lieblingsfarbe und deine Glückszahl. `let mein_tupel = ("Blau", 7);`
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.
* '''Array''': Eine Liste von mehreren Dingen, die aber alle vom gleichen Typ sein müssen. `let meine_noten = [1, 2, 1, 3];`
 
=== 3. Mini-Fabriken: Funktionen ===
Wenn du denselben Code oft brauchst, kannst du ihn verpacken. Das ist eine Funktion. Die `main()`-Funktion kennst du schon!
Lass uns eine Fabrik bauen, die immer "Guten Morgen" sagt und den Namen dazu:
<source lang="rust">
<source lang="rust">
// Hier ist unsere neue Fabrik!
// Das ist eine Funktion, die "Hallo" sagt
fn sage_hallo(name: &str) {
fn sag_hallo() {
     println!("Guten Morgen, {}!", name);
     println!("Hallo von der Funktion!");
}
}


fn main() {
fn main() {
     sage_hallo("Lukas"); // Wir rufen die Fabrik auf und geben ihr den Namen.
     sag_hallo(); // Hier rufen wir unser Rezept auf!
    sage_hallo("Mia");
}
}
</source>
</source>


* '''Kommentare''': Manchmal möchtest du dir was notieren, das der Computer ignorieren soll. Mach einfach `//`. Alles danach in der Zeile ist für dich!
=== Ü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.


== Modul 3: Der Verkehrspolizist (Kontrollstrukturen) ==
== 4. Kontrollstrukturen ==
Ein Programm muss auch Entscheidungen treffen können!
=== Lernziele ===
* Bringe dem Programm bei, Entscheidungen zu treffen (`if`, `else`).
* Wiederhole Dinge automatisch mithilfe von '''Schleifen''' (`loop`, `while`, `for`).


=== 1. Wenn dies, dann das: `if`, `else if`, `else` ===
=== Lektion: Wenn-Dann (if / else if / else) ===
Stell dir vor, du stehst vor einer Ampel.
Dein Programm soll schlau sein!
<source lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let ampel = "Rot";
     let wetter = "Regen";


     if ampel == "Grün" {
     if wetter == "Regen" {
        // Wenn Grün, dann gehen.
         println!("Nimm einen Regenschirm mit!");
         println!("Du darfst über die Straße gehen!");
     } else if wetter == "Schnee" {
     } else if ampel == "Rot" {
         println!("Zieh warme Stiefel an!");
        // Oder wenn Rot, dann stehen bleiben.
         println!("Halt! Warten!");
     } else {
     } else {
        // Sonst (zum Beispiel wenn sie aus ist).
         println!("Zieh ein T-Shirt an!");
         println!("Pass gut auf!");
     }
     }
}
}
</source>
</source>
Das ist ein Wegweiser für dein Programm!
Analyzed
~/Übungen

Thought for 118s


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


Edited

thorsten.wiki
+448
-0

Thought for 2s
=== 2. Immer wieder: Schleifen (`loop`, `while`, `for`) ===
Manchmal möchtest du Dinge wiederholen, ohne sie tausendmal zu tippen.
* Die Endlos-Schleife (`loop`): Das ist wie ein Hamsterrad, es dreht sich immer weiter, bis du "Stopp!" (`break`) rufst!
<source lang="rust">
<source lang="rust">
fn main() {
fn main() {
     let mut zähler = 0;
     // for-Schleife (zählt von 1 bis 3)
    loop {
        zähler = zähler + 1;
        println!("Wir sind bei {}!", zähler);
        if zähler == 3 {
            println!("Genug gedreht!");
            break; // Hier springen wir aus der Schleife raus
        }
    }
}
</source>
 
* Solange etwas stimmt (`while`): Wiederhole etwas, ''solange'' eine Bedingung wahr ist.
<source lang="rust">
fn main() {
    let mut kekse = 3;
    while kekse > 0 {
        println!("Ich esse einen Keks! Übrig sind: {}", kekse);
        kekse = kekse - 1; // Ein Keks ist weg!
    }
    println!("Alle Kekse aufgegessen!");
}
</source>
 
* Für jedes Stück (`for`): Perfekt, um eine Liste oder einen bestimmten Zeitraum durchzugehen.
<source lang="rust">
fn main() {
    // 1..4 bedeutet die Zahlen 1, 2 und 3 (die 4 ist nicht dabei!)
     for zahl in 1..4 {
     for zahl in 1..4 {
         println!("Countdown: {}", zahl);
         println!("Ich zähle: {}", zahl);
     }
     }
    println!("Los geht's!");
}
}
</source>
</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.


== Praxis-Projekte: Werde zum Meister-Erfinder! ==
Hier mischen wir alles (Interleaving!). Versuche, diese Projekte selber in VS Code zu schreiben!
'''Projekt 1: Der Taschengeld-Rechner'''
* Was es tun soll: Lege fest, wie viel Taschengeld du pro Monat bekommst (z.B. `let pro_monat = 20;`). Berechne dann, wie viel du in einem ganzen Jahr (12 Monate) bekommst! Gib das Ergebnis mit `println!` aus.
'''Projekt 2: Der Geheimtür-Wächter'''
* Was es tun soll: Lege ein Passwort fest `let geheimes_passwort = "Apfelsaft";`. Benutze dann eine `if`-Abfrage! Teste, ob jemand das richtige Passwort hat. Wenn ja, schreibe "Tür öffnet sich". Wenn nein, schreibe "Alarm!!!".
'''Projekt 3: Der Raketen-Start! (Countdown)'''
* Was es tun soll: Schreibe ein Programm, das von 10 herunterzählt bis 1! Nutze dafür am besten eine `while`-Schleife. Wenn es bei 0 ist, soll der Computer "Rakete startet! Wuuuuuuusch!" auf den Bildschirm schreiben.
'''Projekt 4: Der Temperatur-Bewerter'''
* Was es tun soll: Lege als Variable (Typ: ganze Zahl) das aktuelle Wetter in Grad Celsius fest. Wenn es über 25 Grad hat, schreibe "Lass uns Eis essen!". Unter 10 Grad "Zieh eine Jacke an!". Dazwischen "Perfektes Spielwetter!". Nutze dafür `if` und `else if`.
'''Projekt 5: Einmaleins-Trainer (Bottom-Up Aufgabe)'''
* Was es tun soll: Schreibe eine `for`-Schleife, die dir die 7er-Reihe aufschreibt: 7, 14, 21 ... bis 70.
* Extra schwer: Schreib das so, dass du die Zahl, z.B. die 7, nur oben in eine Variable packst (`let reihe = 7;`).
== 🧠 Großes Rust-Quiz 🧠 ==
Teste jetzt dein neues Wissen aus dem Lernpfad!
<quiz display=simple>
{Rust-Wissenstest 1: Vervollständige die Lücken
|type="{}"}
Um einen veränderbaren Wert in Rust zu speichern, schreibst du nach "let" das Wort { mut _3 }.
Damit der Computer deinen Text auf den Bildschirm malt, benutzt du { println! _8 }("Hallo!").
Der Befehl in der Konsole, der ein neues Bauprojekt erstellt, fängt an mit { cargo _5 } new mein_projekt.
Die Abkürzung für eine Funktion heisst { fn _2 } und die Hauptfunktion, in der dein Programm immer startet, nennt sich { main _4 }.
</quiz>
<quiz display=simple>
{Rust-Wissenstest 2: Datentypen und Variablen
|type="{}"}
Um eine Kommazahl wie 3.5 abzuspeichern, verwendet Rust den Typ { Float _5 } (Gleitkommazahl).
Wahrheitswerte wie "true" und "false" nennt man auch { Booleans _8 }.
Um eine Schleife zu bauen, die FÜR jede Zahl von 1 bis 10 durchläuft, nutzen wir das { for _3 }-Schlüsselwort.
Mit einem doppelten { // _2 } sagst du Rust, dass du dir eine Notiz gemacht hast (Kommentar). Das Programm überspringt das einfach.
Eine unendliche Schleife kannst du durch den Befehl { break _5 } beenden.
</quiz>
<quiz display=simple>
{Rust-Wissenstest 3: Vervollständige das Hallo-Welt Programm
|type="{}"}
fn { main _4 }() {
    println!("Hello, { world _5 }!");
}
</quiz>


<quiz display=simple>
== Projektbasiertes Lernen ==
{Rust-Wissenstest 4: Vervollständige die Variable
|type="{}"}
Um sicherzustellen, dass sich der Wert nicht ändert:
{ let _3 } alter = 10;
Um den Wert später noch ändern zu können:
let { mut _3 } guthaben = 5;
guthaben = 10;
</quiz>


<quiz display=simple>
=== 75 Mini-Projekte für den schnellen Praxisbezug ===
{Rust-Wissenstest 5: Vervollständige die If-Abfrage
Diese Mini-Projekte sind super kurz und fokussiert, damit du schnell Erfolgserlebnisse hast. Sie behandeln Variablen, Funktionen, Schleifen und If-Abfragen.
|type="{}"}
let hunger = true;
{ if _2 } hunger == true {
    println!("Lass uns Kuchen essen!");
} { else _4 } {
    println!("Ich bin satt!");
}
</quiz>


<quiz display=simple>
#Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
{Rust-Wissenstest 6: Vervollständige die Loop-Schleife
#Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
|type="{}"}
#Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
let mut runden = 0;
#Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
{ loop _4 } {
#Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
    runden = runden + 1;
#Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
    if runden == 3 {
#Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
        { break _5 };
#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.
</quiz>
#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.


<quiz display=simple>
=== 20 Große Projekte (Top-Down-Lernen) ===
{Rust-Wissenstest 7: Vervollständige die For-Schleife
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.
|type="{}"}
// Wir zählen von 1 bis 5 (ohne 6)
{ for _3 } zahl in 1..6 {
    println!("Zahl: {}", { zahl _4 });
}
</quiz>


<quiz display=simple>
#Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife ('Wie möchtest du gehen?').
{Rust-Wissenstest 8: Funktionen
#Taschenrechner mit Kommandozeile: Ein echtes Terminal-Tool, um Zahlen zu berechnen.
|type="{}"}
#Zahlenraten-Simulator: Ein komplexeres Rate-Spiel mit Feedback (wärmer, kälter) in einer Loop.
Vervollständige den Aufbau einer neuen Funktion, die "winken" heißt.
#Todo-Listen-Verwaltung (im Speicher): Ein Array mutabel halten und Aufgaben abhaken (ohne echten User-Input).
{ fn _2 } winken() {
#Persönliches Haushaltsbuch (Mockup): Ein- und Ausgaben aus Arrays zusammenrechnen und bewerten.
    println!("*Winkt*");
#Schere, Stein, Papier - Automat: Zwei voreingestellte oder simulierte Spieler treten gegeneinander an.
}
#Vokabel-Trainer: Tupel abfragen, Zähler für richtige und falsche Antworten.
Um die Funktion auszuführen, schreibst du in der main() einfach { winken(); _9 }
#Der Quiz-Master: 5 Fragen hintereinander via Terminal Output, mit Punkteauswertung.
</quiz>
#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.


<quiz display=simple>
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
{Rust-Wissenstest 9: Toolchain
* Installation und Einrichtung:
|type="{}"}
  * `rustup`, `rustc` und `cargo`.
Das Programm, das deinen Rust-Code "übersetzt", heißt { rustc _5 } .  
  * Ein „Hello World!“-Programm.
Das Programm, von dem man seine Bibliothek an Tools bekommt, also den Installer, nennt man { rustup _6 } .  
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
Ein "cargo { run _3 }" startet in der Konsole das fertig gebaute Programm.
* Grundlegende Syntax:
</quiz>
  * Variablen und Mutabilität (`let`, `let mut`).
  * Datentypen (Skalar- und Verbundtypen).
  * Funktionen und Kommentare.
* Kontrollstrukturen:
  * `if`, `else if`, `else`.
  * Schleifen (`loop`, `while`, `for`).


<quiz display=simple>
Erkläre alle Inhalte leicht verständlich für Programmieranfänger.
{Rust-Wissenstest 10: Array und Tupel
|type="{}"}
Sollen verschiedene Werte, wie eine Note von der Schule (Zahl) und dein Name (Wort) eng zusammen stehen, verpackst du sie am geschicktesten in ein { Tupel _5 }.  
Möchtest du eine Liste von lauter gleichen Dingen, zum Beispiel fünf T-Shirts speichern, benutzt du am besten ein { Array _5 }.
</quiz>


<quiz display=simple>
* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
{Rust-Wissenstest 11: While-Schleife
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
|type="{}"}
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.
let mut wasser = 5;
{ while _5 } wasser > 0 {
    println!("Schluck trinken!");
    wasser = wasser - 1;
}
</quiz>


<quiz display=simple>
{Rust-Wissenstest 12: Fehler finden
|type="{}"}
Warum funktioniert der folgende Code nicht?
let hund = "Bello";
hund = "Wuffi";
Weil vor "hund" in der ersten Zeile das Wort { mut _3 } fehlt!
</quiz>


<quiz display=simple>
Ausgabe und Speicherung:
{Rust-Wissenstest 13: IDE und Editor
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
|type="{}"}
* Das Ausgabeformat ist die MediaWiki-Syntax.
Die intelligente Hilfe für VS Code, die Fehler beim Tippen direkt unterstreicht und das Leben eines Rust-Programmierers extrem vereinfacht, heißt rust-{ analyzer _8 } .
</quiz>


<quiz display=simple>
==Prompt==
{Rust-Wissenstest 14: Konsolen-Befehl
<pre>
|type="{}"}
Wenn ich ein neues Projekt machen möchte, das "Spiel" heisst, welche beiden Wörter schreibe ich am Anfang in meiner Konsole?
{ cargo new _9 } Spiel
</quiz>


<quiz display=simple>
Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
{Rust-Wissenstest 15: If-Else-If
* Installation und Einrichtung:
|type="{}"}
  * `rustup`, `rustc` und `cargo`.
let alter = 10;
  * Ein „Hello World!“-Programm.
if alter < 6 {
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
    println!("Kindergarten");
* Grundlegende Syntax:
} else { if _2 } alter < 11 {
  * Variablen und Mutabilität (`let`, `let mut`).
    println!("Grundschule");
  * Datentypen (Skalar- und Verbundtypen).
} else {
  * Funktionen und Kommentare.
    println!("Weiterführende Schule");
* Kontrollstrukturen:
}
  * `if`, `else if`, `else`.
</quiz>
  * Schleifen (`loop`, `while`, `for`).


<quiz display=simple>
Erkläre alle Inhalte leicht verständlich für Programmieranfänger.
{Rust-Wissenstest 16: Code-Block Klammern
|type="{}"}
Eine Funktion braucht für ihren Code immer diese runden, gebogenen Klammern.
Das sind { geschweifte _11 } Klammern. Auf der Tastatur tippt man "{" und "}".
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 17: Variablen überschreiben
|type="{}"}
let mut kekse = 2;
kekse = 5;
Welche Zahl ist nun in der Kiste gespeichert? Es ist die { 5 _1 }.
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 18: Platzhalter für Ausgaben
|type="{}"}
let name = "Fritz";
println!("Hallo, {}!", name);
Die beiden Zeichen { {} _2 } sagen dem Programm, dass dort etwas eingefügt wird.
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 19: Das Ausrufezeichen bei Print
|type="{}"}
Ein "Makro" im Rust-Code wie "println" erkennt man immer sofort an einem speziellen Satzzeichen!
Vor der runden Klammer steht immer ein { Ausrufezeichen _13 }.
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 20: Rechnen mit Plus
|type="{}"}
In Rust kann man rechnen wie auf dem Papier!
let ergebnis = 5 { + _1 } 3;
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 21: Rechnen mit Mal
|type="{}"}
Und Malnehmen?
let pfoten = 4 { * _1 } 2; // Dafür nimmt man ein Sternchen!
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 22: Boolean
|type="{}"}
Welcher Datentyp bist du?
`false` ist vom Typ { Boolean _7 }
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 23: Integer
|type="{}"}
Welcher Datentyp bist du?
`42` ist vom Typ { Integer _7 } (ganze Zahl)
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 24: String
|type="{}"}
Welcher Datentyp bist du?
`"Hallo"` ist vom Typ { String _6 } (Text)
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 25: Char
|type="{}"}
Welcher Datentyp bist du?
`'b'` ist vom Typ { Char _4 } (nur ein Zeichen)
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 26: Ist gleich Zeichen
|type="{}"}
Wenn ein "if" kontrolliert, ob zwei Zahlen GLEICH sind, benutzt er ein Doppel-Gleichzeichen:
if runden { == _2 } 5 {
  println!("Fünf Runden um!");
}
</quiz>
 
<quiz display=simple>
{Rust-Wissenstest 27: For-Schleifen Zähler
|type="{}"}
for zahl in 1.. { 4 _1 } {
  println!("{}", zahl); // Zeigt 1, 2 und 3 an, aber nicht das Maximum!
}
</quiz>


<quiz display=simple>
* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
{Rust-Wissenstest 28: Projektbasiertes Lernen
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
|type="{}"}
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.
Wenn man durch ein eigenes kleines Projekt, etwa ein Mini-Spiel, am besten lernt, ist man im { projektbasierten _16 } Lernen.
</quiz>


<quiz display=simple>
{Rust-Wissenstest 29: Interleaving Ansatz
|type="{}"}
Man lernt besser, wenn man Themen durcheinander mischt. Diese Methode nennt man { Interleaving _12 } .
</quiz>


<quiz display=simple>
Ausgabe und Speicherung:
{Rust-Wissenstest 30: Bottom-Up Ansatz
* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
|type="{}"}
* Das Ausgabeformat ist die MediaWiki-Syntax.
Das schrittweise Aufbauen von einfachen zu komplexen Teilen (von unten nach oben) nennt man den { Bottom-Up _9 } Ansatz!
</pre>
</quiz>


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