Rust/Installation_von_`rustup`,_`rustc`_und_`cargo`

Willkommen in der Welt von Rust Um erfolgreich mit Rust zu programmieren, musst du drei wichtige Werkzeuge kennenlernen: rustup, rustc und cargo. Keine Sorge, wir erklären alles so einfach, dass du als Programmieranfänger sofort loslegen kannst.

Lernziele

Nach diesem Kurs wirst du:

• Verstehen, was `rustup`, `rustc` und `cargo` sind und worin sie sich unterscheiden.
• Rust selbstständig auf deinem Computer installieren und aktualisieren können.
• Einzelne Rust-Dateien mit dem Compiler übersetzen können.
• Komplette Rust-Projekte mit Cargo erstellen, verwalten, testen und bauen können.

Lektionen

Lektion 1: rustup – Dein Werkzeug-Manager

Stell dir `rustup` wie einen Werkzeugkoffer vor. Wenn du Rust verwenden möchtest, musst du es zuerst installieren. `rustup` kümmert sich um die Installation, Updates und darum, dass du immer die passenden Werkzeuge (wie den Compiler) hast.

• Hauptaufgabe: Rust installieren und aktuell halten.
• Wichtigster Befehl: `rustup update` (um alles auf den neuesten Stand zu bringen).

Lektion 2: rustc – Der Übersetzer

Computer verstehen unseren geschriebenen Text (den Code) nicht direkt. Sie brauchen Nullen und Einsen. Hier kommt `rustc` (der Rust-Compiler) ins Spiel. Er nimmt deinen Rust-Code und übersetzt ihn in ein Programm, das der Computer ausführen kann.

• Hauptaufgabe: Deinen Code in ein fertiges Programm verwandeln.
• Wichtigster Befehl: `rustc programm.rs` (übersetzt die Datei in ein ausführbares Programm).

Lektion 3: cargo – Dein Projektmanager

Du wirst `rustc` fast nie direkt benutzen. Warum? Weil `cargo` das für dich macht `cargo` ist wie ein Bauleiter: Es erstellt Ordner für dein Projekt, lädt andere Codes (Bibliotheken) aus dem Internet herunter und ruft `rustc` auf, um alles zusammenzubauen.

• Hauptaufgabe: Projekte erstellen, verwalten und bauen.
• Wichtigste Befehle: `cargo new` (neues Projekt), `cargo run` (Programm bauen und starten).

Übungen und 75 Mini-Projekte (Projektbasiertes Lernen)

Hier sind 75 kleine Aufgaben, mit denen du die Werkzeuge in der Praxis kennenlernst. Jedes Mini-Projekt dauert nur wenige Minuten

Teil 1: Mini-Projekte zu rustup (1-25)

1. Hallo rustup: Öffne das Terminal und gib `rustup --version` ein.
2. Updates prüfen: Führe `rustup update` aus, um die neuesten Versionen zu holen.
3. Werkzeuge anzeigen: Nutze `rustup show`, um zu sehen, was installiert ist.
4. Hilfe suchen: Lass dir mit `rustup help` alle Befehle erklären.
5. Docs lokal: Öffne die Offline-Dokumentation in deinem Browser mit `rustup doc`.
6. Zielplattformen: Führe `rustup target list` aus. Was siehst du?
7. Komponenten checken: Untersuche mit `rustup component list`, welche Extras verfügbar sind.
8. Formatierer holen: Installiere `rustfmt` mit `rustup component add rustfmt`.
9. Linter installieren: Füge `clippy` hinzu: `rustup component add clippy`.
10. Nightly installieren: Lade die Vorschauversion mit `rustup toolchain install nightly`.
11. Nightly aktivieren: Mache Nightly zum Standard: `rustup default nightly`.
12. Zurück zu Stable: Wechsle wieder zur stabilen Version: `rustup default stable`.
13. Ordner-Spezifisch: Setze in einem speziellen Ordner eine andere Version: `rustup override set nightly`.
14. Override löschen: Entferne diese Regel wieder mit `rustup override unset`.
15. Profil wechseln: Ändere dein Profil auf 'minimal': `rustup set profile minimal`.
16. Profil zurücksetzen: Gehe zurück auf 'default': `rustup set profile default`.
17. Deinstallieren üben: Entferne die Nightly-Toolchain: `rustup toolchain uninstall nightly`.
18. Wo bin ich?: Finde heraus, wo `rustup` liegt: `rustup where`.
19. Selbst-Update: Aktualisiere nur rustup selbst: `rustup self update`.
20. Beta-Version: Installiere die Beta-Version: `rustup toolchain install beta`.
21. Einmalig Beta: Führe einen Befehl explizit via Beta aus: `rustup run beta rustc --version`.
22. WebAssembly: Füge Wasm als Ziel hinzu: `rustup target add wasm32-unknown-unknown`.
23. Alte Versionen: Installiere eine sehr alte Rust-Version (z.B. 1.50): `rustup toolchain install 1.50.0`.
24. Aufräumen: Deinstalliere Version 1.50.0 wieder.
25. Quellcode laden: Lade den Rust-Sourcecode: `rustup component add rust-src`.

