Rust.md

2026-04-02 22:31:09 +02:00
parent 5811cbd9e9
commit 6648179294
1 changed files with 746 additions and 0 deletions
@@ -0,0 +1,746 @@
+```md
+---
+title: "Rust Tutorial (für Python-Erfahrene)"
+tags: [rust, tutorial, programming]
+created: 2026-03-27
+---
+
+# Rust Tutorial (für Python-Erfahrene)
+
+Dieses Tutorial ist als **hands-on Lernpfad** gedacht: viele kleine Programme, die du direkt ausführen und variieren kannst. Du bekommst dabei die wichtigsten Rust-Konzepte (Ownership/Borrowing, Lifetimes-Grundlagen, Traits, Enums/Pattern Matching, Fehlerbehandlung, Collections, Generics, Module/Crates, Testing, Async-Basics).
+
+---
+
+## 0) Setup: Was brauche ich, wie führe ich Rust aus?
+
+### Installation (Compiler + Tooling)
+Rust wird normalerweise über **rustup** installiert (inkl. `rustc`, `cargo`, Standardbibliothek).
+
+- **Windows/macOS/Linux:**
+  - https://rustup.rs öffnen und Anweisungen folgen
+- Danach prüfen:
+```bash
+rustc --version
+cargo --version
+rustup --version
+```
+
+### Editor (empfohlen)
+- **VS Code** + Extension: **rust-analyzer**
+- Alternativ: IntelliJ Rust, Neovim + rust-analyzer, etc.
+
+### Neues Projekt erstellen und ausführen
+Rust nutzt **Cargo** als Build-Tool + Paketmanager.
+
+```bash
+cargo new hello_rust
+cd hello_rust
+cargo run
+```
+
+Wichtige Cargo-Kommandos:
+```bash
+cargo build        # kompiliert (debug)
+cargo build --release
+cargo run          # build + run
+cargo test         # tests
+cargo fmt          # formatieren (rustfmt)
+cargo clippy       # lints (clippy)
+cargo doc --open   # docs generieren + öffnen
+```
+
+Projektstruktur:
+- `src/main.rs` (Binary)
+- `Cargo.toml` (Dependencies, Name, Version, etc.)
+
+---
+
+## 1) Hello World + Grundsyntax
+
+`src/main.rs`:
+```rust
+fn main() {
+    println!("Hello, Rust!");
+}
+```
+
+**Wichtig:** Makro-Aufruf erkennst du am `!` (`println!`, `vec!`, `format!`, …).
+
+---
+
+## 2) Variablen, Mutabilität, Typen
+
+Rust ist **statisch typisiert**, aber oft mit **Typinferenz**.
+
+```rust
+fn main() {
+    let x = 5;          // immutable
+    // x = 6;           // Fehler
+
+    let mut y = 5;      // mutable
+    y = 6;
+
+    let z: i32 = 42;    // expliziter Typ
+    let pi: f64 = 3.1415;
+
+    println!("{x} {y} {z} {pi}");
+}
+```
+
+### Shadowing (anders als mut)
+```rust
+fn main() {
+    let s = "42";
+    let s = s.parse::<i32>().unwrap(); // shadowing: neuer s mit anderem Typ
+    println!("{s}");
+}
+```
+
+---
+
+## 3) Strings: `&str` vs `String` (Python-Vergleich)
+
+- `&str`: **String Slice**, meist “geliehener” Text (z.B. Stringliteral)
+- `String`: **besitzender**, heap-allocierter String (änderbar)
+
+```rust
+fn main() {
+    let a: &str = "hi";           // slice
+    let mut b: String = String::from("hi"); // owned
+    b.push_str(" there");
+
+    println!("{a} / {b}");
+}
+```
+
+Sehr häufig konvertieren:
+```rust
+let s = "abc".to_string();
+let t = String::from("abc");
+let u: &str = &t; // String -> &str
+```
+
+---
+
+## 4) Funktionen
+
+```rust
+fn add(a: i32, b: i32) -> i32 {
+    a + b // kein Semikolon => Ausdruck
+}
+
+fn main() {
+    let r = add(2, 3);
+    println!("{r}");
+}
+```
+
+Mehr Rückgabewerte via Tupel:
+```rust
+fn div_mod(a: i32, b: i32) -> (i32, i32) {
+    (a / b, a % b)
+}
+```
+
+---
+
+## 5) Kontrollfluss: `if`, `loop`, `while`, `for`
+
+```rust
+fn main() {
+    let n = 7;
+
+    if n % 2 == 0 {
+        println!("even");
+    } else {
+        println!("odd");
+    }
+
+    for i in 0..3 {
+        println!("i={i}");
+    }
+
+    let items = vec!["a", "b", "c"];
+    for (idx, item) in items.iter().enumerate() {
+        println!("{idx}: {item}");
+    }
+}
+```
+
+`loop` kann Werte zurückgeben:
+```rust
+fn main() {
+    let mut i = 0;
+    let result = loop {
+        i += 1;
+        if i == 3 {
+            break i * 10; // liefert 30
+        }
+    };
+    println!("{result}");
+}
+```
+
+---
+
+## 6) Structs, Methoden, `impl`
+
+```rust
+#[derive(Debug, Clone)]
+struct User {
+    name: String,
+    age: u32,
+}
+
+impl User {
+    fn new(name: impl Into<String>, age: u32) -> Self {
+        Self { name: name.into(), age }
+    }
+
+    fn birthday(&mut self) {
+        self.age += 1;
+    }
+}
+
+fn main() {
+    let mut u = User::new("Alice", 30);
+    u.birthday();
+    println!("{u:?}");
+}
+```
+
+---
+
+## 7) Enums + Pattern Matching (sehr wichtig)
+
+```rust
+#[derive(Debug)]
+enum Message {
+    Quit,
+    Write(String),
+    Move { x: i32, y: i32 },
+}
+
+fn handle(m: Message) {
+    match m {
+        Message::Quit => println!("bye"),
+        Message::Write(text) => println!("text={text}"),
+        Message::Move { x, y } => println!("move to {x},{y}"),
+    }
+}
+
+fn main() {
+    handle(Message::Write("hello".into()));
+    handle(Message::Move { x: 1, y: 2 });
+}
+```
+
+`match` ist exhaustiv: alle Fälle müssen behandelt werden (oder `_`).
+
+---
+
+## 8) Ownership, Borrowing, References (Kern von Rust)
+
+Rust verhindert Data Races und Use-After-Free durch Regeln:
+
+### Ownership-Regeln (vereinfacht)
+1. Jeder Wert hat **genau einen Owner**.
+2. Wenn der Owner aus dem Scope läuft, wird der Wert **gedroppt**.
+3. **Move**: Zuweisung/Übergabe kann Ownership übertragen.
+
+Beispiel: Move vs Copy
+```rust
+fn main() {
+    let a = String::from("hello");
+    let b = a;
+    // println!("{a}"); // Fehler: a wurde gemoved
+
+    let x = 5; // i32 ist Copy
+    let y = x;
+    println!("{x} {y}");
+}
+```
+
+### Borrowing: `&T` (immutable) und `&mut T` (mutable)
+```rust
+fn len(s: &String) -> usize {
+    s.len()
+}
+
+fn add_exclamation(s: &mut String) {
+    s.push('!');
+}
+
+fn main() {
+    let mut s = String::from("hi");
+    println!("{}", len(&s));
+
+    add_exclamation(&mut s);
+    println!("{s}");
+}
+```
+
+Borrowing-Regeln:
+- beliebig viele `&T` **oder**
+- genau ein `&mut T`
+- aber nicht beides gleichzeitig (im gleichen Gültigkeitsbereich)
+
+Typischer Fehler (und Fix durch Scopes):
+```rust
+fn main() {
+    let mut s = String::from("abc");
+
+    let r1 = &s;
+    let r2 = &s;
+    println!("{r1} {r2}");
+
+    let r3 = &mut s; // ok, weil r1/r2 danach nicht mehr benutzt werden
+    r3.push('d');
+    println!("{r3}");
+}
+```
+
+---
+
+## 9) Slices: Teilansichten von Daten
+
+```rust
+fn main() {
+    let a = [10, 20, 30, 40];
+    let mid: &[i32] = &a[1..3]; // 20,30
+    println!("{mid:?}");
+
+    let s = String::from("hello world");
+    let w: &str = &s[0..5];
+    println!("{w}");
+}
+```
+
+Achtung bei UTF-8: String-Slicing nur an gültigen Byte-Grenzen von Codepoints.
+
+---
+
+## 10) Collections: `Vec`, `HashMap`, `HashSet`
+
+### `Vec<T>`
+```rust
+fn main() {
+    let mut v = vec![1, 2, 3];
+    v.push(4);
+
+    for x in &v {
+        println!("{x}");
+    }
+
+    if let Some(last) = v.pop() {
+        println!("popped {last}");
+    }
+}
+```
+
+### `HashMap<K,V>`
+```rust
+use std::collections::HashMap;
+
+fn main() {
+    let mut m = HashMap::new();
+    m.insert("alice", 10);
+    m.insert("bob", 7);
+
+    *m.entry("alice").or_insert(0) += 1;
+
+    if let Some(score) = m.get("alice") {
+        println!("alice={score}");
+    }
+
+    for (k, v) in &m {
+        println!("{k} => {v}");
+    }
+}
+```
+
+---
+
+## 11) Option und Result: Fehlerbehandlung ohne Exceptions
+
+Rust nutzt **`Option<T>`** (statt `None`) und **`Result<T, E>`** (statt Exceptions).
+
+### Option
+```rust
+fn first(v: &[i32]) -> Option<i32> {
+    v.first().copied()
+}
+
+fn main() {
+    let v = vec![1, 2, 3];
+    match first(&v) {
+        Some(x) => println!("first={x}"),
+        None => println!("empty"),
+    }
+}
+```
+
+### Result + `?` Operator
+```rust
+use std::fs;
+
+fn read_file(path: &str) -> Result<String, std::io::Error> {
+    let text = fs::read_to_string(path)?;
+    Ok(text)
+}
+
+fn main() {
+    match read_file("Cargo.toml") {
+        Ok(t) => println!("len={}", t.len()),
+        Err(e) => eprintln!("error: {e}"),
+    }
+}
+```
+
+**`?`**: Wenn `Err`, returnt die Funktion früh; wenn `Ok`, entpackt.
+
+---
+
+## 12) Iterators (sehr “pythonic”, aber typisiert)
+
+```rust
+fn main() {
+    let nums = vec![1, 2, 3, 4, 5];
+
+    let squares: Vec<i32> = nums.iter()
+        .map(|x| x * x)
+        .collect();
+
+    let even_sum: i32 = nums.iter()
+        .filter(|x| *x % 2 == 0)
+        .sum();
+
+    println!("{squares:?} even_sum={even_sum}");
+}
+```
+
+Ownership dabei:
+- `iter()` gibt `&T`
+- `into_iter()` konsumiert und gibt `T` (Owned)
+- `iter_mut()` gibt `&mut T`
+
+---
+
+## 13) Generics + Traits (Rusts “Interfaces”)
+
+### Generics
+```rust
+fn first<T: Clone>(v: &[T]) -> Option<T> {
+    v.first().cloned()
+}
+```
+
+### Trait definieren und implementieren
+```rust
+trait Greeter {
+    fn greet(&self) -> String;
+}
+
+struct Person { name: String }
+
+impl Greeter for Person {
+    fn greet(&self) -> String {
+        format!("Hi, {}!", self.name)
+    }
+}
+
+fn say_hello(g: &impl Greeter) {
+    println!("{}", g.greet());
+}
+
+fn main() {
+    let p = Person { name: "Alice".into() };
+    say_hello(&p);
+}
+```
+
+Trait Bounds:
+```rust
+fn print_debug<T: std::fmt::Debug>(x: T) {
+    println!("{x:?}");
+}
+```
+
+---
+
+## 14) Module, Crates, Sichtbarkeit (`pub`)
+
+### In einer Datei
+```rust
+mod math {
+    pub fn add(a: i32, b: i32) -> i32 {
+        a + b
+    }
+
+    fn secret() {} // privat
+}
+
+fn main() {
+    println!("{}", math::add(1, 2));
+}
+```
+
+### Mehrere Dateien (typisches Layout)
+- `src/main.rs`
+- `src/math.rs`
+
+`src/main.rs`:
+```rust
+mod math;
+
+fn main() {
+    println!("{}", math::add(1, 2));
+}
+```
+
+`src/math.rs`:
+```rust
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+```
+
+---
+
+## 15) Lifetimes (Grundidee, praxisnah)
+
+Lifetimes sagen dem Compiler: “Wie lange sind Referenzen gültig?”
+
+Beispiel: Funktion gibt eine Referenz zurück:
+```rust
+fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
+    if a.len() >= b.len() { a } else { b }
+}
+
+fn main() {
+    let x = "short";
+    let y = "a bit longer";
+    println!("{}", longer(x, y));
+}
+```
+
+Als Anfänger-Regel:
+- Wenn du **Owned** (`String`, `Vec<T>`) zurückgeben kannst, ist das oft einfacher.
+- Lifetimes brauchst du vor allem bei APIs, die Referenzen zurückgeben.
+
+---
+
+## 16) Smart Pointers: `Box`, `Rc`, `Arc`, `RefCell` (Überblick)
+
+- `Box<T>`: heap allocation, Ownership bleibt eindeutig
+- `Rc<T>`: shared ownership **single-thread**
+- `Arc<T>`: shared ownership **thread-safe**
+- `RefCell<T>`: “interior mutability” (Borrow-Regeln zur Laufzeit)
+
+Mini-Beispiel `Rc`:
+```rust
+use std::rc::Rc;
+
+fn main() {
+    let a = Rc::new(String::from("hello"));
+    let b = Rc::clone(&a);
+
+    println!("a={}, b={}", a, b);
+    println!("strong_count={}", Rc::strong_count(&a));
+}
+```
+
+---
+
+## 17) Concurrency (Basics): Threads + Channels
+
+```rust
+use std::thread;
+use std::sync::mpsc;
+
+fn main() {
+    let (tx, rx) = mpsc::channel();
+
+    let handle = thread::spawn(move || {
+        tx.send("hello from thread").unwrap();
+    });
+
+    let msg = rx.recv().unwrap();
+    println!("got: {msg}");
+
+    handle.join().unwrap();
+}
+```
+
+---
+
+## 18) Async (Basics): `async/await` mit Tokio
+
+Async braucht i.d.R. eine Runtime (z.B. Tokio).
+
+`Cargo.toml`:
+```toml
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+```
+
+`src/main.rs`:
+```rust
+use tokio::time::{sleep, Duration};
+
+#[tokio::main]
+async fn main() {
+    let h = tokio::spawn(async {
+        sleep(Duration::from_millis(100)).await;
+        42
+    });
+
+    let result = h.await.unwrap();
+    println!("result={result}");
+}
+```
+
+---
+
+## 19) Testing
+
+```rust
+fn add(a: i32, b: i32) -> i32 { a + b }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adds() {
+        assert_eq!(add(2, 3), 5);
+    }
+}
+```
+
+Ausführen:
+```bash
+cargo test
+```
+
+---
+
+## 20) “Rust für Python-Dev”: mentale Übersetzungen
+
+- Python-Liste ↔ `Vec<T>`
+- Dict ↔ `HashMap<K,V>`
+- `None` ↔ `Option<T>`
+- Exceptions ↔ `Result<T,E>` + `?`
+- Duck typing ↔ Traits + Generics
+- Mutable Default überall ↔ Rust: **immutable by default**
+- Garbage Collector ↔ Ownership (Drop am Scope-Ende)
+
+**Idiom:** Daten lieber so modellieren, dass `match` alle Fälle abdeckt (Enums sind stark).
+
+---
+
+## 21) Mini-Projekt 1: CLI “todo” (ohne externe Crates)
+
+Ziel: einfache Aufgabenliste im Speicher (kein Persistenz).
+
+```rust
+use std::io::{self, Write};
+
+fn main() {
+    let mut todos: Vec<String> = Vec::new();
+
+    loop {
+        print!("todo> ");
+        io::stdout().flush().unwrap();
+
+        let mut line = String::new();
+        if io::stdin().read_line(&mut line).is_err() {
+            println!("input error");
+            continue;
+        }
+        let line = line.trim();
+
+        if line == "quit" {
+            break;
+        } else if line == "list" {
+            for (i, t) in todos.iter().enumerate() {
+                println!("{}: {}", i + 1, t);
+            }
+        } else if let Some(rest) = line.strip_prefix("add ") {
+            todos.push(rest.to_string());
+        } else if let Some(rest) = line.strip_prefix("done ") {
+            if let Ok(idx) = rest.parse::<usize>() {
+                if idx >= 1 && idx <= todos.len() {
+                    todos.remove(idx - 1);
+                } else {
+                    println!("index out of range");
+                }
+            } else {
+                println!("usage: done <number>");
+            }
+        } else {
+            println!("commands: add <text> | list | done <n> | quit");
+        }
+    }
+}
+```
+
+---
+
+## 22) Mini-Projekt 2: JSON holen (Reqwest)
+
+`Cargo.toml`:
+```toml
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+reqwest = { version = "0.12", features = ["json"] }
+serde = { version = "1", features = ["derive"] }
+```
+
+`src/main.rs`:
+```rust
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct HttpBin {
+    url: String,
+    origin: String,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), reqwest::Error> {
+    let data: HttpBin = reqwest::get("https://httpbin.org/get")
+        .await?
+        .json()
+        .await?;
+
+    println!("{data:#?}");
+    Ok(())
+}
+```
+
+---
+
+## 23) Nächste Schritte / gute Referenzen
+
+- Offizielles Buch: https://doc.rust-lang.org/book/
+- Rust by Example: https://doc.rust-lang.org/rust-by-example/
+- Standard Library Docs: https://doc.rust-lang.org/std/
+
+---
+
+## Vorschlag für deinen Lernpfad (kurz)
+1. Kapitel 1–7 (Syntax, Structs/Enums)
+2. Ownership/Borrowing (Kapitel 8–10) – viel üben
+3. Option/Result + Iterators
+4. Traits/Generics + Module
+5. Tests + kleines Projekt
+6. Dann Async/Concurrency nach Bedarf
+
+---
+
+## Offene Fragen (damit ich es besser anpassen kann)
+- Willst du Rust eher für **CLI**, **Backend**, **Embedded**, **WebAssembly** oder **Data/Perf** nutzen?
+- Betriebssystem/Editor?
+- Soll ich daraus **mehrere Obsidian-Notizen** machen (z.B. “Ownership”, “Result/Option”, “Traits”, …) mit internen Links?
+```