En Swift, un type optionnel est un type spécial qui permet de représenter une valeur qui peut être soit une valeur réelle, soit une valeur nulle (nil
).
Les types optionnels sont très utiles car ils nous permettent de traiter les valeurs nulles de manière sûre et efficace.
Dans Swift, un type optionnel est représenté par un point d’interrogation ?
.
let myOptionalString: String? = "Hello, world!"
let myString: String = myOptionalString!
Utilisation du nil
Non, non, je ne vais pas te refaire la blague du programmeur sur le Nil, même si c’est très tentant 🤭
L’utilisation du nil
ne peut se faire que sur un type Optionnel, sous peine de bloquer l’exécution du code.
var age: Int? //La valeur par défaut est nil
age = 19
age = nil // Possible
var name: String = "Pomme"
name = nil // Impossible
Dans le premier cas, la valeur nil
est assignée à age
car la variable age
est de type Optional
. Attention, je répète, la variable age
est de type Optional
, ce n’est pas un type Int
!
Déballage des optionnels (Optional unwrapping)
Pour utiliser la valeur stockée dans une variable optionnelle, il faudra la « déballer » (en anglais, « unwrap »). Pour cela, il faudra simplement poser des conditions de cette manière :
var name: String? = "Pomme"
if let myName = name {
print("La valeur \(myName) est bien renseignée.")
} else {
print("Le nom n'est pas renseigné.")
}
De cette manière, nous pouvons extraire de manière sécurisée la valeur de notre variable. La syntaxe if let
peut se traduire par : « si l’optionnel possède une valeur, déballe-la et utilise-la, sinon ne l’utilise pas du tout ».
Forcer le déballage d’un optionnel
Nous venons de voir la manière douce, mais nous pouvons aussi utiliser la manière forte pour déballer un optionnel.
Pour accéder à la valeur d’un optionnel, si tu es sûr(e) que celle-ci n’est pas nulle, tu peux outrepasser sa sécuité en utilisant !
.
var address: String? = "102 micile fixe"
print("Mon adresse ? \(address!).")
Attention, si nous forçons le déballage de notre variable, c’est à nos risques et périls. En effet, si la valeur retournée est nulle, l’application plantera, aussi simplement que ça.
Chaînage d’optionnels (optional chaining)
Il est utilisé pour accéder à des propriétés ou méthode sans risquer de faire planter l’application.
let myObject: MyClass? = MyClass()
let myValue = myObject?.myProperty
Ainsi, en gardant le ?
, on peut accéder à la valeur de la variable myObject
, si elle n’est pas nulle. On appelle cela le chaînage d’optionnels car on pourrait coller derrières d’autres méthodes avec d’autres valeurs optionnelles, presque « à l’infini ».
L’opérateur « nil coalescing »
Ou « opérateur de fusion nul » en français. Il permet de fournir une valeur par défaut lorsqu’une variable optionnelle est nulle. Il est réprésenté par ??
.
let myOptionalString: String? = nil
let myString = myOptionalString ?? "Valeur par défaut"
Si la variable myOptionalString
est nulle, la valeur de myString
sera « Valeur par défaut ». Si myOptionalString
contient une valeur, la valeur de myString
sera celle de myOptionalString
.
Cet opérateur est très utile pour simplifier le code, notamment en évitant des constructions ternaires ou des if/else. Il permet également de fournir une valeur de secours par défaut si la variable optionnelle est nulle. Cela pourrait être utile pour les interfaces utilisateurs ou les valeurs par défaut de configuration.
Mais attention, il ne faut pas l’utiliser avec excès. En effet, il pourrait cacher des erreurs dans le code.
Et voilà, tu en sais plus aujourd’hui sur les types optionnels. Pour d’autres exemples bien illsutrés, je t’invite à suivre le cours de Paul Hudson, toujours un plaisir à lire.
Swift recèle encore de nombreux secrets dont nous allons parler tout prochainement. Prochaine direction : les protocoles !