I denne artikel lærer du om valgfri, dens brugssager og valgfri håndtering i Swift.
I den forrige artikel lærte vi om forskellige datatyper, der var tilgængelige i Swift, og bemærkede også, at variabel eller konstant deklareret af disse typer indeholder en standardværdi.
Eksempel:
lad someValue = Int () udskrive (someValue)
Når du kører programmet, vil output være:
0
Der er dog en anden datatype i Swift kaldet Valgfri, hvis standardværdi er en nulværdi ( nil). Du kan bruge valgfrit, når du vil have en variabel eller konstant, der ikke indeholder nogen værdi i den. En valgfri type kan indeholde en værdi eller fraværende en værdi (en nulværdi).
Ikke teknisk kan du tænke valgfri som en skokasse. Skokassen indeholder eller kan ikke indeholde en sko i den. Så du skal vide det på forhånd, mens du får adgang til skoen fra kassen.
Hvordan erklæres en valgfri?
Du kan simpelthen repræsentere en datatype som valgfri ved at tilføje !eller ?til Type. Hvis en valgfri indeholder en værdi i den, returnerer den værdien som Optional, hvis den ikke returnerer nil.
Eksempel 1: Hvordan erklæres en valgfri i Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Når du kører programmet, vil output være:
nul nul
I ovenstående program har vi initialiseret en valgfri type ved hjælp af ?og !. Begge måder er gyldige for at oprette en valgfri, men der er en stor forskel, som vi vil undersøge nedenfor.
At erklære en valgfri Int betyder, at variablen enten vil have et heltal eller ingen værdi. Da der ikke er tildelt nogen værdi til variablen, kan du se begge printsætningsoutputs nilpå skærmen.
Eksempel 2: Tildeling og adgang til en værdi fra en valgfri
let someValue:Int? = 5 print(someValue) print(someValue!)
Når du kører programmet, vil output være:
Valgfri (5) 5
I ovenstående program har vi deklareret en valgfri Inttype og tildelt værdi 5 i den.
Som du kan se, udskriver det valgfri som print(someValue)ikke giver dig, 5men Optional(5). Det er af formen som beskrevet ovenfor: Optional. For at få adgang til det fra det har vi brug for en mekanisme kaldet udpakning .
Du kan pakke et valgfrit ud ved at tilføje !tegn i slutningen af variablen / konstanten som i næste linje print(someValue!). print(someValue!)pakker ekstraudstyr og output ud 5på skærmen.
Husk dog, at denne form for udpakningsmekanisme kun skal bruges, når du er sikker på, at det valgfri vil helt sikkert have en værdi, når du får adgang til det.
Eksempel 3: Erklærer eksplicit en uindpakket valgfri
Du kan også oprette en ikke-pakket valgfri som:
let someValue:Int! = 5 print(someValue)
Når du kører programmet, vil output være:
5
I ovenstående program Int!opretter du en uindpakket valgfri, som automatisk pakker værdien ud, mens du får adgang til den, så du ikke behøver at tilføje !tegnet hver gang .
Vær sikker, mens du bruger denne slags optioner, skal variablen altid have en værdi, når du får adgang til den. Hvis du ikke gør det, får du et fatalt fejlnedbrud.
Eksempel 4: Alvorlig fejl, når du får adgang til en valgfri null udpakket
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Når du kører programmet, får du et nedbrud som en fatal fejl: uventet fundet nul, mens du pakker en valgfri værdi ud, fordi koden unwrappedValue:Int = someValueforsøger at tildele værdi fra Valgfri someValue til variabel unwrappedValue.
Imidlertid er en værdi en Optionaltype, der indeholder nilværdi. Forsøg på at tildele nulværdi til variabel unwrappedValue, som ikke er valgfri, fører til nedbrud.
Der er forskellige teknikker til håndtering af denne sag, som forklares nedenfor.
Valgfri håndtering
For at kunne bruge værdien af en valgfri skal den pakkes ud. Bedre måde at bruge valgfri værdi er ved betinget udpakning snarere end at tvinge udpakning ved hjælp af !operatøren.
Dette skyldes, at betinget udpakning spørger Kontroller, om denne variabel har en værdi? . Hvis ja, angiv værdien, ellers håndterer den nul-sagen.
Tværtimod siger kraftudpakning, at denne variabel har en værdi, mens du bruger den . Derfor, når du tvinger udpakning af en variabel, der er nul, kaster dit program en uventet fundet nul, mens du pakker ud en valgfri undtagelse og går ned . Nogle af teknikkerne til betinget udpakning forklares nedenfor:
1. Hvis-erklæring
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
I ovenstående program er variabel someValue defineret valgfri og indeholder nulværdi. Nul-koalescerende operatør undlader at pakke det valgfri ud, returnerer derfor defaultValue. Derfor print(unwrappedValue)udsender erklæringen 5 i konsollen.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Når du kører programmet, vil output være:
10
Imidlertid initialiseres valgfri variabel someValue i ovenstående program med værdi 10. Så den nul-koalescerende operatør pakker værdien succesfuldt ud fra someValue. Derfor someValue ?? defaultValuereturnerer sætningen 10, og udsagnet print(unwrappedValue)output 10 i konsollen.
