I den här artikeln lär du dig om valfritt, dess användningsfall och valfri hantering i Swift.
I den föregående artikeln lärde vi oss om olika datatyper som är tillgängliga i Swift och märkte också att variabel eller konstant deklarerad av dessa typer innehåller ett standardvärde.
Exempel:
låt someValue = Int () skriva ut (someValue)
När du kör programmet blir resultatet:
0
Det finns dock en annan datatyp i Swift som heter Optional, vars standardvärde är ett nullvärde ( nil). Du kan använda valfritt när du vill att en variabel eller konstant inte innehåller något värde i den. En valfri typ kan innehålla ett värde eller frånvarande ett värde (ett nollvärde).
Icke tekniskt kan du tänka valfritt som en skokartong. Skokartongen kan innehålla en sko eller inte. Så du borde veta i förväg när du går åt skon från lådan.
Hur förklarar jag ett valfritt?
Du kan helt enkelt representera en datatyp som valfritt genom att lägga till !eller ?till Type. Om ett valfritt innehåller ett värde i det returnerar det värdet som Optionalom det inte returnerar det nil.
Exempel 1: Hur förklarar jag ett valfritt i Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
När du kör programmet blir resultatet:
noll noll
I ovanstående program har vi initierat en valfri typ med ?och !. Båda sätten är giltiga för att skapa ett valfritt men det är en stor skillnad som vi kommer att undersöka nedan.
Att deklarera ett valfritt Int betyder att variabeln antingen har ett heltal eller inget värde. Eftersom inget värde tilldelas variabeln, kan du se båda printuttalandeutgångarna nilpå skärmen.
Exempel 2: Tilldela och komma åt ett värde från ett valfritt
let someValue:Int? = 5 print(someValue) print(someValue!)
När du kör programmet blir resultatet:
Valfritt (5) 5
I ovanstående program har vi förklarat en valfri Inttyp och tilldelat värde 5 i den.
Som du kan se, att skriva ut tillvalet som print(someValue)inte ger dig 5men Optional(5). Den är av den form som beskrivits ovan: Optional. För att komma åt det från det behöver vi en mekanism som kallas avpakning .
Du kan packa upp ett valfritt genom att lägga till !tecken i slutet av variabeln / konstanten som i nästa rad print(someValue!). print(someValue!)packar upp tillvalet och utgångarna 5på skärmen.
Kom dock ihåg att den här typen av avpakningsmekanism endast bör användas när du är säker på att tillvalet säkert kommer att ha ett värde när du öppnar det.
Exempel 3: Förklarar uttryckligen ett oinpackat valfritt
Du kan också skapa ett oöppnat tillval som:
let someValue:Int! = 5 print(someValue)
När du kör programmet blir resultatet:
5
I ovanstående program Int!skapar du ett oinpackat tillval som automatiskt packar upp värdet medan du öppnar det så att du inte behöver lägga till !karaktären varje gång .
Var säker när du använder den här typen av tillval, variabeln måste alltid ha ett värde när du öppnar den. Om du inte gör det får du en dödlig felkrasch.
Exempel 4: Dödligt fel när du får åtkomst till ett icke-packat tillbehör
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
När du kör programmet kommer du att krascha som ett dödligt fel: oväntat hittat noll när du packar upp ett valfritt värde eftersom koden unwrappedValue:Int = someValueförsöker tilldela värde från Optional someValue till variabel unwrappedValue.
Somevalue är dock en Optionaltyp som innehåller nilvärde. Att försöka tilldela nollvärde till variabel unwrappedValue som inte är valfri leder till krasch.
Det finns olika tekniker för att hantera detta fall som förklaras nedan.
Valfri hantering
För att kunna använda ett valfritt värde måste det packas upp. Bättre sätt att använda valfritt värde är genom villkorlig avpakning snarare än att tvinga att packa upp med !operatören.
Detta beror på att villkorlig avpakning frågar Kontrollera om den här variabeln har ett värde? . Om ja, ge värdet, annars hanterar det nollfallet.
Tvärtom säger kraftuppackning Denna variabel har ett värde medan du använder den . Därför, när du tvingar packa upp en variabel som är noll, kommer ditt program att kasta en oväntat hittad noll medan du packar upp ett valfritt undantag och kraschar . Några av teknikerna för villkorlig packning förklaras nedan:
1. Om-uttalande
Du kan använda if-uttalandet och jämföra valfritt med noll för att ta reda på om ett valfritt innehåller ett värde eller inte. Du kan använda jämförelseoperatören "lika med" operatör ( ==) eller "inte lika med" operatör ( !=) i if-uttalandet.
Exempel 5: Valfri hantering med if iförklaring
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") )
När du kör programmet blir resultatet:
innehåller inte värde Den har något värde 0
I ovanstående program körs koden inuti if-satsen om ett valfritt innehåller ett värde, annars körs satsen i det andra blocket. Den största nackdelen med valfri hantering med denna teknik är att du fortfarande måste packa upp värdet från valfritt med !operatören.
2. Valfri bindning (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 ovanstående program är variabel someValue definierad som valfri och innehåller nollvärde. Noll-sammanslagningsoperatören misslyckas med att packa upp tillvalet och returnerar därför defaultValue. Därför sänder print(unwrappedValue)utdraget 5 i konsolen.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
När du kör programmet blir resultatet:
10
I ovanstående program initialiseras emellertid den valfria variabeln someValue med värdet 10. Så noll-sammanslagningsoperatören packar upp framgångsrikt värdet från someValue. Därför someValue ?? defaultValuereturnerar uttalandet 10 och uttalandet print(unwrappedValue)matar ut 10 i konsolen.
