|
|
| 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!
| |
|
| |
|
| == 1. Installation und Einrichtung ==
| | Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen: |
| === Lernziele ===
| | * Installation und Einrichtung: |
| * Du weißt, was `rustup`, `rustc` und `cargo` sind. | | * `rustup`, `rustc` und `cargo`. |
| * Du kannst Rust auf deinem Computer installieren. | | * Ein „Hello World!“-Programm. |
| * Du kannst dein allererstes Programm (ein "Hello World!") schreiben und ausführen. | | * 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`). |
|
| |
|
| === Lektion ===
| | Erkläre alle Inhalte leicht verständlich für Programmieranfänger. |
| 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:'''
| | * Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer. |
| 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!
| | * Top-Down-Lernen: 20 große Projekte zu diesen Themen. |
| | * Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich. |
|
| |
|
| '''Dein erstes Programm: "Hello World!"'''
| |
| Lass uns Cargo benutzen, um ein neues Projekt zu starten:
| |
| <source lang="bash">
| |
| cargo new hallo_welt
| |
| cd hallo_welt
| |
| cargo run
| |
| </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!
| |
|
| |
|
| === Übungen ===
| | Ausgabe und Speicherung: |
| # Installiere Rust auf deinem Computer.
| | * Das Ergebnis soll auf thorsten.wiki gespeichert werden. |
| # Erstelle mit `cargo new` ein Projekt namens "mein_erstes_projekt".
| | * Das Ausgabeformat ist die MediaWiki-Syntax. |
| # Führe das Projekt mit `cargo run` aus.
| |
|
| |
|
| == 2. IDE-Einrichtung (Dein digitaler Schreibtisch) == | | ==Prompt== |
| === Lernziele ===
| | <pre> |
| * Du lernst, wie du "Visual Studio Code" (VS Code) einrichtest.
| |
| * Du installierst die Erweiterung "rust-analyzer", die dir beim Coden hilft.
| |
|
| |
|
| === Lektion ===
| | Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen: |
| Programmieren in einem einfachen Texteditor ist wie Malen ohne Pinsel. Wir benutzen '''Visual Studio Code (VS Code)'''. Das ist unser digitaler Schreibtisch.
| | * Installation und Einrichtung: |
| # Lade dir "VS Code" aus dem Internet herunter und installiere es.
| | * `rustup`, `rustc` und `cargo`. |
| # Öffne VS Code und klicke links auf die kleinen Quadrate (das sind die Erweiterungen).
| | * Ein „Hello World!“-Programm. |
| # Suche nach '''rust-analyzer''' und klicke auf "Installieren".
| | * IDE-Einrichtung (z. B. VS Code mit rust-analyzer). |
| Dieser kleine Spickzettel zeigt dir Fehler an, bevor sie passieren und hilft dir mit cleveren Vorschlägen!
| | * 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`). |
|
| |
|
| === Übungen ===
| | Erkläre alle Inhalte leicht verständlich für Programmieranfänger. |
| # Installiere VS Code.
| |
| # Installiere "rust-analyzer".
| |
| # Öffne dein Projekt "hallo_welt" in VS Code und schau, wie schön bunt der Code jetzt ist!
| |
|
| |
|
| == 3. Grundlegende Syntax ==
| | * Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer. |
| === Lernziele ===
| | * Top-Down-Lernen: 20 große Projekte zu diesen Themen. |
| * Du verstehst, wie man Werte in '''Variablen''' speichert. | | * Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich. |
| * 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.
| |
| <source lang="rust">
| |
| 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);
| |
| }
| |
| </source>
| |
|
| |
|
| === Lektion: Datentypen ===
| | Ausgabe und Speicherung: |
| Es gibt einfache Typen (Skalartypen) und zusammengesetzte Typen (Verbundtypen).
| | * Das Ergebnis soll auf thorsten.wiki gespeichert werden. |
| * '''Zahlen (Integer):''' Ganze Zahlen wie `5` oder `100` (`i32`, `u32`).
| | * Das Ausgabeformat ist die MediaWiki-Syntax. |
| * '''Kommazahlen (Float):''' Zahlen wie `3.14` (`f64`).
| | </pre> |
| * '''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.
| |
| <source lang="rust">
| |
| let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
| |
| let mein_array: [i32; 3] = [1, 2, 3];
| |
| </source>
| |
| | |
| === 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.
| |
| <source lang="rust">
| |
| // 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!
| |
| }
| |
| </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.
| |
| | |
| == 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!
| |
| <source lang="rust">
| |
| 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!");
| |
| }
| |
| }
| |
| </source>
| |
| | |
| === 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.
| |
| | |
| <source lang="rust">
| |
| fn main() {
| |
| // for-Schleife (zählt von 1 bis 3)
| |
| for zahl in 1..4 {
| |
| println!("Ich zähle: {}", zahl);
| |
| }
| |
| }
| |
| </source>
| |
| | |
| === Übungen ===
| |
| # Schreibe ein Programm, das mit `if` prüft, ob eine Zahl größer als 10 ist und dann eine Nachricht ausgibt.
| |
| # Nutze eine `for`-Schleife, um die Zahlen von 1 bis 5 auszudrucken.
| |
| | |
| | |
| == Projektbasiertes Lernen ==
| |
| | |
| === 75 Mini-Projekte für den schnellen Praxisbezug ===
| |
| Diese Mini-Projekte sind super kurz und fokussiert, damit du schnell Erfolgserlebnisse hast. Sie behandeln Variablen, Funktionen, Schleifen und If-Abfragen.
| |
| | |
| #Begrüßungs-Automat: Deklariere eine Variable mit deinem Namen und drucke 'Hallo, [Name]' aus.
| |
| #Variablen-Tausch: Lege zwei Variablen an und tausche ihre Werte.
| |
| #Münzwurf: Erstelle ein Programm, das zufällig 'Kopf' oder 'Zahl' als String in einer Variable speichert und ausgibt.
| |
| #Jahresrechner: Eine Variable hat dein Alter, gib dein Geburtsjahr aus.
| |
| #Temperatur-Umrechner (Celsius zu Fahrenheit): Rechne eine feste Variable um.
| |
| #Einfacher Taschenrechner (Addition): Eine Funktion, die zwei i32-Zahlen addiert.
| |
| #Einfacher Taschenrechner (Subtraktion): Eine Funktion, die zwei i32-Zahlen subtrahiert.
| |
| #Einfacher Taschenrechner (Multiplikation): Eine Funktion, die zwei i32-Zahlen multipliziert.
| |
| #Einfacher Taschenrechner (Division): Eine Funktion, die zwei i32-Zahlen dividiert.
| |
| #Gerade oder Ungerade?: Prüfe mit if/else und % 2, ob eine Zahl gerade ist.
| |
| #Notenbewerter: Gib zu einer Zahl von 1-6 ein Textfeedback aus.
| |
| #Schleifen-Zähler: Nutze eine for-Schleife, um von 1 bis 10 zu zählen.
| |
| #Raketen-Countdown: Nutze eine for-Schleife (10..1), gefolgt von 'Ignition!'.
| |
| #Passwort-Prüfer: Ein if/else Check eines String-Passwortes gegen ein festes 'geheim123'.
| |
| #Tage-in-Monat-Rechner: Ordne einem Monatsnamen (als String) die Anzahl der Tage per if/else zu.
| |
| #Schachtel-Verschachteler: Nutze ein if/else in einem if/else (Nested If).
| |
| #FizzBuzz Mini: Iteriere von 1 bis 20 und ersetze durch fizz/buzz.
| |
| #Die unendliche Schleife mit Ausweg: Ein loop {}, der bei counter == 5 mit break beendet wird.
| |
| #while-Schleifen-Zähler: Das Gleiche wie Projekt 12, aber mit while.
| |
| #Array-Lesezeichen: Lege ein Array mit 5 Buchtiteln an und drucke das dritte Buch.
| |
| #Tuple-Lieblinge: Erstelle ein Tupel (Farbe, Zahl, Essen) und greife auf die Zahl zu.
| |
| #Funktions-Grüßer: Übergib einen Namen als Argument an eine Funktion, die hallo sagt.
| |
| #Mutabilitäts-Test: Lege variable X an, ändere sie danach dreimal und gib sie nach jeder Änderung aus.
| |
| #Schleifen-Summe: Addiere die Zahlen von 1 bis 100 in einer Schleife.
| |
| #Der kleine Papagei: Eine Funktion, der du einen Text übergibst und die ihn 3x nacheinander ausdruckt.
| |
| #Schaltjahr-Prüfer: if/else, um zu checken, ob Variable 'jahr' ein Schaltjahr ist.
| |
| #Tier-Laute: Funktion, die einen Tiernamen nimmt und das passende Geräusch (Miauen, Bellen) printet.
| |
| #Einkaufslisten-Array: Lege 5 Dinge an und printe jedes Element mit einer for-Schleife aus.
| |
| #Schatten-Ninja (Shadowing): Überschreibe eine let-Variable neu (let my_var = 1; let my_var = 'zwei').
| |
| #Wochentag-Anzeige: Speichere 1-7 in einer Variable und gib den passenden Wochentag aus.
| |
| #Zahlen-Rater-Mock: 'if geraten_zahl == zielzeug' check (ohne echten Input).
| |
| #Zeichenzähler in Schleife: Printe ein '*' 1x, 2x, 3x mithilfe von String::repeat().
| |
| #Wetter-Bot: Array von Wetter-Zuständen, das zufällig ausgegeben wird.
| |
| #Das vergessene Semikolon: Erzeuge absichtlich einen Compiler-Fehler, fix ihn.
| |
| #Einrückungs-Korrektur: Nimm unformatierten Code und schiebe ihn durch 'cargo fmt'.
| |
| #Das Typ-Experiment: Erzwinge verschiedene Typen für x (f32, f64, i8, i16).
| |
| #Kino-Alterskontrolle: if/else ab 12, 16 oder 18 Jahren.
| |
| #Umfangrechner Skript: Länge und Breite berechnen Umfang.
| |
| #Flächenrechner: Länge mal Breite.
| |
| #ASCII-Kunst: Nutze println! für kleine ASCII-Bilder (Hund, Haus).
| |
| #Fahrkarten-Automat: Wenn genug Geld (Variable) da ist -> Ticket drucken, sonst Fehlbetrag nennen.
| |
| #Vokabel-Tupel: (Deutsch, Englisch) in Variablen und geordnet ausgeben.
| |
| #Mittelwert-Berechner: Array von 3 Zahlen nehmen und Mittelwert (Addition / 3) errechnen.
| |
| #Gefahren-Ampel: Rot, Gelb, Grün -> Ausgaben wie Stop, Warnung, Go.
| |
| #while_let Anfänge (Optional): Optionale Option<i32> ausprobieren.
| |
| #Rustup-Check-Skript: Nutze std::process::Command (oder print!), um zu zeigen, dass du verstanden hast, was rustc --version ausgibt.
| |
| #Die Cargo.toml betrachten: Füge im Kommentarfeld die Erklärung des Cargo Manifests ein.
| |
| #Konstanten-Macht: Deklariere eine const MWST: f64 = 0.19; und rechne damit.
| |
| #Kleines Textadventure (Raumbeschreibung): Nutze Funktionen für 3 Räume.
| |
| #Würfelspiel-Simulation (ohne Random): Fest programmierte Würfel-Ergebnisse addieren.
| |
| #Würfelspiel-Anzeige: Array von [1,2,3,4,5,6] -> durchlaufen.
| |
| #Kommentar-Kunstwerk: Ein Programm, wo jeder Schritt absolut überdokumentiert ist (zum Lernen!).
| |
| #Rostige Strings: Unterscheide &str und String::from() bei ein, zwei Zuweisungen.
| |
| #Namens-Kombinator: Vorname und Nachname (Strings) zusammenfügen.
| |
| #Rabatt-Rechner: Wenn Preis > 100, ziehe 10% ab.
| |
| #Dreiecks-Prüfer: Sind die Winkel zusammen 180 Grad?
| |
| #Zahlen-Muster: Drucke 1, 22, 333, 4444.
| |
| #Gedichte-Formatierer: Verwende \n für Zeilenumbrüche in einem Print.
| |
| #Cargo check - Speed: Mach einen Syntax-Fehler, nutze cargo check statt run.
| |
| #Zufalls_Platzhalter: Setze Kommentare 'TODO: Hier später random' in Code.
| |
| #Bmi-Rechner: Gewicht / (Größe*Größe).
| |
| #Geschwindigkeitsanzeige: km/h in mp/h umrechnen.
| |
| #E-Mail-Mockup-Macher: setze 'An', 'Von', 'Betreff' aus Variablen zusammen.
| |
| #Ressourcen-Planer: Array aus ['Holz', 'Stein', 'Gold'].
| |
| #Inventar-Liste (Tupel-Array): Menge und Name kombinieren.
| |
| #Beste-Freunde-Sucher: In einem Array schauen, ob Name x dabei ist.
| |
| #Kleiner Roboter-Timer: Nutze thread::sleep, um zu warten (optional).
| |
| #Schleifen-Continue: Zähle auf 10, bei 5 sagst du 'continue'.
| |
| #Schleifen-Break: Endet, wenn eine bestimmte Taste/Zahl erreicht ist.
| |
| #Verdeckte Variablen: Rufe dieselbe Funktion 5x auf.
| |
| #Tagebuch-Drucker: Printe Datum + Text-Variable.
| |
| #Rust-Maskottchen: Drucke Infos zu 'Ferris' der Krabbe.
| |
| #Versions-Checker: Gibt 1.0.0 als Variable an.
| |
| #Hello-World-Multi: Hello World in 5 Sprachen über If-Else.
| |
| #Debug-Print: Nutze {:?} statt {} bei Arrays.
| |
| | |
| === 20 Große Projekte (Top-Down-Lernen) ===
| |
| Bei diesen Projekten startest du mit der großen Vision (Top-Down) und nutzt dein neues Wissen aus den Modulen, um das Projekt nach und nach funktionsfähig zu machen.
| |
| | |
| #Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife ('Wie möchtest du gehen?').
| |
| #Taschenrechner mit Kommandozeile: Ein echtes Terminal-Tool, um Zahlen zu berechnen.
| |
| #Zahlenraten-Simulator: Ein komplexeres Rate-Spiel mit Feedback (wärmer, kälter) in einer Loop.
| |
| #Todo-Listen-Verwaltung (im Speicher): Ein Array mutabel halten und Aufgaben abhaken (ohne echten User-Input).
| |
| #Persönliches Haushaltsbuch (Mockup): Ein- und Ausgaben aus Arrays zusammenrechnen und bewerten.
| |
| #Schere, Stein, Papier - Automat: Zwei voreingestellte oder simulierte Spieler treten gegeneinander an.
| |
| #Vokabel-Trainer: Tupel abfragen, Zähler für richtige und falsche Antworten.
| |
| #Der Quiz-Master: 5 Fragen hintereinander via Terminal Output, mit Punkteauswertung.
| |
| #ASCII-Tamagotchi: Ein kleines Haustier, das Hunger-/Durst-/Müdigkeits-Variablen in einer Loop verändert.
| |
| #Wetterstation-Simulator: Durchschnittsberechnung aus großen Arrays von simulierten Temperaturdaten.
| |
| #Morsen-Übersetzer: Nutze if/else oder Arrays, um Buchstaben in Morsecode (Text) zu verwandeln.
| |
| #Ein einfacher Passwort-Generator (Mockup): Strings aus verschiedenen Zeichen zusammenfügen.
| |
| #Bankkonto-Simulation: Funktionen für einzahlen(), abheben() und kontostand().
| |
| #Pizzabestellung-System: Wähle Größe, Belag aus und berechne den Preis am Ende.
| |
| #Schatzsuche auf dem Raster: Ein 2D-Array als Spielfeld (Karte), laufe mit Koordinaten x,y.
| |
| #Lottozahlen-Checker: Gleiche eine Liste deiner getippten Zahlen mit einer simulierten Ziehung ab.
| |
| #Krimi-Dateien: Verwalte Verdächtige mit ihren Alibis und filtere über Schleifen.
| |
| #Zeiterfassungs-Helfer: Erfasse Stunden für fiktive Projekte und rechne Lohn aus.
| |
| #Das Geometrie-Genie: Ein Tool, das für jede abgefahrene Flächenform (Kreis, Zylinder) das Volumen als Sub-Funktionen nutzt.
| |
| #Das Cargo-Meisterwerk: Dein Abschlussprojekt – Erstelle mehrere Module (Dateien) in Cargo für ein mini RPG-Spiel.
| |
|
| |
|
| ---- | | ---- |
| ''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).'' |