V tomto článku sa dozviete o voliteľnom vybavení, jeho prípadoch použitia a voliteľnom zaobchádzaní v prostredí Swift.
V predchádzajúcom článku sme sa dozvedeli o rôznych dátových typoch dostupných v aplikácii Swift a tiež sme si všimli, že premenná alebo konštanta deklarované z týchto typov obsahujú predvolenú hodnotu.
Príklad:
nechajte someValue = Int () print (someValue)
Po spustení programu bude výstup:
0
Vo Swifte však existuje iný dátový typ s názvom Optional, ktorého predvolená hodnota je nulová hodnota ( nil). Voliteľné môžete použiť, ak chcete, aby premenná alebo konštanta v nej neobsahovali žiadnu hodnotu. Voliteľný typ môže obsahovať hodnotu alebo absenciu hodnoty (nulová hodnota).
Z technického hľadiska si môžete myslieť, že je to krabica od topánok. Krabica na topánky môže, ale nemusí obsahovať topánku. Mali by ste to vedieť najskôr pri prístupe k topánke z krabice.
Ako vyhlásiť voliteľné?
Dátový typ môžete jednoducho reprezentovať ako voliteľný pripojením !alebo ?k Type. Ak voliteľný údaj obsahuje hodnotu, vráti hodnotu ako Optional, ak nie, vráti hodnotu nil.
Príklad 1: Ako deklarovať voliteľné v Swifte?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Po spustení programu bude výstup:
nil nil
Vo vyššie uvedenom programe sme inicializovali voliteľný typ pomocou ?a !. Na vytvorenie voliteľného prvku sú platné oba spôsoby, ale je tu jeden zásadný rozdiel, ktorý preskúmame nižšie.
Deklarovanie voliteľného Int znamená, že premenná bude mať celočíselnú hodnotu alebo žiadnu hodnotu. Pretože premennej nie je priradená žiadna hodnota, môžete na obrazovke vidieť oba printvýstupy výpisu nil.
Príklad 2: Priradenie a prístup k hodnote z voliteľného prvku
let someValue:Int? = 5 print(someValue) print(someValue!)
Po spustení programu bude výstup:
Voliteľné (5) 5
Vo vyššie uvedenom programe sme deklarovali voliteľnú hodnotu Inttypu a v nej sme priradili hodnotu 5.
Ako vidíte, tlač voliteľnej položky ako print(someValue)vám nedá, 5ale Optional(5). To je v tvare, ako je popísané vyššie: Optional. Na prístup z neho potrebujeme mechanizmus, ktorý sa nazýva rozbaľovanie .
Voliteľné môžete rozbaliť pripojením !znaku na koniec premennej / konštanty, ako v nasledujúcom riadku print(someValue!). print(someValue!)rozbalí voliteľné a výstupy 5na obrazovku.
Pamätajte však, že tento druh rozbaľovacieho mechanizmu by sa mal používať iba v prípade, že ste si istí, že voliteľný modul bude mať pri prístupe určite svoju hodnotu.
Príklad 3: Výslovné vyhlásenie nerozbaleného voliteľného prvku
Môžete tiež vytvoriť nezabalenú voliteľnú položku ako:
let someValue:Int! = 5 print(someValue)
Po spustení programu bude výstup:
5
Vo vyššie uvedenom programe Int!vytvorí nerozbalený voliteľný prvok, ktorý automaticky rozbalí hodnotu, keď k nej získate prístup, takže nemusíte !znak vždy pridávať .
Pri používaní týchto druhov voliteľných doplnkov buďte istí, že premenná bude musieť mať pri svojom prístupe vždy hodnotu. Ak tak neurobíte, dostanete fatálnu chybu.
Príklad 4: Závažná chyba pri prístupe k nulovo rozbalenému voliteľnému prvku
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Pri spustení programu sa zobrazí zlyhanie ako závažná chyba: pri rozbaľovaní voliteľnej hodnoty sa neočakávane našlo nič, pretože sa kód unwrappedValue:Int = someValuepokúsi priradiť hodnotu z voliteľnej someValue k premennej unfrappedValue.
Somevalue je však Optionaltyp, ktorý obsahuje nilhodnotu. Pokus o priradenie nulovej hodnoty premennej unwrappedValue, ktorá nie je voliteľná, povedie k zlyhaniu.
Ďalej sú vysvetlené rôzne techniky riešenia tohto prípadu.
Voliteľné zaobchádzanie
Ak chcete použiť hodnotu voliteľného prvku, je potrebné ho rozbaliť. Lepší spôsob použitia voliteľnej hodnoty je skôr podmienené rozbalenie ako vynútené rozbalenie pomocou !operátora.
Je to preto, že podmienečne rozbalenie sa pýta Skontrolovať, či má táto premenná hodnotu? . Ak áno, uveďte hodnotu, inak zvládne nulový prípad.
Naopak, rozbaľovanie silou hovorí, že táto premenná má hodnotu, keď ju používate . Preto keď vynútite rozbalenie premennej, ktorá je nulová, váš program vyhodí neočakávane nájdenú nulu a zároveň rozbalí voliteľnú výnimku a zlyhá . Niektoré z techník podmieneného rozbalenia sú vysvetlené nižšie:
1. If-vyhlásenie
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
Vo vyššie uvedenom programe je premenná someValue definovaná ako voliteľná a obsahuje nulovú hodnotu. Operátor nulového spájania zlyhá pri rozbalení voliteľnej položky, preto vráti defaultValue. Preto vyhlásenie print(unwrappedValue)vydá 5 v konzole.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Po spustení programu bude výstup:
10
Avšak vo vyššie uvedenom programe je voliteľná premenná someValue inicializovaná s hodnotou 10. Takže nulový operátor spojenia úspešne rozbalí hodnotu z someValue. Príkaz preto someValue ?? defaultValuevráti 10 a print(unwrappedValue)výstup z výstupu 10 v konzole.
