Correctif pour «nul trouvé de manière inattendue lors du déballage d'une valeur facultative - AppyPie (2023)

Retour au blog

ParAsif Khan|Dernière mise à jour le 12 juillet 202313:59|4 minutes de lecture

Les options sont une fonctionnalité intéressante de Swift, mais si vous ne les déballez pas en toute sécurité, vous rencontrerez le nil trouvé de manière inattendue lors du déballage d'une erreur de valeur facultative. Comment pouvez-vous résoudre cette erreur ?

Dans ce didacticiel, vous découvrirez :

• Options et comment les utiliser
• Correction du nil trouvé de manière inattendue lors du déballage d'une erreur de valeur facultative
• Déballage en toute sécurité des options

Comprendre les options et corriger les bogues est une partie importante du développement iOS. Il est essentiel de comprendre les options en tant que développeur d'applications !

Dans Swift, les options sont un type générique spécial qui...

… peut contenir une valeur
… ou aucune valeur (néant)

Une variable ne peut être nulle que lorsqu'elle est facultative. Vous déclarez une option comme ceci :

laissez le sensDeLaVie : Int ? = 42

Le point d'interrogation ? à la fin de la déclaration de type indique que la variable meaningOfLife est facultative. Par conséquent, ce code est OK :

sensDeLaVie = néant

La variable meaningOfLife est facultative, elle peut donc être nulle. L'exemple suivant, cependant, n'est pas valide :

laissez l'âge: Int = 99
age = nil // Cette ligne n'est pas OK

Parce que l'âge n'est pas une option, il ne peut pas être nul !

Les options sont une fonctionnalité puissante de Swift, car elles rendent votre code plus sûr et moins sujet aux erreurs. Par conséquent, les options vous rendent plus productif en tant que développeur, car vous passez moins de temps à corriger les bogues.

Pourquoi utiliser des options ?

Mais… pourquoi avez-vous besoin d'options ?

Vous savez déjà ce que sont les variables. Dans le code de votre application, certaines variables peuvent n'avoir aucune valeur à certains moments :

• Lorsqu'un contrôleur de vue n'a pas encore été chargé, l'outlet pour textLabel n'a pas de valeur
• Lorsque vous obtenez une paire clé-valeur à partir d'un dictionnaire avec une syntaxe en indice, comme items["food"], le résultat peut n'avoir aucune valeur, car la clé "food" peut ne pas exister dans le dictionnaire
• Lorsque vous souhaitez accéder au contrôleur de navigation pour un contrôleur de vue avec la propriété navigationController, il ne peut avoir aucune valeur, car le contrôleur de vue n'est pas encapsulé dans un contrôleur de navigation

Dans Swift, une option peut soit avoir une valeur ordinaire, soit être nulle. Lorsqu'une variable n'a pas de valeur, elle est nulle.

Presque tous les langages de programmation ont quelque chose de similaire à nil. Il est indéfini en JavaScript, nul en Java et NULL en PHP. Dans ces langages, pour éviter les erreurs d'exécution avec des variables qui n'ont pas de valeur, il faut penser à vérifier si une variable est nulle. Tu pourrais oublier ça !

Swift gère les options d'une manière spéciale : il oblige le développeur à vérifier si une variable est nulle, si c'est une option. C'est ce qu'on appelle le déballage. Vous devez déballer une option avant de pouvoir l'utiliser.

Lorsque vous avez oublié de déballer une option, vous le saurez avant l'exécution de votre application, ce qui vous fera gagner du temps. Cela vous rend plus productif et votre code moins bogué.

Contrairement à d'autres langages, Swift vérifiera si les options sont correctement déballées au moment de la compilation. Ainsi, avant l'exécution de l'application, lorsque le code est compilé, Swift vérifiera toutes les options de votre code et verra si vous l'avez correctement déballé.

Malheureusement, certaines erreurs ne peuvent pas être détectées par le compilateur. C'est alors que vous verrez cette erreur :

erreur fatale : Nil trouvé de manière inattendue lors du déballage d'une valeur facultative
Cela se produit lorsque votre application est en cours d'exécution, dans les scénarios suivants :

• Vous avez déballé de force une option avec !
• Une option non emballée implicitement est nil

Dans 99 % des cas, vous avez déballé de force une option avec ! et c'était nul, c'est donc le premier endroit à regarder lorsque vous rencontrez cette erreur.

