imported>Import: Version 232

2026-03-04T04:35:02Z

Version 232

Neue Seite

''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 [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!

'''Dein erstes Programm: “Hello World!”''' Lass uns Cargo benutzen, um ein neues Projekt zu starten:

<syntaxhighlight lang="bash">cargo new hallo_welt
cd hallo_welt
cargo run</syntaxhighlight>
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 ===

# Installiere Rust auf deinem Computer.
# Erstelle mit `cargo new` ein Projekt namens “mein_erstes_projekt”.
# 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.

# Lade dir “VS Code” aus dem Internet herunter und installiere es.
# Öffne VS Code und klicke links auf die kleinen Quadrate (das sind die Erweiterungen).
# Suche nach '''rust-analyzer''' und klicke auf “Installieren”.

Dieser kleine Spickzettel zeigt dir Fehler an, bevor sie passieren und hilft dir mit cleveren Vorschlägen!

=== Übungen ===

# Installiere VS Code.
# Installiere “rust-analyzer”.
# Öffne dein Projekt “hallo_welt” in VS Code und schau, wie schön bunt der Code jetzt ist!

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

<syntaxhighlight 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);
}</syntaxhighlight>
=== 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.

<syntaxhighlight lang="rust">let mein_tupel: (i32, f64, char) = (500, 6.4, 'Z');
let mein_array: [i32; 3] = [1, 2, 3];</syntaxhighlight>
=== 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.

<syntaxhighlight 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!
}</syntaxhighlight>
=== Ü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!

<syntaxhighlight 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!");
}
}</syntaxhighlight>
=== 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.

<syntaxhighlight lang="rust">fn main() {
// for-Schleife (zählt von 1 bis 3)
for zahl in 1..4 {
println!("Ich zähle: {}", zahl);
}
}</syntaxhighlight>
=== Ü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 für Zeilenumbrüche in einem Print.
# Cargo check - Speed: Mach einen Syntax-Fehler, nutze cargo check statt run.
# Zufalls_Platzhalter: Setze Kommentare ‘TODO: Hier später random’ in Code.
# Bmi-Rechner: Gewicht / (Größe*Größe).
# Geschwindigkeitsanzeige: km/h in mp/h umrechnen.
# E-Mail-Mockup-Macher: setze ‘An’, ‘Von’, ‘Betreff’ aus Variablen zusammen.
# Ressourcen-Planer: Array aus [‘Holz’, ‘Stein’, ‘Gold’].
# Inventar-Liste (Tupel-Array): Menge und Name kombinieren.
# Beste-Freunde-Sucher: In einem Array schauen, ob Name x dabei ist.
# Kleiner Roboter-Timer: Nutze thread::sleep, um zu warten (optional).
# Schleifen-Continue: Zähle auf 10, bei 5 sagst du ‘continue’.
# Schleifen-Break: Endet, wenn eine bestimmte Taste/Zahl erreicht ist.
# Verdeckte Variablen: Rufe dieselbe Funktion 5x auf.
# Tagebuch-Drucker: Printe Datum + Text-Variable.
# Rust-Maskottchen: Drucke Infos zu ‘Ferris’ der Krabbe.
# Versions-Checker: Gibt 1.0.0 als Variable an.
# Hello-World-Multi: Hello World in 5 Sprachen über If-Else.
# Debug-Print: Nutze {:?} statt {} bei Arrays.

=== 20 Große Projekte (Top-Down-Lernen) ===

Bei diesen Projekten startest du mit der großen Vision (Top-Down) und nutzt dein neues Wissen aus den Modulen, um das Projekt nach und nach funktionsfähig zu machen.