Teil 2: Mini-Projekte zu rustc (26-50)

1. Erstes Programm: Erstelle `hallo.rs`, schreibe eine 'main'-Funktion mit `println

` und kompiliere mit `rustc hallo.rs`.

1. Programmumbenennung: Kompiliere und gib dem Programm einen eigenen Namen: `rustc hallo.rs -o mein_programm`.
2. Fehler provozieren: Lösche ein Semikolon im Code und lies die rote `rustc`-Fehlermeldung.
3. Typenfehler: Versuche eine Zahl und einen Text zu addieren, beobachte `rustc`.
4. Fehlererklärung: Nutze den Tipp aus der Konsole, z.B. `rustc --explain E0308`.
5. Kompakt-Modus: Minimiere Code-Ausgaben: `rustc -O hallo.rs` (Optimierung).
6. Warnungen ansehen: Deklariere eine Variable `let x = 5;` ohne sie zu nutzen und kompiliere.
7. Warnungen unterdrücken: Füge `
   1. allow(unused_variables)` hinzu.
   2. Strenge Regeln: Wandle Warnungen in Fehler um: `rustc -D warnings hallo.rs`.
   3. Bibliothek erstellen: Baue Code ohne `main`-Funktion: `rustc --crate-type lib hallo.rs`.
   4. Metadaten ausgeben: Lass dir sagen, was kompiliert wird: `rustc --emit metadata hallo.rs`.
   5. Assembler ansehen: Generiere Maschinencode-Text: `rustc --emit asm hallo.rs`.
   6. Architektur: Setze die Ziel-Architektur manuell: `rustc --target x86_64-unknown-linux-gnu hallo.rs`.
   7. Standard-Edition: Kompiliere im älteren 2018-Standard: `rustc --edition 2018 hallo.rs`.
   8. Ausgabeverzeichnis: Lege fest, wohin die Datei soll: `rustc --out-dir ./neuer_ordner hallo.rs`.
   9. Bunte Farben aus: Schalte die Farbausgabe ab: `rustc --color never hallo.rs`.
   10. Version von rustc: Rufe `rustc --version` auf.
   11. Verbose-Modus: Lass rustc redselig werden: `rustc --verbose --version`.
   12. Tests kompilieren: Füge `
       1. test` hinzu und kompiliere mit `rustc --test hallo.rs`.
       2. Externe Links: Verbinde eine Library manuell mit `rustc -L . hallo.rs`.
       3. Crate-Name logisch ändern: Nutze `rustc --crate-name test_projekt hallo.rs`.
       4. Ausführungszeit prüfen: Miss, wie lange `rustc` braucht (z.B. mit dem Befehl `time`).
       5. LLVM IR ausgeben: Lass rustc die Zwischensprache zeigen: `rustc --emit llvm-ir hallo.rs`.
       6. Hilfe lesen: Stöbere in `rustc --help`.
       7. Zusammenfassung: Kombiniere `-O`, `--edition 2021` und `--out-dir`.

   Teil 3: Mini-Projekte zu cargo (51-75)

8. Startschuss: Baue ein neues Projekt: `cargo new mein_projekt`.
9. Ordnerstruktur: Analysiere, was Cargo in `mein_projekt` anlegt (src, Cargo.toml).
10. Bauen: Wechsle in den Ordner und tippe `cargo build`.
11. Sofort-Start: Führe `cargo run` aus (baut und startet gleichzeitig).
12. Schneller Check: Überprüfe Fehler ohne zu bauen: `cargo check`.
13. Release bauen: Baue eine superschnelle, optimierte Version: `cargo build --release`.
14. Ausmisten: Lösche den `target`-Ordner mit `cargo clean`.
15. Neues Paket hinzufügen: Öffne die `Cargo.toml` und füge `rand = "0.8"` hinzu.
16. Cargo Add benutzen: Füge eine Bibliothek im Terminal hinzu: `cargo add serde`.
17. Cargo Remove: Lösche Serde wieder: `cargo remove serde`.
18. Abhängigkeitsbaum: Lass dir den Abhängigkeits-Baum zeigen: `cargo tree`.
19. Code formatieren: Bringe Unordnung in deinen Code und tippe `cargo fmt`.
20. Code-Analyse: Lass den Linter Clippy rübergehen: `cargo clippy`.
21. Lokale Docs: Generiere Dokumentationen für dich und deine Helferlein: `cargo doc --open`.
22. Tests ausführen: Schreibe einen kleinen `
    1. test` in die `main.rs` und tippe `cargo test`.
    2. Neues Lib-Projekt: Erstelle directly eine Bibliothek: `cargo new --lib meine_bib`.
    3. Ausführbare Beispiele: Erstelle einen Ordner `examples` und führe ihn mit `cargo run --example demo` aus.
    4. Paket updaten: Aktualisiere Hilfs-Pakete mit `cargo update`.
    5. Suchen: Finde Pakete ohne Browser: `cargo search regex`.
    6. Werkzeuge installieren: Installiere ein fremdes Rust-Tool weltweit: `cargo install ripgrep`.
    7. Offline-Modus: Baue ohne Internetverbindung: `cargo build --offline`.
    8. Projekt packen: Simuliere einen Veröffentlichungs-Prozess: `cargo package`.
    9. Metadaten: Zeige maschinenlesbare Infos: `cargo metadata`.
    10. Globaler Cache: Mache dich mit dem Ordner `~/.cargo/registry` vertraut.
    11. Cargo-Hilfe: Entdecke weitere Befehle mit `cargo --list`.

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

