V tomto článku se dozvíte o volitelném, jeho případech použití a volitelném zacházení ve Swift.
V předchozím článku jsme se dozvěděli o různých datových typech dostupných v Swiftu a také jsme si všimli, že proměnná nebo konstanta deklarovaná z těchto typů obsahuje výchozí hodnotu.
Příklad:
nechat someValue = Int () print (someValue)
Když spustíte program, výstup bude:
0
Ve Swiftu však existuje jiný datový typ s názvem Optional, jehož výchozí hodnota je null value ( nil). Volitelné můžete použít, pokud chcete, aby proměnná nebo konstanta neobsahovaly žádnou hodnotu. Volitelný typ může obsahovat hodnotu nebo chybí hodnota (nulová hodnota).
Z technického hlediska můžete volitelně uvažovat o krabici na boty. Krabička na boty může nebo nemusí obsahovat botu. Při přístupu k botě z krabice byste tedy měli vědět předem.
Jak deklarovat volitelné?
Můžete jednoduše reprezentovat datový typ jako volitelný připojením !nebo ?k Type. Pokud volitelný obsahuje v něm hodnotu, vrátí hodnotu jako Optional, pokud ne, vrátí nil.
Příklad 1: Jak deklarovat volitelnou položku ve Swiftu?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Když spustíte program, výstup bude:
nula nula
Ve výše uvedeném programu jsme inicializovali volitelný typ pomocí ?a !. Oba způsoby jsou platné pro vytvoření volitelného, ale je zde jeden zásadní rozdíl, který prozkoumáme níže.
Deklarace volitelného Int znamená, že proměnná bude mít buď celočíselnou hodnotu, nebo žádnou hodnotu. Protože proměnné není přiřazena žádná hodnota, můžete na obrazovce vidět oba printvýstupy výpisu nil.
Příklad 2: Přiřazení a přístup k hodnotě z volitelného
let someValue:Int? = 5 print(someValue) print(someValue!)
Když spustíte program, výstup bude:
Volitelné (5) 5
Ve výše uvedeném programu jsme deklarovali volitelný Inttyp a přiřadili jsme v něm hodnotu 5.
Jak vidíte, tisk volitelného as print(someValue)vám nedává, 5ale Optional(5). To je ve tvaru, jak je popsáno výše: Optional. Abychom z něj měli přístup , potřebujeme mechanismus zvaný rozbalování .
Volitelné můžete rozbalit připojením !znaku na konec proměnné / konstanty jako v dalším řádku print(someValue!). print(someValue!)rozbalí volitelné a výstupy 5na obrazovce.
Nezapomeňte však, že tento druh rozbalovacího mechanismu by měl být použit pouze v případě, že jste si jisti, že volitelný bude mít jistou hodnotu, když k němu přistupujete.
Příklad 3: Explicitní deklarování nezabalené nepovinné
Můžete také vytvořit rozbalený volitelný doplněk jako:
let someValue:Int! = 5 print(someValue)
Když spustíte program, výstup bude:
5
Ve výše uvedeném programu Int!vytvoří nepovinnou volitelnou položku, která automaticky rozbalí hodnotu, když k ní přistupujete, takže nemusíte pokaždé připojit !znak.
Při používání těchto druhů volitelných doplňků buďte jistí, že proměnná bude při přístupu vždy potřebovat hodnotu. Pokud tak neučiníte, dojde k závažné chybě.
Příklad 4: Závažná chyba při přístupu k null rozbalenému volitelnému
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Když spustíte program, dojde k havárii jako fatální chyba: neočekávaně nalezena nulová hodnota při rozbalování volitelné hodnoty, protože se kód unwrappedValue:Int = someValuepokusí přiřadit hodnotu z volitelné volitelné hodnoty do proměnné unbrappedValue.
Somevalue je však Optionaltyp, který obsahuje nilhodnotu. Pokus o přiřazení nulové hodnoty proměnné unwrappedValue, která není volitelná, povede ke zhroucení.
V tomto případě existují různé techniky, které jsou vysvětleny níže.
Volitelná manipulace
Chcete-li použít hodnotu volitelného prvku, je třeba jej rozbalit. Lepší způsob, jak použít volitelnou hodnotu, je podmíněné rozbalení namísto vynucení rozbalení pomocí !operátoru.
Je to proto, že podmíněné rozbalování se ptá Zkontrolovat, zda má tato proměnná hodnotu? . Pokud ano, uveďte hodnotu, jinak bude řešit nulový případ.
Naopak, rozbalení síly říká, že tato proměnná má hodnotu, když ji používáte . Proto když vynutíte rozbalení proměnné, která je nulová, váš program vyvolá neočekávaně nalezenou nulu, zatímco rozbalí volitelnou výjimku a dojde k chybě . Níže jsou vysvětleny některé techniky podmíněného rozbalování:
1. If-prohlášení
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
Ve výše uvedeném programu je proměnná someValue definována jako volitelná a obsahuje nulovou hodnotu. Operátor sloučení nuly se nepodaří rozbalit volitelný, proto vrací defaultValue. Proto příkaz print(unwrappedValue)vydá 5 v konzole.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Když spustíte program, výstup bude:
10
Ve výše uvedeném programu je však volitelná proměnná someValue inicializována s hodnotou 10. Takže operátor splynutí nuly úspěšně rozbalí hodnotu z someValue. Proto příkaz someValue ?? defaultValuevrátí 10 a print(unwrappedValue)výstup výstupu 10 v konzole.
