Références nulles
Si tu as déjà utilisé un autre langage de programmation (C/C++, Python, Java, Ruby, Lisp, etc.), il est probable que tu aies déjà rencontré null ou nil.
L'utilisation de null ou nil est la façon dont ces langages indiquent qu'une variable donnée n'a pas de valeur.
Cependant, il est alors facile (et fréquent) d'utiliser par accident une variable qui pointe vers null.
Comme tu peux l'imaginer, essayer d'appeler une fonction qui n'existe pas ou d'accéder à une valeur qui n'existe pas peut entraîner toutes sortes de bugs et de plantages.
Le créateur de null est même allé jusqu'à l'appeler son « erreur à un milliard de dollars ».
Le type Option
Pour éviter ces problèmes, Rust n'utilise pas de références nulles.
Cependant, il a toujours besoin d'un moyen sûr d'indiquer qu'une variable donnée n'a pas de valeur.
C'est là que Option entre en jeu.
Au lieu d'avoir une variable dépourvue de valeur, les variables Rust peuvent utiliser l'énumération Option.
Cette énumération a deux variantes : None, l'équivalent de null en Rust ; et Some(T), où T est une valeur de n'importe quel type.
Elle ressemble à ceci :
enum Option<T> {
None,
Some(T),
}
Tu peux voir Option comme une couche de sécurité entre toi et les problèmes que peuvent causer les références nulles, tout en conservant leur utilité conceptuelle.
Utiliser Option
Affecter None à une variable est assez simple :
let nothing: Option<u32> = None; // Variable nothing is set to None
Cependant, si tu veux que le type Option porte une valeur, tu ne peux pas affecter cette valeur directement.
Une variable de type Option et, disons, une variable de type i32 ne sont pas équivalentes.
Tu devras utiliser Some :
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>
C'est aussi pour cette raison que ce qui suit ne fonctionnera pas :
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
Si tu veux récupérer la valeur contenue dans Some, tu devras d'abord vérifier qu'elle existe :
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"
Outre match, Rust dispose d'autres outils pour vérifier et accéder aux valeurs contenues dans Option, mais match devrait t'être familier maintenant.
De plus, vois-y une démonstration de la raison pour laquelle Rust utilise Option au lieu d'une référence nulle.
L'idée, c'est que tu dois vérifier si la variable Option vaut Some (auquel cas tu peux extraire et utiliser la valeur qu'elle contient) ou None.
Dans tout autre cas, ton programme ne compilera pas ; le compilateur te protège de null.
Exercice d'apprentissage