Résumer:

1. Les options sont des types de variables qui peuvent soit contenir une valeur, soit être nulles
2. Vous devez déballer une option avant de pouvoir l'utiliser
3. Parce que vous êtes obligé de vérifier si une valeur est nulle avant d'exécuter votre application, vous êtes plus productif en tant que développeur et votre code a moins de bugs

Le scénario le plus courant pour l'erreur fatale : Nil trouvé de manière inattendue lors du déballage d'une erreur de valeur facultative est lorsque vous avez forcé le déballage d'un facultatif et qu'il était nul.

Voici un exemple :

laisser nom d'utilisateur : chaîne ? = "Alice"
let message = "Bienvenue", + nom d'utilisateur !
imprimer (message)
// Sortie : Bienvenue, Alice

Jusqu'ici, tout va bien. C'est ce qui se passe dans le code :

1. Vous créez une variable appelée nom d'utilisateur. C'est un facultatif de type String, et on lui attribue la chaîne "Alice"
2. Vous créez une variable appelée message et lui attribuez la valeur "Bienvenue" et le nom d'utilisateur. Le nom d'utilisateur facultatif est déballé de force avec !.
3. Vous imprimez le message et le résultat est : Bienvenue, Alice.

Supposons maintenant que ce code puisse s'exécuter avant que l'utilisateur ne se soit connecté. Lorsque l'utilisateur ne s'est pas connecté, le nom d'utilisateur est nul - c'est pourquoi il est facultatif.

Un formulaire de connexion est présenté à l'utilisateur, mais avant que l'utilisateur puisse se connecter, le code ci-dessus s'exécute déjà. Ce qui se produit?

laisser nom d'utilisateur : chaîne ? = nul
let message = "Bienvenue", + nom d'utilisateur !

Voici ce qui se passe :

erreur fatale : zéro trouvé de manière inattendue lors du déballage d'une valeur facultative

C'est parce que vous avez forcé le déballage de l'optionnel et qu'il était nul. Vous auriez bien sûr pu éviter d'exécuter ce morceau de code avant que l'utilisateur ne se connecte. Cependant, la plupart des applications ont de nombreuses parties mobiles qui s'exécutent indépendamment, et vous ne pouvez pas toujours éviter qu'un morceau de code s'exécute avant ou après l'autre.

Comment le résolvez-vous ? Facile!

laisser nom d'utilisateur : chaîne ? = nul

si nom d'utilisateur != néant {
let message = "Bienvenue", + nom d'utilisateur !
imprimer (message)
}

Avant de forcer le déballage du nom d'utilisateur, vous vérifiez avec une instruction if si le nom d'utilisateur est nil. Lorsque le nom d'utilisateur est nil, le code à l'intérieur des crochets ondulés { } n'est pas exécuté.

Cependant, il existe une manière beaucoup plus élégante de déballer les options. Continuer à lire!

Options implicitement déballées

Un autre scénario pour l'erreur Nil trouvée de manière inattendue lors du déballage d'une valeur facultative est lorsque vous avez utilisé des options implicitement déballées.

Les options implicitement déballées sont des options que vous n'avez pas à déballer. Comme leur nom l'indique, ils se déballent automatiquement lorsque vous les utilisez.

Comme ça:

laissez nom d'utilisateur : chaîne ! = "Alice"
let message = "Bonjour", + nom d'utilisateur
imprimer (message)
// Sortie : Bonjour, Alice

Il y a deux choses différentes dans cet exemple :

• le nom d'utilisateur est implicitement déballé avec le !, après la chaîne
• le nom d'utilisateur n'a pas besoin d'être déballé sur la deuxième ligne

Logiquement, lorsque le nom d'utilisateur vaut nil, le code plante à nouveau :

laissez nom d'utilisateur : chaîne ! = nul
let message = "Bonjour", + nom d'utilisateur
imprimer (message)

Cela affichera :

erreur fatale : zéro trouvé de manière inattendue lors du déballage d'une valeur facultative

Alors pourquoi utiliser des options implicitement déballées ?

