Rust-Spickzettel

Eine Seite zum schnellen Nachschlagen – für alles, was du prüfen willst, ohne gleich eine ganze Lektion noch einmal zu lesen. Jeder Abschnitt verlinkt auf die Seite, die das Thema ausführlich erklärt.

Schlüsselwörter

Schlüsselwort	Bedeutung
`let`	Deklariert eine Variable (Variablen)
`mut`	Macht eine Variable oder Referenz veränderbar (Variablen)
`const`	Deklariert eine Konstante (Variablen)
`fn`	Deklariert eine Funktion (Funktionen)
`struct`	Deklariert ein Struct (Structs)
`enum`	Deklariert ein Enum (Enums)
`impl`	Fügt einem Typ Methoden hinzu (Structs, Traits)
`trait`	Deklariert einen Trait (Traits)
`match`	Vergleicht einen Wert mit Patterns (Match)
`if let` / `while let`	Prüft auf ein einzelnes Pattern (If Let / While Let)
`loop` / `while` / `for`	Die drei Arten von Schleifen (Schleifen, While, For)
`break` / `continue`	Steuern eine Schleife (Break/Continue)
`mod`	Deklariert ein Modul (Module)
`pub`	Macht ein Element außerhalb seines Moduls sichtbar (Module)
`use`	Holt einen Pfad in den Gültigkeitsbereich (Module)
`unsafe`	Erlaubt Raw Pointer und andere Operationen, für deren Sicherheit du selbst sorgst (Unsafe Rust)
`move`	Zwingt ein Closure, die Ownership der eingefangenen Werte zu übernehmen (Nebenläufigkeit)
`&` / `&mut`	Leiht einen Wert aus / leiht ihn veränderbar aus (Borrowing)

Wichtige String-Methoden

Methode	Was sie tut
`.len()`	Länge in Bytes
`.trim()`	Entfernt Leerzeichen am Anfang und Ende
`.to_uppercase()` / `.to_lowercase()`	Groß- bzw. Kleinschreibung
`.contains(pat)`	Ob ein Teilstring oder Pattern vorkommt
`.replace(from, to)`	Ersetzt alle Treffer
`.push_str(s)`	Hängt einen `&str` an
`.push(c)`	Hängt ein einzelnes `char` an
`.chars()`	Iteriert Zeichen für Zeichen
`.split(pat)`	Teilt in einen Iterator aus Teilstrings
`.parse::<T>()`	Wandelt Text in einen anderen Typ um (gibt `Result` zurück)

Details und Beispiele findest du auf der Seite Strings in Rust.

Wichtige Vec-Methoden

Methode	Was sie tut
`.push(x)`	Hängt ein Element ans Ende an
`.pop()`	Entfernt das letzte Element und gibt es zurück (`Option`)
`.remove(i)`	Entfernt das Element am Index `i`
`.len()`	Anzahl der Elemente
`.is_empty()`	Ob der Vektor leer ist
`.get(i)`	Sicherer Zugriff per Index (`Option`, kein Panic)
`.iter()`	Iteriert per Referenz
`.contains(&x)`	Ob ein Wert enthalten ist
`.sort()`	Sortiert an Ort und Stelle
`.sort_by_key(\|x\| ...)`	Sortiert nach einem Feld oder berechneten Schlüssel
`.dedup()`	Entfernt direkt aufeinanderfolgende Duplikate (vorher sortieren)

Details und Beispiele findest du auf den Seiten Vektoren, Sortieren und Suchen und Iteratoren.

Welche Collection soll ich nehmen?

Typ	Nimm ihn, wenn du … brauchst
`Vec<T>`	eine geordnete Liste, die wachsen kann
`HashMap<K, V>`	schnelles Nachschlagen eines Werts über einen Schlüssel
`HashSet<T>`	eindeutige Elemente und schnelle „Ist das hier drin?“-Prüfungen
`BTreeMap<K, V>`	Schlüssel-Wert-Paare, nach Schlüssel sortiert
`VecDeque<T>`	eine Warteschlange – Einfügen und Entfernen an beiden Enden

