Wie man Option<String> in Option<&str> in Rust ohne Schmerz umwandelt

Warum sind Sie hier? Seien Sie ehrlich

Sie programmieren in Rust und stoßen plötzlich auf eine Wand. Sie haben ein Option<String> – einen Wert, der vorhanden sein kann oder auch nicht. Aber die Funktion, die Sie aufrufen möchten, erwartet Option<&str>. Und der Compiler blickt Sie vorwurfsvoll an und gibt einen Fehler aus, bei dem Sie am liebsten den Laptop zuklappen und Tee trinken gehen würden.

Keine Sorge. Diese Situation tritt so häufig auf, dass die Frage "Converting from Option<String> to Option<&str>" auf Stack Overflow tausende Aufrufe gesammelt hat. Sie sind nicht allein.

In diesem Artikel werden wir verstehen, warum diese Konvertierung so viele Fragen aufwirft, und – am wichtigsten – wie man sie richtig durchführt. Ohne Magie, ohne unnötiges Kopieren im Speicher, mit vollständigem Verständnis dessen, was unter der Haube passiert.

Das Problem: Warum kann man nicht einfach konvertieren?

Zunächst ein kurzer Blick auf die Typen.

\n
• String ist ein besitzender Typ. Er besitzt die Daten auf dem Heap und ist für deren Freigabe verantwortlich.
\n
• &str ist ein Verweis auf einen String-Slice. Er leiht sich die Daten aus, ohne sie zu besitzen.
\n

Und hier beginnt der Spaß. Option<String> ist ein möglicherweise vorhandener String, den Sie besitzen. Option<&str> ist ein möglicherweise vorhandener Verweis auf einen String.

Das Problem ist, dass Sie nicht einfach einen Verweis auf den Wert innerhalb des Option nehmen und nach außen geben können, wenn das Option temporär ist. Der Verweis muss auf etwas zeigen, und dieses "Etwas" muss lange genug leben.

Schauen wir uns einen typischen Anfängerfehler an:

fn process(value: Option<String>) {\n    // Fehler! cannot return reference to temporary value\n    let ref_value: Option<&str> = value.as_ref().map(|s| s.as_str());\n    // oder noch direkter:\n    let ref_value: Option<&str> = Some(value.unwrap().as_str()); // BUMM!\n}

Der Compiler explodiert in Rot. Warum? Weil value der Besitzer des Strings ist. Wenn Sie versuchen, einen &str davon zu nehmen, darf der Verweis nicht länger leben als value selbst. Und wenn value ein temporäres Objekt ist (z. B. das Ergebnis eines Funktionsaufrufs), wird der Verweis zu einem hängenden Verweis (dangling reference).

Lösung Nr. 1: as_deref() – Ihr neuer bester Freund

Der eleganteste Weg, Option<String> in Option<&str> zu konvertieren, ist die Methode as_deref().

Wie funktioniert das? as_deref() macht zwei Dinge:

\n
1. Es nimmt &Option<T> und wandelt es in Option<&T> um (das macht as_ref()).
\n
2. Dann wendet es Deref auf den inneren Wert an und wandelt &String in &str um.
\n

So sieht das im Code aus:

fn main() {\n    let my_string: Option<String> = Some(String::from("Hallo, Rust!"));\n    \n    // Magie in einer Zeile:\n    let my_str_ref: Option<&str> = my_string.as_deref();\n    \n    match my_str_ref {\n        Some(s) => println!("String: {}", s),\n        None => println!("Kein String vorhanden"),\n    }\n    // my_string lebt und ist wohlauf!\n    println!("Ursprünglicher String: {:?}", my_string);\n}

Beachten Sie: my_string bleibt der Besitzer der Daten. Wir haben nur einen Verweis auf seinen Inhalt genommen. Das bedeutet, dass my_str_ref nur so lange lebt, wie my_string lebt.

Was ist, wenn Option leer ist?

Ganz einfach:

fn main() {\n    let empty: Option<String> = None;\n    let result: Option<&str> = empty.as_deref();\n    println!("{:?}", result); // None\n}

Keine Paniken, keine Abstürze. Funktioniert wie ein Uhrwerk.