Jetzt fügen wir alles zusammen. Hier erstellst du mit `cargo` große Projekte von der Idee bis zum fertigen Produkt.

1. Taschenrechner im Terminal: Nutze `cargo new` und schreibe ein Programm, das Eingaben liest und Plus, Minus, Mal, Geteilt rechnet. Teste die Formeln mit `cargo test`.
2. Zahlenraten-Spiel: Binde mit `cargo add` das `rand`-Paket ein. Lass das Programm eine zufällige Zahl generieren, die der Spieler erraten muss.
3. Notizbuch-App: Speichere und lade Zeilen aus einer Textdatei (.txt). Kompiliere abschließend im `--release` Modus.
4. Wetter-Anzeige (CLI): Binde die `reqwest`-Bibliothek ein und hole Wetterdaten aus dem Internet. Betrachte den komplexen Abhängigkeitsbaum mit `cargo tree`.
5. Vokabel-Lernkartei: Lese eine CSV-Datei ein. Nutze `cargo clippy`, um sicherzustellen, dass dein Code perfekt sauber ist.
6. Eigener Web-Server: Starte einen Server (z.B. mit dem Crate `axum` oder `actix-web`) und zeige ein "Hallo Welt" im Browser.
7. ToDo-Listen-Verwaltung: Ein Programm mit Menü: Hinzufügen, Löschen, Anzeigen. Speichere die Daten in einer lokalen JSON-Datei (Nutze `serde`).
8. Markdown zu HTML Konverter: Schreibe ein Tool, das `.md`-Dateien einliest und einfache HTML-Dateien ausspuckt. Formatiere den Code stets mit `cargo fmt`.
9. Passwort-Generator: Generiere sichere 16-stellige Passwörter. Mache dies als reines Bibliotheksprojekt (`cargo new --lib`) und schreibe eine GUI oder CLI in einem anderen Projekt dafür.
10. Stoppuhr / Pomodoro-Timer: Ein Timer, der Warntöne abgibt. Nutze Multi-Threading für den Hintergrund-Timer.
11. ASCII-Art Zeichner: Lies ein kleines Bild ein und wandle die Pixel in ASCII-Zeichen um.
12. Text-Verschlüsselung (Caesar Chiffre): Schreibe einen Algorithmus, der geheime Nachrichten verschlüsselt. Teste alle möglichen Kombinationen mit echten Test-Funktionen (`cargo test`).
13. Dateisystem-Durchsucher: Ähnlich wie Windows-Suche: Gib einen Begriff ein, und Rust durchsucht rasend schnell alle Dateien in einem Ordner.
14. Chat-Client: Baue eine einfache Client-Server-Architektur, bei der zwei Terminals miteinander chatten können.
15. Morse-Code-Übersetzer: Gib Text ein, das Programm übersetzt es in Punkte und Striche und gibt Pieptöne aus.
16. Ausgaben-Tracker: Ein Finanz-Tool, in dem du Ausgaben einträgst. Generiere eine kleine Statistik.
17. Tagebuch mit Passwort-Schutz: Nutze Verschlüsselungs-Bibliotheken (über Cargo hinzugeladen), bevor dein Text in die Datei geschrieben wird.
18. Ein Cargo-Workspace: Erstelle einen übergeordneten "Workspace", der zwei Projekte gleichzeitig beinhaltet: Eine Text-Analyse-Bibliothek und ein Terminal-Interface, das diese nutzt.
19. Eigener Mini-Programmiersprachen-Interpreter: Erstelle einen Interpreter für eine winzige, ausgedachte Spaß-Sprache. Bei Typfehlern schaust du dir an, wie gut `rustc` dir bei der Lösung hilft.
20. Ein öffentliches Crate vorbereiten: Mach eins deiner Projekte bereit, um es (theoretisch) mit `cargo publish` der Welt zur Verfügung zu stellen. Generiere dazu eine perfekte Offline-Anleitung mit `cargo doc`.