Rust/Grundlagen

Aus Dokument
Zur Navigation springen Zur Suche springen

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


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! Diese Lernreise ist speziell für Kinder ab zehn Jahren und für absolute Code-Anfänger gedacht.

Lernziele

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

Was brauchen wir zum Bauen?

Um Rust zu nutzen, brauchst du drei super Helfer auf deinem Computer:

  • rustup: Das ist dein Werkzeugkasten-Manager. Er holt dir immer die neueste Version von Rust aus dem Internet.
  • rustc: Der Übersetzer (Compiler). Er liest deinen Text-Code und übersetzt ihn in Maschinensprache – die einzige Sprache, die dein Computer versteht (nur Einsen und Nullen).
  • cargo: Dein allerbester Freund! Cargo erstellt neue Projekte für dich, startet deine Programme und lädt Erweiterungen aus dem Internet herunter.

Aufgabe für dich: Öffne ein Terminal (das schwarze Fenster deines Computers) und tippe ein, was die Rust-Webseite dir sagt, um es zu installieren.

Das IDE-Setup (Dein Zauber-Schreibtisch)

Ein normaler Notizblock ist zu dumm zum Programmieren. Wir benutzen Visual Studio Code (VS Code). Lade VS Code herunter und installiere die Erweiterung rust-analyzer. Diese Erweiterung ist wie ein Helfer, der dir noch beim Tippen Fehler mit roten Linien markiert – genau wie dein Lehrer beim Diktat!

Das "Hello World!"-Programm

Lass uns den Computer dazu bringen, dich zu begrüßen! Tippe in deinem Terminal: 

cargo new hallo_welt
cd hallo_welt
cargo run

Was ist passiert? cargo new hat ein leeres Projekt gebaut. cd bedeutet "change directory" (gehe in den Ordner). Mit cargo run baust und startest du das Programm! Wenn du in die Datei src/main.rs schaust, siehst du: 

fn main() {
    println!("Hello, world!");
}
  • fn main(): Hier startet das Programm. Jeder Computer sucht nach der Hauptfunktion "main", um anzufangen. fn bedeutet "Funktion" (ein Rezept).
  • println!("...");: Das sagt dem Computer: "Drucke diesen Text auf den Bildschirm". Das ! bedeutet, dass es sich um ein Makro handelt. Stell es dir wie einen vorgefertigten Zauberspruch vor!


Lektion 2: Grundlegende Syntax (Kisten und Schachteln)

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. 

fn main() {
    let alter = 10;
    println!("Ich bin {} Jahre alt.", alter);
}

In Rust sind Kisten normalerweise **verschlossen**. Du kannst den Inhalt von alter nicht mehr ändern! Wenn eine Kiste **offen** bleiben soll, damit du etwas Neues hineinlegen kannst, brauchst du das Zauberwort mut (das steht für mutabel, also veränderbar). 

fn main() {
    let mut punkte = 0; // Kiste ist offen!
    punkte = punkte + 5; // Juhu, 5 Punkte gefunden!
    println!("Punkte: {}", punkte);
}

Datentypen (Was passt in die Kisten?)

Der Computer muss wissen, ob in der Kiste eine Zahl, ein Wort oder ein Schalter liegt.

  • Skalare (Einzelne Dinge):
    • Ganze Zahlen (z.B. 10 oder -5). In Rust oft i32 genannt.
    • Kommazahlen (z.B. 3.14). Genannt f64.
    • Wahrheitswerte (Booleans). Wie ein Lichtschalter: true (An/Wahr) oder false (Aus/Falsch). Genannt bool.
    • Buchstaben. Einzelne Zeichen wie 'A' oder ein Emoji '🚀'. Genannt char.
  • 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

Kommentare sind Notizen, die der Computer komplett ignoriert. Sie sind nur für dich! Starte sie mit //. Funktionen sind wie Backrezepte. Einmal aufschreiben, 100-mal Waffeln backen! 

// Das ist eine Funktion (unser Rezept), die uns begrüßt.
fn begruesse_hund(name: &str) {
    println!("Wuff, hallo {}!", name);
}

fn main() {
    // Hier nutzen wir das Rezept
    begruesse_hund("Bello");
}


Lektion 3: Kontrollstrukturen (Der Computer denkt mit)

Entscheidungen treffen: if, else if, else

Stell dir eine Straßenkreuzung vor. 

fn main() {
    let taschengeld = 10;

    if taschengeld >= 15 {
        println!("Ich kaufe mir das große Lego-Set!");
    } else if taschengeld >= 5 {
        println!("Ein Eis reicht auch.");
    } else {
        println!("Ich muss noch sparen.");
    }
}

Schleifen: loop, while, for

Computer lieben Wiederholungen. Menschen hassen sie. Lassen wir die Arbeit vom Computer machen!

1. Das endlose Karussell (loop): Es dreht sich für immer, es sei denn du schreist STOPP (break). 

fn main() {
    let mut runden = 0;
    loop {
        runden = runden + 1;
        println!("Runde {}!", runden);
        if runden == 3 {
            println!("Mir wird schlecht, aussteigen!");
            break; // Das STOPP-Wort
        }
    }
}

2. Solange du ein Ticket hast (while): 

fn main() {
    let mut tickets = 3;
    while tickets > 0 {
        println!("Autoscooter fahren! Tickets übrig: {}", tickets);
        tickets = tickets - 1;
    }
    println!("Alle Tickets weg.");
}

3. Von 1 bis 10 zählen (for): Perfekt, wenn du genau weißt, wie oft etwas passieren soll. 

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
}