# Das eigene Textadventure (Level 1): Baue ein Spiel mit verschiedenen Räumen und einer Schleife (‘Wie möchtest du gehen?’).
# Taschenrechner mit Kommandozeile: Ein echtes Terminal-Tool, um Zahlen zu berechnen.
# Zahlenraten-Simulator: Ein komplexeres Rate-Spiel mit Feedback (wärmer, kälter) in einer Loop.
# Todo-Listen-Verwaltung (im Speicher): Ein Array mutabel halten und Aufgaben abhaken (ohne echten User-Input).
# Persönliches Haushaltsbuch (Mockup): Ein- und Ausgaben aus Arrays zusammenrechnen und bewerten.
# Schere, Stein, Papier - Automat: Zwei voreingestellte oder simulierte Spieler treten gegeneinander an.
# Vokabel-Trainer: Tupel abfragen, Zähler für richtige und falsche Antworten.
# Der Quiz-Master: 5 Fragen hintereinander via Terminal Output, mit Punkteauswertung.
# ASCII-Tamagotchi: Ein kleines Haustier, das Hunger-/Durst-/Müdigkeits-Variablen in einer Loop verändert.
# Wetterstation-Simulator: Durchschnittsberechnung aus großen Arrays von simulierten Temperaturdaten.
# Morsen-Übersetzer: Nutze if/else oder Arrays, um Buchstaben in Morsecode (Text) zu verwandeln.
# Ein einfacher Passwort-Generator (Mockup): Strings aus verschiedenen Zeichen zusammenfügen.
# Bankkonto-Simulation: Funktionen für einzahlen(), abheben() und kontostand().
# Pizzabestellung-System: Wähle Größe, Belag aus und berechne den Preis am Ende.
# Schatzsuche auf dem Raster: Ein 2D-Array als Spielfeld (Karte), laufe mit Koordinaten x,y.
# Lottozahlen-Checker: Gleiche eine Liste deiner getippten Zahlen mit einer simulierten Ziehung ab.
# Krimi-Dateien: Verwalte Verdächtige mit ihren Alibis und filtere über Schleifen.
# Zeiterfassungs-Helfer: Erfasse Stunden für fiktive Projekte und rechne Lohn aus.
# Das Geometrie-Genie: Ein Tool, das für jede abgefahrene Flächenform (Kreis, Zylinder) das Volumen als Sub-Funktionen nutzt.
# Das Cargo-Meisterwerk: Dein Abschlussprojekt – Erstelle mehrere Module (Dateien) in Cargo für ein mini RPG-Spiel.

Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:

* Installation und Einrichtung:

<code> * `rustup`, `rustc` und `cargo`.</code><br />
<code> * Ein „Hello World!“-Programm.</code>

* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
* Grundlegende Syntax:

<code> * Variablen und Mutabilität (`let`, `let mut`).</code><br />
<code> * Datentypen (Skalar- und Verbundtypen).</code><br />
<code> * Funktionen und Kommentare.</code>

* Kontrollstrukturen:

<code> * `if`, `else if`, `else`.</code><br />
<code> * Schleifen (`loop`, `while`, `for`).</code>

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

* Projektbasiertes Lernen: 75 eigene Mini-Projekte bieten einen schnellen Praxisbezug und fördern den Wissenstransfer.
* Top-Down-Lernen: 20 große Projekte zu diesen Themen.
* Bitte gestalte alle Inhalte praxis- und projektbezogen sowie leicht verständlich.

Ausgabe und Speicherung:

* Das Ergebnis soll auf thorsten.wiki gespeichert werden.
* Das Ausgabeformat ist die MediaWiki-Syntax.

== Prompt ==

<pre>Erstelle Lernziele, Lektionen und Übungen zu den folgenden Themen:
* Installation und Einrichtung:
* `rustup`, `rustc` und `cargo`.
* Ein „Hello World!“-Programm.
* IDE-Einrichtung (z. B. VS Code mit rust-analyzer).
* Grundlegende Syntax:
* Variablen und Mutabilität (`let`, `let mut`).
* Datentypen (Skalar- und Verbundtypen).
* Funktionen und Kommentare.
* Kontrollstrukturen:
* `if`, `else if`, `else`.
* Schleifen (`loop`, `while`, `for`).

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.</pre>

----
''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''

Rust/Grundlagen - Versionsgeschichte

imported>Import: Version 232