Rust Spickzettel
Zuletzt aktualisiert
Hello World & Aufbau
Ein Rust-Programm beginnt bei fn main; Anweisungen enden mit Semikolons.
| Operation | Syntax |
|---|---|
| Einstiegspunkt | fn main() { ... } |
| Eine Zeile ausgeben | println!("Hello, World!"); |
| Mit Werten ausgeben | println!("{} is {}", name, age); |
| Debug-Form ausgeben | println!("{:?}", value); |
| Zeilenkommentar | // comment |
| Ein Element aus einem Modul verwenden | use std::collections::HashMap; |
| Bauen & ausführen | cargo run |
| Eine Release-Binärdatei bauen | cargo build --release |
Variablen & Typen (let / mut)
Bindungen sind standardmäßig unveränderlich; füge mut hinzu, um Neuzuweisung zu erlauben.
| Operation | Syntax |
|---|---|
| Unveränderliche Bindung | let x = 5; |
| Veränderliche Bindung | let mut count = 0; |
| Expliziter Typ | let age: u32 = 30; |
| Konstante | const MAX: u32 = 100; |
| Shadowing | let x = x + 1; |
| Ganzzahltypen | i32, u32, i64, usize |
| Andere Skalare | f64, bool, char |
| Tupel | let pair: (i32, &str) = (1, "a"); |
| Typumwandlung | let f = x as f64; |
Kontrollfluss
if ist ein Ausdruck, und Rust hat drei Schleifenformen.
| Operation | Syntax |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If als Ausdruck | let y = if x > 0 { 1 } else { -1 }; |
| Endlosschleife | loop { ... } |
| Schleife, die einen Wert zurückgibt | let v = loop { break 5; }; |
| While-Schleife | while x < 100 { ... } |
| For über einen Bereich | for i in 0..10 { ... } |
| For über eine Collection | for item in &items { ... } |
| Break / continue | break;, continue; |
Funktionen
Der letzte Ausdruck (ohne Semikolon) ist der Rückgabewert.
| Operation | Syntax |
|---|---|
| Einfache Funktion | fn add(a: i32, b: i32) -> i32 { a + b } |
| Expliziter Return | fn f() -> i32 { return 5; } |
| Kein Rückgabewert | fn log(msg: &str) { ... } |
| Eine Referenz nehmen | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Closure mit Typ | let sq = |x: i32| -> i32 { x * x }; |
| Funktion als Argument | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership & Borrowing
Jeder Wert hat einen Besitzer; Referenzen leihen ihn aus, ohne den Besitz zu übernehmen.
| Operation | Syntax |
|---|---|
| Move (Besitz wird übertragen) | let b = a; (a nicht mehr gültig) |
| Clone (tiefe Kopie) | let b = a.clone(); |
| Unveränderliche Ausleihe | let r = &x; |
| Veränderliche Ausleihe | let r = &mut x; |
| Ausleihe in einer Funktion | fn read(s: &String) { ... } |
| Dereferenzieren | *r |
| Borrowing-Regel | Viele & ODER ein &mut gleichzeitig, nicht beides |
| Slice (leiht einen Bereich aus) | let part = &arr[1..3]; |
Structs & Enums
Structs gruppieren zusammengehörige Daten; Enums modellieren einen Wert, der eine von mehreren Varianten ist.
| Operation | Syntax |
|---|---|
| Ein Struct definieren | struct Point { x: i32, y: i32 } |
| Eine Instanz erstellen | let p = Point { x: 1, y: 2 }; |
| Auf ein Feld zugreifen | p.x |
| Tupel-Struct | struct Pair(i32, i32); |
| Methode (impl-Block) | impl Point { fn dist(&self) -> f64 { ... } } |
| Assoziierte Funktion | impl Point { fn new() -> Self { ... } } |
| Ein Enum definieren | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum mit benannten Feldern | enum Msg { Move { x: i32, y: i32 } } |
| Traits ableiten | #[derive(Debug, Clone)] |
Pattern Matching (match)
match vergleicht einen Wert mit Mustern und muss erschöpfend sein.
| Operation | Syntax |
|---|---|
| Auf Werte matchen | match x { 1 => "one", _ => "other" } |
| Ein Enum matchen | match shape { Shape::Circle(r) => ... } |
| Einen Bereich matchen | match n { 1..=5 => ..., _ => ... } |
| Binden mit einem Guard | match x { n if n > 0 => ... } |
| Ein Tupel matchen | match point { (0, y) => ..., (x, _) => ... } |
| if let (einzelnes Muster) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Ein Struct destrukturieren | let Point { x, y } = p; |
Traits & Generics
Traits definieren gemeinsames Verhalten; Generics lassen Code über viele Typen hinweg funktionieren.
| Operation | Syntax |
|---|---|
| Ein Trait definieren | trait Area { fn area(&self) -> f64; } |
| Ein Trait implementieren | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Standardmethode | trait Greet { fn hi(&self) { ... } } |
| Generische Funktion | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Generisches Struct | struct Wrapper<T> { value: T } |
| Trait-Bound (where) | fn f<T>(x: T) where T: Display { ... } |
| impl-Trait-Argument | fn print(item: impl Display) { ... } |
| Trait-Objekt | let shapes: Vec<Box<dyn Area>> = ...; |
Fehlerbehandlung (Result / Option)
Rust modelliert Abwesenheit mit Option und behebbare Fehler mit Result.
| Operation | Syntax |
|---|---|
| Optionaler Wert | Option<T>: Some(v) oder None |
| Result-Typ | Result<T, E>: Ok(v) oder Err(e) |
| Ein Result zurückgeben | fn read() -> Result<String, Error> { ... } |
| Mit ? weiterreichen | let data = read()?; |
| Unwrap (paniert bei None/Err) | opt.unwrap() |
| Standardwert | opt.unwrap_or(0) |
| Einen Wert mappen | opt.map(|v| v + 1) |
| Beide Zweige behandeln | match res { Ok(v) => ..., Err(e) => ... } |
| Option in Result umwandeln | opt.ok_or("missing")? |
Häufige Collections (Vec / HashMap)
Vec ist ein wachsendes Array; HashMap ist ein Schlüssel-Wert-Speicher.
| Operation | Syntax |
|---|---|
| Einen Vektor erstellen | let mut v: Vec<i32> = Vec::new(); |
| Vektor-Literal | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Indexzugriff | v[0] |
| Sicherer Zugriff | v.get(0) gibt Option<&T> zurück |
| Durchlaufen | for x in &v { ... } |
| Länge | v.len() |
| Eine Map erstellen | let mut m: HashMap<String, i32> = HashMap::new(); |
| Einfügen / lesen | m.insert(k, v);, m.get(&k) |
| Entry-API | *m.entry(k).or_insert(0) += 1; |
Die Rust-Syntax, die du am häufigsten brauchst, auf einer Seite. Dieser Rust-Spickzettel ist eine Schnellreferenz für die Kernsprache - Variablen und Veränderlichkeit, Ownership und Borrowing, Structs und Enums, Pattern Matching, Traits und Generics sowie die Result- und Option-Typen hinter Rusts Fehlerbehandlung.
Alles hier ist Standard-Rust, das auf einer aktuellen stabilen Toolchain kompiliert. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im Rust-Playground aus - keine cargo-Installation nötig.
Rust-Spickzettel FAQ
Ist dieser Rust-Spickzettel kostenlos?
Ja. Dieser Rust-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du ein match-Muster, einen Trait-Bound oder eine Collection-Methode nachschlagen möchtest.
Was sind Ownership und Borrowing in Rust?
&x für eine unveränderliche Ausleihe oder &mut x für eine veränderliche. Der Compiler erzwingt eine Regel: Du kannst viele unveränderliche Ausleihen oder genau eine veränderliche Ausleihe gleichzeitig haben, was Data Races zur Compilezeit verhindert.Was ist der Unterschied zwischen Result und Option in Rust?
Option<T> steht für einen Wert, der fehlen kann - er ist entweder Some(v) oder None, und du verwendest ihn, wenn kein Fehler zu melden ist, sondern nur ein fehlender Wert. Result<T, E> steht für eine Operation, die fehlschlagen kann - sie ist entweder Ok(v) oder Err(e) und trägt einen Fehlerwert, wenn etwas schiefgeht. Verwende Option für „vielleicht vorhanden" und Result für „dies könnte fehlschlagen"; der ?-Operator reicht beide weiter.Kann ich Rust online üben?
Ja. Öffne den Rust-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser zu kompilieren und auszuführen - kein cargo oder Toolchain zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Rust-Kurs Schritt für Schritt von Variablen und Ownership zu Traits und Fehlerbehandlung.
Ist dieser Spickzettel für Anfänger geeignet?
Ja. Er ist von den häufigsten Themen (Variablen, Kontrollfluss, Funktionen) hin zu den fortgeschrittenen (Traits, Generics, Fehlerbehandlung) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in Ownership und den Rest hineinwachsen kannst.
Verwandte Ressourcen
Weitere Spickzettel