Projektbasiertes Lernen: 30 Mini-Projekte

Programmiere diese kleinen Aufgaben in eigenen cargo new Projekten, um super stark in Rust zu werden! So lernst du am schnellsten.

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

Interleaving-Übungen (50 kleine Aufgaben bunt gemischt)

Hier testen wir dein Wissen. Alles ist durchgewirbelt – genau so lernt das Gehirn am besten! Beantworte die Fragen im Kopf oder probiere den Code im VS Code aus.

  1. 1 Wie lautet der Befehl im Terminal, um ein neues Projekt zu erstellen?
  2. 2 Welches Schlüsselwort macht eine Variable veränderbar? (Tipp: 3 Buchstaben)
  3. 3 Schreibe eine For-Schleife, die 3 Mal etwas ausdruckt.
  4. 4 Welcher Datentyp bedeutet 'Wahr' oder 'Falsch'?
  5. 5 Wie startest du ein fertig gebautes Cargo-Projekt im Terminal?
  6. 6 Du willst das Alter eines Drachens speichern (1000 Jahre). Ist das `let drache = 1000;` oder `let mut drache = 1000;` wenn er nicht älter wird?
  7. 7 Schreibe einen einzeiligen Kommentar in Rust.
  8. 8 Warum steht bei `println!` am Ende oft ein Ausrufezeichen?
  9. 9 Wie heißen die kleinen Texte, die ignoriert werden (//)?
  10. 10 Was ist an `fn main { }` falsch?
  11. 11 Übersetze dieses Rezept in Code: Funktion namens 'hüpfen'.
  12. 12 Was ist ein Array?
  13. 13 Was prüft dieser Code: `if x > 10`?
  14. 14 Was passiert in einem `loop { ... }` wenn es kein `break` gibt?
  15. 15 Was bedeutet das englische Wort 'while' ins Deutsche übersetzt für Schleifen?
  16. 16 Welcher Datentyp speichert den Text 'Hallo'?
  17. 17 Die Zahl `3.14` ist eine Kommazahl. Welcher mathematische Fachbegriff steht für Kommazahlen im Code (i32 oder f64)?
  18. 18 Schreibe den Code: Eine veränderbare Variable `gold` mit Inhalt 0.
  19. 19 Was bedeutet das Symbol `%` (Modulo) beim Rechnen im Code? Wie viel ist 5 % 2?
  20. 20 Wie gibst du den Wert der Variable `x` mit `println!` aus? Zeige den genauen Code.
  21. 21 Ordne zu: Werkzeugkasten-Manager, Übersetzer, Projekt-Manager. Die Begriffe: cargo, rustc, rustup.
  22. 22 Der Compiler sagt 'expected `;`'. Was hast du vergessen?
  23. 23 Welcher Buchstabe fängt bei Arrays an zu zählen, Index 1 oder Index 0?
  24. 24 Erstelle ein Tupel mit 2 Elementen: Der Zahl 10 und dem Buchstaben 'A'.
  25. 25 Was bewirkt `(1..=5).rev()` in einer for-Schleife?
  26. 26 Wozu braucht man VS Code?
  27. 27 Was macht das Plugin 'rust-analyzer'?
  28. 28 Wenn du `10 / 3` in i32 ausrechnest, welches Ergebnis kriegst du? (Tipp: Es gibt keine Kommas bei i32)
  29. 29 Finde den Fehler: `let x = 5; x = 6;`
  30. 30 Wie rufst du eine fertige Funktion namens `springen()` auf?
  31. 31 Welche Kontrollstruktur passt hier: Du möchtest etwas solange tun, wie dein Hunger größer als 0 ist.
  32. 32 Welche Kontrollstruktur passt hier: Du hast 10 Euro und es gibt Eis für 5 und Schoki für 2. Du triffst eine Wahl.
  33. 33 Welche Kontrollstruktur passt hier: Du zählst die Plätze im Bus von 1 bis 40.
  34. 34 Schreibe: Wenn `wetter == "Sonne"`, drucke "warm".
  35. 35 Füge ein: `____ alter = 15;` (Es soll sich nie verändern).
  36. 36 Ist `char` für lange Gedichte oder für einzelne Tastenanschläge gedacht?
  37. 37 Warum ist Rust wie Legosteine?
  38. 38 Was passiert, wenn die Hauptfunktion (main) durchgelaufen ist?
  39. 39 Wie schreibt man 'Größer oder gleich 10' in einem `if`?
  40. 40 Wie lautet das Zeichen für 'Gleichheit' in einer Bedingung (z.B. x gleich 5)? Ein `=` oder zwei `==`?
  41. 41 Erkläre einem Freund, wofür man `else` benutzt.
  42. 42 Schreibe ein Rust-Programm komplett aus dem Gedächtnis auf ein Stück Papier, das nur 'Hallo' ausgibt.
  43. 43 Wie machst du aus einer 5 eine Mut-Variable?
  44. 44 Finde den Fehler: `fn losgeht's() {}`
  45. 45 Was macht `cargo new spiel`?
  46. 46 Warum lieben Programmierer Arrays und Tupel?
  47. 47 Was ist ein Skalar-Typ?
  48. 48 Welcher Befehl stoppt das `loop` Karussell blitzartig?
  49. 49 Angenommen ein Array ist `let zahlen = [10, 20, 30]`. Welcher Index gibt die Zahl 20 aus?
  50. 50 Fühle dich stolz! Du hast 50 Aufgaben und 30 Projekte bearbeitet. Was ist dein nächstes Traum-Projekt in Rust?

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