So meistern Sie das Rust-Vorstellungsgespräch: Top-Fragen von A bis Z

Einleitung: Warum Rust eine Herausforderung für Interviewer darstellt

Rust ist eine Sprache, die vom Entwickler ein tiefes Verständnis der Speicherverwaltung, des Typsystems und des Parallelitätsmodells erfordert. Ein Rust-Vorstellungsgespräch ist kein Test der Syntax, sondern eine Prüfung des Verständnisses der Sprachphilosophie. In diesem Artikel analysieren wir die wichtigsten Fragen, die Ihnen im Vorstellungsgespräch gestellt werden können – von den Grundlagen des Ownerships bis zu fortgeschrittenen Themen wie Async. Sie erfahren, welche Antworten der Interviewer erwartet und wie Sie typische Fehler vermeiden.

1. Ownership, Borrowing und Lifetimes

1.1. Was ist Ownership und wie funktioniert es?

Dies ist das Fundament von Rust. Jeder Wert hat genau einen Besitzer. Wenn der Besitzer den Gültigkeitsbereich verlässt, wird der Wert gelöscht. Dies vermeidet eine Garbage Collection und garantiert Speichersicherheit zur Kompilierzeit.

fn main() {\n    let s1 = String::from("hallo");\n    let s2 = s1; // s1 wird nach s2 verschoben\n    // println!("{}", s1); // Fehler! s1 ist nicht mehr gültig\n    println!("{}", s2); // Funktioniert\n}

Tipp: Erklären Sie den Unterschied zwischen Verschiebung (move) und Kopie (copy). Bei Typen, die das Copy-Trait implementieren (z. B. ganze Zahlen), findet keine Verschiebung statt – die Daten werden kopiert.

1.2. Regeln des Borrowings

Borrowing ermöglicht die Nutzung eines Verweises auf Daten, ohne das Eigentumsrecht zu übertragen. Es gibt zwei Arten von Verweisen:

\n
• Unveränderliche (&T): beliebig viele, Daten können nicht geändert werden.
\n
• Veränderliche (&mut T): nur ein Verweis auf die Daten im aktuellen Gültigkeitsbereich.
\n

fn main() {\n    let mut s = String::from("hallo");\n    let r1 = &s; // unveränderlicher Verweis\n    let r2 = &s; // noch ein unveränderlicher – ok\n    // let r3 = &mut s; // Fehler! Gleichzeitig unveränderliche und veränderliche Verweise sind nicht erlaubt\n    println!("{} {}", r1, r2);\n}

Knifflige Frage: "Warum verbietet Rust gleichzeitig veränderliche und unveränderliche Verweise?" Antwort: Um Datenrennen (data races) bereits zur Kompilierzeit zu verhindern.

1.3. Lifetimes – einfach erklärt

Lifetimes sind Annotationen, die dem Compiler mitteilen, wie lange Verweise gültig sind. Meistens leitet der Compiler sie selbst ab, aber bei komplexen Funktionen müssen sie explizit angegeben werden.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {\n    if x.len() > y.len() { x } else { y }\n}

Kernidee: 'a bedeutet, dass der zurückgegebene Verweis nicht länger lebt als beide Eingangsverweise. Dies garantiert, dass der Verweis nicht zu einem hängenden (dangling) Verweis wird.

2. Enums, Pattern Matching und Traits

2.1. Enum in Rust – warum es mächtiger ist als in anderen Sprachen

In Rust können Enums Daten beliebigen Typs speichern – Strings, Zahlen, Strukturen und sogar andere Enums. Dies ermöglicht die Erstellung algebraischer Datentypen (ADT).

enum Message {\n    Quit,\n    Move { x: i32, y: i32 },\n    Write(String),\n    ChangeColor(i32, i32, i32),\n}

Typische Frage: "Wie funktioniert Option<T> und warum gibt es in Rust kein null?" Antwort: Option ist ein Enum, das entweder Some(T) oder None sein kann. Der Compiler zwingt zur Behandlung beider Varianten, was Nullzeigerfehler ausschließt.

2.2. Pattern Matching

Das match-Konstrukt ist das Herz von Rust. Es muss erschöpfend (exhaustive) sein.

fn describe_point(point: (i32, i32)) -> &'static str {\n    match point {\n        (0, 0) => "Ursprung",\n        (0, _) => "auf der X-Achse",\n        (_, 0) => "auf der Y-Achse",\n        _ => "irgendwo in der Ebene",\n    }\n}

Lifehack für das Vorstellungsgespräch: Verwenden Sie if let für