In questo articolo, imparerai a conoscere gli optional, i suoi casi d'uso e la gestione facoltativa in Swift.
Nell'articolo precedente, abbiamo appreso dei diversi tipi di dati disponibili in Swift e abbiamo anche notato che la variabile o la costante dichiarata di quei tipi contiene un valore predefinito.
Esempio:
let someValue = Int () print (someValue)
Quando esegui il programma, l'output sarà:
0
Tuttavia esiste un altro tipo di dati in Swift chiamato Optional, il cui valore predefinito è un valore nullo ( nil). È possibile utilizzare opzionale quando si desidera che una variabile o una costante non contenga alcun valore. Un tipo facoltativo può contenere un valore o assente un valore (un valore nullo).
Non tecnicamente, puoi pensare come optional come una scatola da scarpe. La scatola da scarpe può contenere o meno una scarpa. Quindi, dovresti saperlo in anticipo mentre accedi alla scarpa dalla scatola.
Come dichiarare un Opzionale?
Puoi semplicemente rappresentare un tipo di dati come facoltativo aggiungendo !o ?al file Type. Se un opzionale contiene un valore al suo interno, restituisce valore come Optional, in caso contrario, restituisce nil.
Esempio 1: come dichiarare un optional in Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Quando esegui il programma, l'output sarà:
zero zero
Nel programma sopra, abbiamo inizializzato un tipo opzionale usando ?e !. Entrambi i modi sono validi per creare un optional, ma c'è una grande differenza che esploreremo di seguito.
Dichiarare un Int facoltativo significa che la variabile avrà un valore intero o nessun valore. Poiché non è assegnato alcun valore alla variabile, è possibile visualizzare entrambi gli printoutput dell'istruzione nilsullo schermo.
Esempio 2: assegnazione e accesso a un valore da un optional
let someValue:Int? = 5 print(someValue) print(someValue!)
Quando esegui il programma, l'output sarà:
Opzionale (5) 5
Nel programma sopra, abbiamo dichiarato un opzionale di Inttipo e assegnato il valore 5 in esso.
Come puoi vedere, la stampa dell'opzionale as print(someValue)non ti dà 5ma Optional(5). È di forma come sopra descritto: Optional. Per accedere a da esso, abbiamo bisogno di un meccanismo chiamato scartare .
Puoi scartare un opzionale aggiungendo un !carattere alla fine della variabile / costante come nella riga successiva print(someValue!). print(someValue!)scarta gli optional e li visualizza 5sullo schermo.
Tuttavia, ricorda, questo tipo di meccanismo di scartamento dovrebbe essere usato solo quando sei certo che l'opzionale avrà sicuramente un valore quando lo accederai.
Esempio 3: dichiarazione esplicita di un opzionale scartato
Puoi anche creare un optional da scartare come:
let someValue:Int! = 5 print(someValue)
Quando esegui il programma, l'output sarà:
5
Nel programma di cui sopra, Int!crea un optional non imbustato, che automaticamente scarta il valore mentre si accede in modo che non sia necessario aggiungere ogni volta il !carattere.
Assicurati che mentre usi questi tipi di optional, la variabile dovrà sempre avere un valore quando accederai. In caso contrario, si verificherà un errore irreversibile.
Esempio 4: errore irreversibile durante l'accesso a un optional null non imbustato
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Quando si esegue il programma, si verificherà un arresto anomalo come errore irreversibile: trovato inaspettatamente nil durante lo scartamento di un valore facoltativo perché il codice unwrappedValue:Int = someValuetenta di assegnare un valore da facoltativo someValue alla variabile unfrappedValue.
Tuttavia, somevalue è un Optionaltipo che contiene nilvalue. Il tentativo di assegnare un valore nullo alla variabile unfrappedValue che non è un optional provocherà un arresto anomalo.
Esistono diverse tecniche per gestire questo caso, spiegate di seguito.
Gestione opzionale
Per poter utilizzare il valore di un optional, è necessario scartarlo. Il modo migliore per utilizzare il valore facoltativo è lo scartamento condizionale piuttosto che forzare lo scartamento utilizzando l' !operatore.
Questo perché lo scartamento condizionale chiede Controlla se questa variabile ha un valore? . Se sì, dai il valore, altrimenti gestirà il caso zero.
Al contrario, lo scartamento forzato dice che Questa variabile ha un valore mentre la usi . Pertanto, quando si forza a scartare una variabile che è nulla, il programma lancerà un valore nullo trovato inaspettatamente durante lo scartamento di un'eccezione facoltativa e il crash . Alcune delle tecniche per lo scartamento condizionale sono spiegate di seguito:
1. If-istruzione
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
Nel programma precedente, la variabile someValue è definita opzionale e contiene un valore nullo. L'operatore di coalescenza nullo non riesce a scartare l'opzionale, quindi restituisce defaultValue. Pertanto l'istruzione print(unwrappedValue)restituisce 5 nella console.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Quando esegui il programma, l'output sarà:
10
Tuttavia, nel programma precedente, la variabile facoltativa someValue viene inizializzata con il valore 10. Quindi, l'operatore di coalescenza nullo scartra con successo il valore da someValue. Pertanto, l'istruzione someValue ?? defaultValuerestituisce 10 e l'istruzione print(unwrappedValue)restituisce 10 nella console.
