În acest articol, veți afla despre opțional, cazurile sale de utilizare și tratarea opțională în Swift.
În articolul precedent, am aflat despre diferite tipuri de date disponibile în Swift și, de asemenea, am observat că variabila sau constanta declarată a acestor tipuri conține o valoare implicită.
Exemplu:
let someValue = Int () print (someValue)
Când rulați programul, ieșirea va fi:
0
Cu toate acestea, există un alt tip de date în Swift numit Opțional, a cărui valoare implicită este o valoare nulă ( nil). Puteți utiliza opțional când doriți ca o variabilă sau o constantă să nu conțină nicio valoare în ea. Un tip opțional poate conține o valoare sau poate lipsi o valoare (o valoare nulă).
Din punct de vedere tehnic, vă puteți gândi opțional ca o cutie de pantofi. Cutia pentru pantofi poate conține sau nu un pantof în ea. Deci, ar trebui să știți în prealabil în timp ce accesați pantoful din cutie.
Cum să declarați o opțională?
Puteți pur și simplu reprezenta un tip de date ca opțional prin anexare !sau ?la Type. Dacă o opțională conține o valoare în ea, returnează valoarea ca Optional, dacă nu, returnează nil.
Exemplul 1: Cum să declarați un opțional în Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Când rulați programul, ieșirea va fi:
nil nil
În programul de mai sus, am inițializat un tip opțional folosind ?și !. Ambele moduri sunt valabile pentru a crea un opțional, dar există o diferență majoră pe care o vom explora mai jos.
Declararea unui Int opțional înseamnă că variabila va avea fie o valoare întreagă, fie nu va avea valoare. Deoarece nicio valoare nu este atribuită variabilei, puteți vedea ambele printieșiri de instrucțiuni nilpe ecran.
Exemplul 2: Atribuirea și accesarea unei valori dintr-o opțională
let someValue:Int? = 5 print(someValue) print(someValue!)
Când rulați programul, ieșirea va fi:
Opțional (5) 5
În programul de mai sus, am declarat o opțională de Inttip și i s-a atribuit valoarea 5.
După cum puteți vedea, imprimarea opțională ca print(someValue)nu vă oferă, 5dar Optional(5). Este de forma descrisă mai sus: Optional. Pentru a accesa din acesta, avem nevoie de un mecanism numit despachetare .
Puteți anula un opțional adăugând !caracter la sfârșitul variabilei / constantei ca în linia următoare print(someValue!). print(someValue!)desfășoară opțional și ieșirile de 5pe ecran.
Cu toate acestea, amintiți-vă, acest tip de mecanism de despachetare trebuie utilizat numai atunci când sunteți sigur că opționalul va avea cu siguranță o valoare atunci când îl accesați.
Exemplul 3: Declararea în mod explicit a unei opțiuni despachetate
De asemenea, puteți crea o opțiune despachetată ca:
let someValue:Int! = 5 print(someValue)
Când rulați programul, ieșirea va fi:
5
În programul de mai sus, Int!creează un opțional despachetat, care dezvăluie automat valoarea în timp ce o accesați, astfel încât să nu aveți nevoie să adăugați de fiecare dată !caracterul.
Fii sigur în timp ce folosești aceste tipuri de opționale, variabila va trebui întotdeauna să aibă o valoare atunci când o accesezi. În caz contrar, veți primi o eroare fatală.
Exemplul 4: eroare fatală la accesarea unui opțional nul despachetat
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Când rulați programul, veți primi un accident ca eroare fatală: neașteptat găsit zero în timp ce desfășurați o valoare opțională deoarece codul unwrappedValue:Int = someValueîncearcă să atribuie valoare din opțional someValue variabilei unwrappedValue.
Cu toate acestea, somevalue este un Optionaltip care conține nilvaloare. Încercarea de a atribui valoare nulă variabilei unwrappedValue care nu este opțională va duce la blocarea.
Există diferite tehnici de gestionare a acestui caz, care sunt explicate mai jos.
Manipulare opțională
Pentru a utiliza valoarea unui opțional, acesta trebuie desfăcut. O modalitate mai bună de a utiliza valoarea opțională este prin desfacerea condiționată, mai degrabă decât forțarea desfăcerii folosind !operatorul.
Acest lucru se datorează faptului că despachetarea condiționată întreabă Verificați dacă această variabilă are o valoare? . Dacă da, dați valoarea, altfel se va ocupa de cazul zero.
Dimpotrivă, despachetarea forțată spune că această variabilă are o valoare în timp ce o utilizați . Prin urmare, când forțați desfacerea unei variabile care este zero, programul dvs. va arunca un zero neașteptat găsit în timp ce desfășurați o excepție opțională și se blochează . Unele dintre tehnicile pentru desfacerea condiționată sunt explicate mai jos:
1. If-statement
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
În programul de mai sus, variabila someValue este definită opțional și conține valoare nulă. Operatorul de coagulare nul nu reușește să desfacă opționalul, prin urmare returnează defaultValue. Prin urmare, declarația print(unwrappedValue)scoate 5 în consolă.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Când rulați programul, ieșirea va fi:
10
Cu toate acestea, în programul de mai sus, variabila opțională someValue este inițializată cu valoarea 10. Deci, operatorul de coagulare nul dezvăluie cu succes valoarea de la someValue. Prin urmare, instrucțiunea someValue ?? defaultValuereturnează 10 și instrucțiunea print(unwrappedValue)produce 10 în consolă.
