In diesem Artikel erfahren Sie mehr über optional, seine Anwendungsfälle und die optionale Behandlung in Swift.
Im vorherigen Artikel haben wir verschiedene in Swift verfügbare Datentypen kennengelernt und festgestellt, dass die von diesen Typen deklarierte Variable oder Konstante einen Standardwert enthält.
Beispiel:
Lassen Sie someValue = Int () drucken (someValue)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
0
In Swift gibt es jedoch einen anderen Datentyp namens Optional, dessen Standardwert ein Nullwert ( nil) ist. Sie können optional verwenden, wenn eine Variable oder Konstante keinen Wert enthalten soll. Ein optionaler Typ kann einen Wert enthalten oder einen Wert fehlen (einen Nullwert).
Nicht technisch kann man als Schuhkarton optional denken. Der Schuhkarton kann einen Schuh enthalten oder nicht. Sie sollten dies also vorher wissen, wenn Sie aus der Box auf den Schuh zugreifen.
Wie deklariere ich eine Option?
Sie können einen Datentyp einfach als optional darstellen, indem Sie ihn anhängen !oder ?an Type. Wenn ein optionales Element einen Wert enthält, gibt es den Wert als zurück Optional, wenn nicht nil.
Beispiel 1: Wie deklariere ich eine Option in Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
nil nil
Im obigen Programm haben wir einen optionalen Typ mit ?und initialisiert !. Beide Möglichkeiten sind gültig, um eine Option zu erstellen, aber es gibt einen Hauptunterschied, den wir unten untersuchen werden.
Das Deklarieren eines optionalen Int bedeutet, dass die Variable entweder einen ganzzahligen Wert oder keinen Wert hat. Da der Variablen kein Wert zugewiesen ist, können Sie beide printAnweisungsausgaben nilauf dem Bildschirm sehen.
Beispiel 2: Zuweisen und Zugreifen auf einen Wert von einem optionalen Wert aus
let someValue:Int? = 5 print(someValue) print(someValue!)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
Optional (5) 5
Im obigen Programm haben wir eine Option vom IntTyp deklariert und darin den Wert 5 zugewiesen.
Wie Sie sehen können, das Drucken der optional als print(someValue)nicht geben Ihnen 5aber Optional(5). Es hat die oben beschriebene Form : Optional. Um darauf zugreifen zu können, benötigen wir einen Mechanismus namens Entpacken .
Sie können ein optionales !Zeichen auspacken, indem Sie das Zeichen wie in der nächsten Zeile am Ende der Variablen / Konstante anhängen print(someValue!). print(someValue!)packt das Optionale aus und gibt es 5auf dem Bildschirm aus.
Denken Sie jedoch daran, dass diese Art von Entpackungsmechanismus nur verwendet werden sollte, wenn Sie sicher sind, dass die Option beim Zugriff sicher einen Wert hat.
Beispiel 3: Explizite Deklaration einer nicht verpackten Option
Sie können ein unverpacktes optionales Element auch wie folgt erstellen:
let someValue:Int! = 5 print(someValue)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
5
Int!Erstellt im obigen Programm ein ausgepacktes optionales Element, das den Wert automatisch auspackt, während Sie darauf zugreifen, sodass Sie das !Zeichen nicht jedes Mal anhängen müssen .
Stellen Sie sicher, dass die Variable beim Zugriff auf diese Option immer einen Wert haben muss, wenn Sie darauf zugreifen. Wenn Sie dies nicht tun, erhalten Sie einen schwerwiegenden Fehlerabsturz.
Beispiel 4: Schwerwiegender Fehler beim Zugriff auf eine optionale Null-Entpackung
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Wenn Sie das Programm ausführen, wird ein Absturz als schwerwiegender Fehler angezeigt: Beim Entpacken eines optionalen Werts wurde unerwartet Null gefunden, da der Code unwrappedValue:Int = someValueversucht, der Variablen unwrappedValue einen Wert von Optional someValue zuzuweisen.
Somevalue ist jedoch ein OptionalTyp, der nilWert enthält . Der Versuch, der Variablen unwrappedValue, die nicht optional ist, den Wert nil zuzuweisen, führt zum Absturz.
Es gibt verschiedene Techniken, um diesen Fall zu behandeln, die unten erläutert werden.
Optionale Handhabung
Um den Wert eines optionalen Elements verwenden zu können, muss es ausgepackt werden. Der optionale Wert kann besser durch bedingtes Entpacken verwendet werden, als das Entpacken mit dem !Operator zu erzwingen .
Dies liegt daran, dass beim bedingten Auspacken gefragt wird, ob diese Variable einen Wert hat. . Wenn ja, geben Sie den Wert an, andernfalls wird der Null-Fall behandelt.
Im Gegenteil, Force Entpacken besagt, dass diese Variable einen Wert hat, während Sie sie verwenden . Wenn Sie das Entpacken einer Variablen erzwingen, die Null ist, löst Ihr Programm daher eine unerwartet gefundene Null aus, während Sie eine optionale Ausnahme entpacken und abstürzen . Einige der Techniken zum bedingten Auspacken werden nachfolgend erläutert:
1. If-Anweisung
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
Im obigen Programm ist die Variable someValue optional definiert und enthält den Wert Null. Der Null-Koaleszenz-Operator kann das optionale nicht auspacken und gibt daher defaultValue zurück. Daher gibt die Anweisung print(unwrappedValue)5 in der Konsole aus.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Wenn Sie das Programm ausführen, lautet die Ausgabe wie folgt:
10
Im obigen Programm wird die optionale Variable someValue jedoch mit dem Wert 10 initialisiert. Daher packt der Null-Koaleszenzoperator den Wert erfolgreich aus someValue aus. Daher gibt die Anweisung someValue ?? defaultValue10 zurück und die Anweisung print(unwrappedValue)gibt 10 in der Konsole aus.
