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 !

Donnes nous ton avis sur les optionnels dans les commentaires. Est-ce que c’est un coup de coeur ?

Si tu as aimé cet article, partage le 🫶