Details und Beispiele findest du auf den Seiten HashMap in Rust und HashSet und BTreeMap.

Option und Result

Methode	Funktioniert mit	Was sie tut
`.unwrap()`	beiden	Liefert den Wert, löst bei `None`/`Err` einen Panic aus
`.expect("msg")`	beiden	Wie `.unwrap()`, aber mit eigener Panic-Meldung
`.unwrap_or(default)`	beiden	Liefert den Wert oder einen Ersatzwert
`.is_some()` / `.is_none()`	`Option`	Prüft, welche Variante es ist
`.is_ok()` / `.is_err()`	`Result`	Prüft, welche Variante es ist
`?`	beiden	Kehrt bei `None`/`Err` sofort zurück

Details und Beispiele findest du auf den Seiten Option und Result.

Formatangaben (println!, format!)

Angabe	Was sie ausgibt
`{}`	Normale Anzeige (braucht den Trait `Display`)
`{:?}`	Debug-Format
`{:#?}`	Schön formatiertes Debug-Format
`{:.2}`	2 Nachkommastellen
`{:5}`	Füllt auf eine Breite von 5 auf
`{name}`	Setzt die Variable `name` direkt ein

Details und Beispiele findest du auf der Seite Ausgabe in Rust.

Cargo-Befehle

Befehl	Was er tut
`cargo new name`	Legt ein neues Projekt an
`cargo run`	Baut und startet das Programm
`cargo check`	Sucht schnell nach Fehlern, ohne zu bauen
`cargo test`	Führt deine Tests aus
`cargo add crate`	Fügt eine Abhängigkeit hinzu
`cargo fmt`	Formatiert deinen Code
`cargo clippy`	Prüft deinen Code auf typische Fehler (Linter)
`cargo build --release`	Baut eine optimierte ausführbare Datei

Details und Beispiele findest du auf der Seite Cargo und Crates.

Range-Syntax

Syntax	Bedeutung
`1..5`	Von 1 bis 5, aber ohne die 5
`1..=5`	Von 1 bis einschließlich 5
`..3`	Vom Anfang bis 3, aber ohne die 3
`2..`	Von 2 bis zum Ende
`..`	Alles

Details und Beispiele findest du auf den Seiten For und Slices.

Beliebte Crates

Du brauchst …	Crate	Lektion
JSON (und andere Formate)	`serde` + `serde_json`	JSON mit Serde
Asynchronen Code, Timer, Netzwerk	`tokio`	Async/Await
Eine Kommandozeilen-Oberfläche	`clap`	CLI-Tool mit clap
Einfache Fehlerbehandlung	`anyhow`, `thiserror`	anyhow und thiserror
Zufallszahlen	`rand`	Zufallszahlen
Reguläre Ausdrücke	`regex`	Reguläre Ausdrücke
Datum und Uhrzeit	`chrono`	Datum und Uhrzeit
Logging	`log` + `env_logger`, `tracing`	Logging
Einen Webserver	`axum`	Web-API mit Axum

Jedes davon fügst du mit cargo add <crate> hinzu. Wie du ein gutes Crate auswählst, erfährst du auf der Seite Cargo und Crates.

Weiterlesen

Rust Language Cheat Sheet — cheats.rs: eine viel ausführlichere Referenz auf einer Seite, von der Syntax bis zum Speicherlayout (auf Englisch).
Anhang B: Operatoren und Symbole – Das Rust-Buch: alle Operatoren und Symbole in Rust und ihre Bedeutung.
std::fmt – Doku der Standardbibliothek: die komplette Formatierungssyntax von println! und format!: Breite, Auffüllen, Genauigkeit und mehr (auf Englisch).
Cargo-Befehle – The Cargo Book: jeder cargo-Befehl mit seinen Optionen (auf Englisch).