Dans cet article, vous découvrirez les options facultatives, ses cas d'utilisation et la gestion facultative dans Swift.
Dans l'article précédent, nous avons découvert les différents types de données disponibles dans Swift et avons également remarqué que la variable ou la constante déclarée de ces types contient une valeur par défaut.
Exemple:
laissez someValue = Int () print (someValue)
Lorsque vous exécutez le programme, la sortie sera:
0
Cependant, il existe un autre type de données dans Swift appelé Optional, dont la valeur par défaut est une valeur nulle ( nil). Vous pouvez utiliser facultatif lorsque vous souhaitez qu'une variable ou une constante ne contienne aucune valeur. Un type facultatif peut contenir une valeur ou en l'absence d'une valeur (une valeur nulle).
Non techniquement, vous pouvez penser en option comme une boîte à chaussures. La boîte à chaussures peut contenir ou non une chaussure. Donc, vous devez savoir à l'avance en accédant à la chaussure depuis la boîte.
Comment déclarer un optionnel?
Vous pouvez simplement représenter un type de données comme facultatif en ajoutant !ou ?au Type. Si un optionnel contient une valeur, il renvoie la valeur comme Optional, sinon il retourne nil.
Exemple 1: Comment déclarer un optionnel dans Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Lorsque vous exécutez le programme, la sortie sera:
néant néant
Dans le programme ci-dessus, nous avons initialisé un type optionnel en utilisant ?et !. Les deux méthodes sont valables pour créer une option mais il existe une différence majeure que nous explorerons ci-dessous.
Déclarer un Int facultatif signifie que la variable aura une valeur entière ou aucune valeur. Puisqu'aucune valeur n'est affectée à la variable, vous pouvez voir les deux printsorties d'instructions nilà l'écran.
Exemple 2: attribution et accès à une valeur à partir d'un
let someValue:Int? = 5 print(someValue) print(someValue!)
Lorsque vous exécutez le programme, la sortie sera:
En option (5) 5
Dans le programme ci-dessus, nous avons déclaré un optionnel de Inttype et attribué la valeur 5.
Comme vous pouvez le voir, l'impression de l'option en tant print(someValue)que ne vous donne pas 5mais Optional(5). Il est de la forme comme décrit ci - dessus: Optional. Pour y accéder , nous avons besoin d'un mécanisme appelé déroulement .
Vous pouvez dérouler une option en ajoutant un !caractère à la fin de la variable / constante comme dans la ligne suivante print(someValue!). print(someValue!)déballe l'option et les sorties 5à l'écran.
Cependant, rappelez-vous que ce type de mécanisme de déballage ne doit être utilisé que lorsque vous êtes certain que l'option optionnelle aura une valeur lorsque vous y accédez.
Exemple 3: déclarer explicitement un optionnel non emballé
Vous pouvez également créer un optionnel non emballé comme:
let someValue:Int! = 5 print(someValue)
Lorsque vous exécutez le programme, la sortie sera:
5
Dans le programme ci-dessus, Int!crée un optionnel non emballé, qui déballe automatiquement la valeur pendant que vous y accédez afin que vous n'ayez pas besoin d'ajouter à chaque fois le !caractère.
Assurez-vous que lorsque vous utilisez ces types d'options, la variable devra toujours avoir une valeur lorsque vous y accédez. Si vous ne le faites pas, vous obtiendrez un crash d'erreur fatale.
Exemple 4: erreur fatale lors de l'accès à un null déballé facultatif
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Lorsque vous exécutez le programme, vous obtiendrez un plantage en tant qu'erreur fatale: inopinément trouvé nil lors du déballage d'une valeur facultative car le code unwrappedValue:Int = someValuetente d'attribuer la valeur de Optional someValue à la variable unwrappedValue.
Cependant, somevalue est un Optionaltype qui contient une nilvaleur. Essayer d'attribuer une valeur nulle à la variable unwrappedValue qui n'est pas facultative entraînera un crash.
Il existe différentes techniques pour gérer ce cas qui sont expliquées ci-dessous.
Manipulation facultative
Afin d'utiliser la valeur d'un optionnel, il doit être déballé. La meilleure façon d'utiliser une valeur facultative consiste à déballer conditionnellement plutôt qu'à forcer le déballage à l'aide de l' !opérateur.
En effet, le déballage conditionnel demande Vérifier si cette variable a une valeur? . Si oui, donnez la valeur, sinon il gérera le cas nil.
Au contraire, forcer le déballage indique que cette variable a une valeur lorsque vous l'utilisez . Par conséquent, lorsque vous forcez le déballage d'une variable qui est nil, votre programme lèvera un nil trouvé de manière inattendue lors du déballage d'une exception facultative et se bloquera . Certaines des techniques de déballage conditionnel sont expliquées ci-dessous:
1. Instruction If
You can use if statement and compare optional with nil to find out whether a optional contains a value or not. You can use the comparison operator "equal to" operator (==) or the "not equal to" operator (!=) in the if statement.
Example 5: Optional handling with if else statement
var someValue:Int? var someAnotherValue:Int! = 0 if someValue != nil ( print("It has some value (someValue!)") ) else ( print("doesn't contain value") ) if someAnotherValue != nil ( print("It has some value (someAnotherValue!)") ) else ( print("doesn't contain value") )
When you run the program, the output will be:
doesn't contain value It has some value 0
In the above program, the code inside if statement executes if an optional contain a value, otherwise the statement inside the else block executes. The major drawback of optional handling using this technique is, you still need to unwrap the value from optional using ! operator.
2. Optional Binding (if-let)
Optional binding helps you to find out whether an optional contains a value or not. If an optional contains a value, that value is available as a temporary constant or variable. Therefore, optional binding can be used with if statement to check for a value inside an optional, and to extract that value into a constant or variable in a single action.
Example 5: Optional handling using if let statement
var someValue:Int? var someAnotherValue:Int! = 0 if let temp = someValue ( print("It has some value (temp)") ) else ( print("doesn't contain value") ) if let temp = someAnotherValue ( print("It has some value (temp)") ) else ( print("doesn't contain value") )
When you run the program, the output will be:
doesn't contain value It has some value 0
In the above program, the code inside if statement executes if the optional contains a value. Otherwise the else block gets executed. The if-let statement also automatically unwraps the value and places the unwrapped value in temp constant. This technique has major advantage because you don't need to forcely unwrap the value although being certain an optional contains a value.
3. Guard statement
You can use guard to handle optionals in Swift. Don't worry if you don't know what guard is. For now, just think of guard as an if-else condition with no if block. If the condition fails, else statement is executed. If not, next statement is executed. See Swift guard for more details.
Example 6: Optional handling using guard-let
func testFunction() ( let someValue:Int? = 5 guard let temp = someValue else ( return ) print("It has some value (temp)") ) testFunction()
When you run the program, the output will be:
It has some value 5
In the above program, the guard contains a condition whether an optional someValue contains a value or not. If it contains a value then guard-let statement automatically unwraps the value and places the unwrapped value in temp constant. Otherwise, else block gets executed and and it would return to the calling function. Since, the optional contains a value, print function is called.
4. Nil-coalescing operator
In Swift, you can also use nil-coalescing operator to check whether a optional contains a value or not. It is defined as (a ?? b). It unwraps an optional a and returns it if it contains a value, or returns a default value b if a is nil.
Example 7: Optional handling using nil-coalescing operator
var someValue:Int! let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
When you run the program, the output will be:
5
Dans le programme ci-dessus, la variable someValue est définie comme facultative et contient une valeur nulle. L'opérateur de fusion nil ne parvient pas à dérouler l'option facultative et renvoie donc defaultValue. Par conséquent, l'instruction print(unwrappedValue)génère 5 dans la console.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Lorsque vous exécutez le programme, la sortie sera:
dix
Cependant, dans le programme ci-dessus, la variable optionnelle someValue est initialisée avec la valeur 10. Ainsi, l'opérateur de fusion nil désencapsule avec succès la valeur de someValue. Par conséquent, l'instruction someValue ?? defaultValuerenvoie 10 et l'instruction renvoie print(unwrappedValue)10 dans la console.
