Ebben a cikkben megismerheti a választható opciókat, azok használati eseteit és a Swift opcionális kezelését.
Az előző cikkben megismerkedtünk a Swiftben elérhető különböző adattípusokkal, és azt is észrevettük, hogy az ilyen típusok deklarált változója vagy állandója tartalmaz egy alapértelmezett értéket.
Példa:
hagyja, hogy someValue = Int () nyomtasson (someValue)
A program futtatásakor a kimenet a következő lesz:
0
Van azonban egy másik adattípus a Swift-ben, az Opcionális néven, amelynek alapértelmezett értéke nullérték ( nil). Akkor választható, ha azt szeretné, hogy egy változó vagy konstans ne tartalmazzon értéket. Az opcionális típus tartalmazhat értéket, vagy hiányozhat (nullérték).
Technikailag nem gondolható úgy, hogy választható cipődobozként. A cipősdoboz tartalmazhat cipőt vagy nem. Tehát, előzetesen tudnia kell, miközben hozzáér a cipőhöz a dobozból.
Hogyan lehet deklarálni az Opcionálisat?
Akkor egyszerűen egy Adat típusú opcionális appending !vagy ?a Type. Ha az opcionális tartalmaz egy értéket, akkor az értéket úgy adja vissza Optional, mintha nem nil.
1. példa: Hogyan lehet deklarálni a Swift opcionálisat?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
A program futtatásakor a kimenet a következő lesz:
nulla nulla
A fenti programban egy opcionális típust inicializáltunk a ?és segítségével !. Mindkét módszer érvényes egy opcionális létrehozására, de van egy fő különbség, amelyet az alábbiakban fogunk megvizsgálni.
Az opcionális Int deklarálása azt jelenti, hogy a változónak egész értéke lesz, vagy nincs értéke. Mivel a változóhoz nincs érték rendelve, mindkét printutasítás kimenetet láthatja nila képernyőn.
2. példa: Érték hozzárendelése és elérése opcionálisból
let someValue:Int? = 5 print(someValue) print(someValue!)
A program futtatásakor a kimenet a következő lesz:
Opcionális (5) 5
A fenti programban deklaráltunk egy opcionális Inttípust és 5-ös értéket rendeltünk benne.
Mint láthatja, az opcionális as nyomtatása print(someValue)nem, 5de megadja Optional(5). Ez a forma a fent leírt módon: Optional. Ahhoz, hogy hozzáférjünk a belőle, szükségünk van egy kibontásnak nevezett mechanizmusra .
Kicsomagolhat egy választható opciót !, ha a változó / konstans végéhez karaktert fűz, mint a következő sorban print(someValue!). print(someValue!)kibontja az opcionális és az outputokat 5a képernyőn.
Ne feledje azonban, hogy ezt a fajta kibontási mechanizmust csak akkor szabad használni, ha biztos benne, hogy az opcionálisnak biztosan lesz értéke, amikor belép.
3. példa: A kibontott opcionális explicit deklarálása
Létrehozhat egy kibontott opcionálisat is:
let someValue:Int! = 5 print(someValue)
A program futtatásakor a kimenet a következő lesz:
5.
A fenti programban Int!létrehoz egy kibontott opcionális opciót, amely automatikusan kibontja az értéket, miközben hozzáfér hozzá, hogy ne kelljen mindig hozzáfűznie a !karaktert.
Legyen biztos abban, hogy ilyen típusú opciókat használ, a változónak mindig rendelkeznie kell értékkel, amikor belép. Ha nem, akkor végzetes hiba összeomlik.
4. példa: Végzetes hiba a null kibontott opcionális elérésekor
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
A program futtatásakor végzetes hibát kap egy összeomlás : váratlanul nullát talált, miközben kibontotta az Opcionális értéket, mert a kód unwrappedValue:Int = someValuemegpróbálja az Opcionális someValue értékét hozzárendelni az uncrappedValue változóhoz.
A somevalue azonban olyan Optionaltípus, amely nilértéket tartalmaz . Ha megpróbál null értéket rendelni az unrappedValue változóhoz, amely nem opcionális, összeomláshoz vezet.
Különböző technikák vannak az eset kezelésére, amelyeket az alábbiakban ismertetünk.
Opcionális kezelés
Az opcionális értékének felhasználásához kibontani kell. Az opcionális érték használatának jobb módja a feltételes kibontás, nem pedig az !operátor segítségével történő kibontás .
Ennek oka, hogy a feltételes kibontás megkérdezi, hogy van-e értéke ennek a változónak? . Ha igen, adja meg az értéket, különben a nulla esetet kezeli.
Éppen ellenkezőleg, az erő kibontása azt mondja, hogy ennek a változónak van értéke, amíg használja . Ezért, amikor kénytelen kibontani egy változót, amely nulla, a program váratlanul talált nullát dob, miközben kibontja az opcionális kivételt és összeomlik . A feltételes kibontás néhány technikáját az alábbiakban ismertetjük:
1. If-állítás
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
A fenti programban a someValue változó opcionálisan van meghatározva, és nulla értéket tartalmaz. A nulla egyesítő operátor nem bontja ki az opcionálisat, ezért visszaadja az alapértelmezett értéket. Ezért az utasítás print(unwrappedValue)5 kimenetet ad ki a konzolban.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
A program futtatásakor a kimenet a következő lesz:
10.
A fenti programban azonban az opcionális someValue változót inicializálják a 10-es értékkel. Tehát a nulla egyesítő operátor sikeresen kibontja az értéket a someValue-ból. Ezért az utasítás someValue ?? defaultValue10-et ad vissza , az utasítás pedig 10-et ad print(unwrappedValue)ki a konzolban.