• Certains SDK Cocoa Touch utiliseront des options implicitement déballées. Vous pouvez savoir quel est le type de n'importe quelle variable, dans Xcode, en cliquant dessus tout en maintenant la touche Alt enfoncée. Cependant, les options implicitement déballées deviennent rares dans les SDK.
• Parfois, vous avez créé une structure ou une classe, et certaines de ses propriétés sont nulles avant d'initialiser la classe, mais ne seront jamais nulles après. Dans ce cas, cela vous fait économiser pas mal de code (pour le déballage) si vous utilisez des options implicitement déballées. C'était une convention avant Swift 3, mais il est en fait tout aussi pratique et beaucoup plus sûr d'utiliser des options et une liaison optionnelle (nous en reparlerons plus tard).

Si vous débutez avec le codage Swift, il est recommandé de ne pas utiliser d'options implicitement déballées, sauf si vous avez un besoin spécifique de le faire.

Si vous avez créé une option implicitement déballée pour éviter la douleur de déballer constamment des variables, détrompez-vous - vous jetez l'une des fonctionnalités les plus sûres, les plus puissantes et les plus productives de Swift !

La meilleure façon d'éviter le nil trouvé de manière inattendue lors du déballage d'une erreur de valeur facultative est d'apprendre à déballer en toute sécurité les options.

Vous pouvez utiliser 3 façons de déballer les options :

• Forcer le déballage avec !
• Liaison optionnelle avec if let …
• Chaînage optionnel avec ?

Vous avez déjà utilisé le déballage forcé. Vous n'utiliserez le déballage forcé que si vous êtes absolument certain que la variable ne sera pas nulle lorsque vous y accéderez.

Si vous n'êtes pas sûr, utilisez une liaison facultative. Supposons que vous ayez codé une prise de contrôleur de vue, comme ceci :

@IBOutlet faible var textLabel : UILabel ?

C'est une option, comme indiqué par le ?. Lorsque vous souhaitez l'utiliser, par exemple dans viewDidLoad(), vous pouvez utiliser une liaison facultative pour déballer l'option :

si let label = textLabel {
label.text = "HOURRA !!"
}

Entre les crochets ondulés, une étiquette de constantes est déclarée et reçoit la valeur de textLabel. Cela ne se produit que lorsque textLabel n'est pas nul !

En d'autres termes, lorsque textLabel n'est pas nul, vous créez une nouvelle étiquette constante, en lui attribuant la valeur de textLabel et en exécutant également le code dans l'instruction if. C'est hyper efficace !

De même, vous pouvez également utiliser le chaînage facultatif. Comme ça:

textLabel?.text = "HOURRA !!"

Ce code est exactement le même que l'exemple ci-dessus, mais il utilise un chaînage facultatif au lieu d'une liaison facultative. Voir le ? après textLabel ? Lorsque textLabel vaut nil, la ligne cesse de s'exécuter. Vous ne pouvez pas accéder au texte de la propriété sur une valeur nulle, donc avec un chaînage facultatif, vous pouvez éviter que le code continue à s'exécuter.

Vous pouvez même créer une chaîne entière :

soit url = utilisateur?.données?.avatar?.url
imprimer (url)
Dans l'exemple ci-dessus, l'url sera nulle lorsque l'utilisateur, les données ou l'avatar seront nuls ! Vous pouvez même combiner chaînage optionnel et reliure optionnelle :

si laissez url = utilisateur?.données?.avatar?.url {
imprimer (url)
}

Dans l'exemple ci-dessus, la constante url n'est imprimée que lorsqu'aucune des propriétés n'est nulle.

Lectures complémentaires

Les options peuvent être difficiles à comprendre, mais une fois que vous avez compris comment les déballer en toute sécurité, vous pouvez être sûr que vous obtiendrez cette erreur beaucoup moins souvent :

erreur fatale : Nil trouvé de manière inattendue lors du déballage d'une valeur facultative
Voici ce qu'il faut garder à l'esprit :

• 99 % du temps, l'erreur ci-dessus est causée par une option non emballée de force qui est nulle. Vous pouvez le réparer en évitant qu'il ne devienne nul, ce qui n'est parfois pas possible, alors vous utilisez une liaison optionnelle ou un chaînage optionnel.
• Évitez d'utiliser des options implicitement déballées lorsque vous le pouvez, sauf si vous avez un besoin spécifique de les utiliser.
• Prenez l'habitude d'utiliser les options en toute sécurité et votre code contiendra moins de bogues. Utilisez le déballage forcé, les instructions if, la liaison facultative ou le chaînage optionnel pour déballer les options.