Null-Referenzen
Wenn du schon einmal eine andere Programmiersprache verwendet hast (C/C++, Python, Java, Ruby, Lisp usw.), bist du wahrscheinlich schon einmal auf null oder nil gestoßen.
Mit null oder nil zeigen diese Sprachen an, dass eine bestimmte Variable keinen Wert hat.
Allerdings passiert es dadurch leicht (und häufig), dass du versehentlich eine Variable verwendest, die auf null zeigt.
Wie du dir vorstellen kannst, kann der Versuch, eine Funktion aufzurufen, die es nicht gibt, oder auf einen Wert zuzugreifen, der nicht existiert, zu allerlei Bugs und Abstürzen führen.
Der Erfinder von null nannte es sogar seinen 'Milliarden-Dollar-Fehler'.
Der Typ Option
Um diese Probleme zu vermeiden, verwendet Rust keine Null-Referenzen.
Rust braucht aber trotzdem eine sichere Möglichkeit anzugeben, dass eine bestimmte Variable keinen Wert hat.
Hier kommt Option ins Spiel.
Statt eine Variable zu haben, der ein Wert fehlt, können Rust-Variablen das Enum Option verwenden.
Dieses Enum hat zwei Varianten: None, das Äquivalent zu null in Rust; und Some(T), wobei T ein Wert beliebigen Typs ist.
Es sieht so aus:
enum Option<T> {
None,
Some(T),
}
Du kannst dir Option als eine Schutzschicht zwischen dir und den Problemen vorstellen, die Null-Referenzen verursachen können, wobei ihr konzeptioneller Nutzen erhalten bleibt.
Option verwenden
Eine Variable auf None zu setzen, ist ganz einfach:
let nothing: Option<u32> = None; // Variable nothing is set to None
Wenn du aber möchtest, dass der Typ Option einen Wert trägt, kannst du diesen Wert nicht direkt zuweisen.
Eine Variable vom Typ Option und zum Beispiel eine Variable vom Typ i32 sind nicht dasselbe.
Du musst Some verwenden:
let wrong_way: Option<i32> = -4; // This will not work
let right_way: Option<i32> = Some(-4); // This will work
let another_right_way = Some(-4); // Compiler infers that this is Option<i32>
Aus demselben Grund funktioniert auch Folgendes nicht:
let number = 47;
let option_number = Some(15);
let compile_error = number + option_number; // Cannot add an i32 and an Option<i32> - they are of different types
Wenn du den Wert erhalten möchtest, den Some enthält, musst du zuerst prüfen, ob er existiert:
let mut some_words = Some("choose something to say"); // some_words set to something
match some_words {
Some(str) => println!("Here, we will {}", str),
None => println!("I've got nothing to say"),
} // Prints "Here, we will choose something to say"
some_words = None; // some_words now set to None
// exactly the same match block as above
match some_words {
Some(str) => println!("Here, we will {}", str),
None => println!("I've got nothing to say"),
} // Prints "I've got nothing to say"
Neben match hat Rust noch andere Werkzeuge, um Werte in Option zu prüfen und auf sie zuzugreifen, aber match dürfte dir inzwischen vertraut sein.
Sieh das außerdem als Demonstration dafür, warum Rust Option statt einer Null-Referenz verwendet.
Der Punkt ist, dass du musst prüfen, ob die Option-Variable Some ist (in diesem Fall kannst du den enthaltenen Wert herausziehen und verwenden) oder None.
Bei allem anderen lässt sich dein Programm nicht kompilieren; der Compiler bewahrt dich vor null.
Lernübung
