In dit artikel leert u over optioneel, de gebruiksscenario's en optionele afhandeling in Swift.
In het vorige artikel hebben we geleerd over verschillende gegevenstypen die beschikbaar zijn in Swift en hebben we ook opgemerkt dat de gedeclareerde variabele of constante van die typen een standaardwaarde bevat.
Voorbeeld:
laat someValue = Int () print (someValue)
Wanneer u het programma uitvoert, is de uitvoer:
0
Er is echter een ander gegevenstype in Swift genaamd Optioneel, waarvan de standaardwaarde een null-waarde ( nil) is. U kunt optioneel gebruiken als u wilt dat een variabele of constante geen waarde bevat. Een optioneel type kan een waarde bevatten of een waarde ontbreken (een null-waarde).
Niet technisch gezien kun je als schoenendoos optioneel denken. De schoenendoos kan al dan niet een schoen bevatten. U moet het dus van tevoren weten wanneer u de schoen uit de doos haalt.
Hoe een optioneel aangeven?
U kunt een gegevenstype eenvoudig weergeven als optioneel door !of toe ?te voegen aan het Type. Als een optioneel een waarde bevat, retourneert het een waarde als Optional, zo niet, wordt het geretourneerd nil.
Voorbeeld 1: Hoe geef ik een optioneel aan in Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Wanneer u het programma uitvoert, is de uitvoer:
nihil nihil
In het bovenstaande programma hebben we een optioneel type geïnitialiseerd met ?en !. Beide manieren zijn geldig om een optioneel te maken, maar er is één groot verschil dat we hieronder zullen onderzoeken.
Het declareren van een optionele Int betekent dat de variabele een geheel getal of geen waarde heeft. Aangezien er geen waarde aan de variabele is toegewezen, kunt u beide printinstructie-uitvoer nilop het scherm zien.
Voorbeeld 2: een waarde toewijzen en openen vanuit een optional
let someValue:Int? = 5 print(someValue) print(someValue!)
Wanneer u het programma uitvoert, is de uitvoer:
Optioneel (5) 5
In het bovenstaande programma hebben we een optioneel Inttype verklaard en de waarde 5 erin toegewezen.
Zoals u kunt zien, geeft het afdrukken van de optionele as print(someValue)u geen 5maar Optional(5). Het is van het type zoals hierboven beschreven Optional. Om er toegang toe te krijgen , hebben we een mechanisme nodig dat we uitpakken .
U kunt een optioneel uitpakken door een !teken aan het einde van de variabele / constante toe te voegen, zoals op de volgende regel print(someValue!). print(someValue!)pakt de optionele en uitgangen uit 5op het scherm.
Onthoud echter dat dit soort uitpakmechanisme alleen mag worden gebruikt als u er zeker van bent dat het optionele zeker een waarde zal hebben wanneer u het opent.
Voorbeeld 3: expliciet een uitgepakt optioneel declareren
U kunt ook een uitgepakte optie maken als:
let someValue:Int! = 5 print(someValue)
Wanneer u het programma uitvoert, is de uitvoer:
5
Int!Creëert in het bovenstaande programma een uitgepakte optie, die automatisch de waarde uitpakt terwijl u deze opent, zodat u niet elke keer het !karakter hoeft toe te voegen .
Wees er zeker van dat terwijl u dit soort opties gebruikt, de variabele altijd een waarde moet hebben wanneer u deze opent. Als u dat niet doet, krijgt u een fatale foutcrash.
Voorbeeld 4: Fatale fout bij het openen van een null uitgepakt optioneel
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Wanneer u het programma uitvoert, krijgt u een crash als fatale fout: onverwachts nul gevonden tijdens het uitpakken van een optionele waarde omdat de code unwrappedValue:Int = someValueprobeert een waarde toe te kennen van Optioneel someValue aan variabele untrappedValue.
Een bepaalde waarde is echter een Optionaltype dat nilwaarde bevat . Proberen om een nulwaarde toe te wijzen aan de variabele unsrappedValue die niet optioneel is, zal leiden tot een crash.
Er zijn verschillende technieken om deze zaak te behandelen, die hieronder worden uitgelegd.
Optionele afhandeling
Om de waarde van een optie te gebruiken, moet deze worden uitgepakt. Een betere manier om optionele waarde te gebruiken is door voorwaardelijk uitpakken in plaats van geforceerd uitpakken met de !operator.
Dit komt omdat voorwaardelijk uitpakken vraagt: Controleer of deze variabele een waarde heeft? . Zo ja, geef de waarde op, anders wordt het nihilgeval behandeld.
Integendeel, geforceerd uitpakken zegt dat deze variabele een waarde heeft terwijl u deze gebruikt . Daarom zal je programma, wanneer je een variabele die nihil is geforceerd uitpakken, een onverwacht gevonden nihil gooien terwijl het een optionele uitzondering uitpakt en crasht . Enkele van de technieken voor voorwaardelijk uitpakken worden hieronder uitgelegd:
1. If-verklaring
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
In het bovenstaande programma is de variabele someValue optioneel gedefinieerd en bevat deze een nulwaarde. De nulcoalescing-operator slaagt er niet in de optionele uit te pakken en retourneert daarom defaultValue. Daarom print(unwrappedValue)voert de instructie 5 uit in de console.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Wanneer u het programma uitvoert, is de uitvoer:
10
In het bovenstaande programma wordt de optionele variabele someValue echter geïnitialiseerd met waarde 10. De operator nil coalescing pakt dus met succes de waarde uit someValue uit. Daarom someValue ?? defaultValueretourneert de instructie 10 en print(unwrappedValue)voert de instructie 10 uit in de console.
