Rust/Grundlagen

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

---

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