Swift attribuisce un valore elevato alla sicurezza del tipo. L'intero linguaggio Swift è stato progettato pensando alla sicurezza. È uno dei tratti distintivi di Swift e uno che dovresti dare il benvenuto a braccia aperte. Contribuirà allo sviluppo di codice pulito e leggibile e contribuirà a impedire il crash dell'applicazione.
Tutti gli optionals in Swift sono delimitati dal ?simbolo. Impostando ?dopo il nome del tipo in cui si dichiara come facoltativo, essenzialmente si esegue il cast di questo non come tipo in cui si trova prima di ?, ma invece come tipo facoltativo .
Nota: una variabile o un tipo nonInt è uguale a . Sono due tipi diversi che non possono essere gestiti l'uno sull'altro.Int?
Usando Opzionale
var myString: String?
myString = "foobar"
Questo non significa che stai lavorando con un tipo di String. Ciò significa che stai lavorando con un tipo di String?(String opzionale o String opzionale). In effetti, ogni volta che provi a farlo
print(myString)
in fase di esecuzione, verrà stampata la console di debug Optional("foobar"). La parte " Optional()" indica che questa variabile può avere o meno un valore in fase di runtime, ma al momento accade che attualmente contenga la stringa "foobar". Questa " Optional()" indicazione rimarrà a meno che tu non faccia quello che viene chiamato "scartare" il valore opzionale.
Scartare un facoltativo significa che stai lanciando quel tipo come non opzionale. Ciò genererà un nuovo tipo e assegnerà il valore che risiedeva in quello opzionale al nuovo tipo non opzionale. In questo modo è possibile eseguire operazioni su quella variabile in quanto è stato garantito dal compilatore un valore solido.
Unwrapping condizionale verificherà se il valore nell'opzionale è nilo meno. In caso contrario nil, ci sarà una variabile di costante appena creata a cui verrà assegnato il valore e che verrà scartato nella costante non opzionale. E da lì puoi tranquillamente utilizzare il non opzionale nel ifblocco.
Nota: è possibile assegnare alla costante non imballata condizionale lo stesso nome della variabile facoltativa che si sta scartando.
if let myString = myString {
print(myString)
// will print "foobar"
}
Gli optionals da scartare condizionatamente sono il modo più pulito per accedere al valore di un opzionale perché se contiene un valore nullo, tutto ciò che si trova all'interno del blocco if let non verrà eseguito. Naturalmente, come ogni istruzione if, puoi includere un blocco else
if let myString = myString {
print(myString)
// will print "foobar"
}
else {
print("No value")
}
Il Unwrapping forzato viene eseguito impiegando quello che è noto come !operatore ("bang"). Questo è meno sicuro ma consente comunque la compilazione del codice. Tuttavia, ogni volta che usi l'operatore bang devi essere sicuro al 1000% che la tua variabile contenga effettivamente un valore solido prima di scartarla con la forza.
var myString: String?
myString = "foobar"
print(myString!)
Questo sopra è un codice Swift completamente valido. Stampa il valore di myStringquello impostato come "foobar". L'utente vedrebbe foobarstampato nella console e questo è tutto. Ma supponiamo che il valore non sia mai stato impostato:
var myString: String?
print(myString!)
Ora abbiamo una situazione diversa nelle nostre mani. A differenza di Objective-C, ogni volta che si tenta di scartare forzatamente un facoltativo, e l'opzione non è stata impostata ed è nil, quando si tenta di scartare l'opzionale per vedere cosa c'è dentro l'applicazione si bloccherà.
Involucro con tipo Casting . Come abbiamo detto in precedenza che, mentre sei unwrappingfacoltativo, stai effettivamente trasmettendo a un tipo non opzionale, puoi anche trasmettere il non opzionale a un tipo diverso. Per esempio:
var something: Any?
Da qualche parte nel nostro codice la variabile somethingverrà impostata con un certo valore. Forse stiamo usando generici o forse c'è qualche altra logica in corso che lo farà cambiare. Quindi più avanti nel nostro codice vogliamo usare, somethingma essere comunque in grado di trattarlo in modo diverso se si tratta di un tipo diverso. In questo caso, dovrai utilizzare la asparola chiave per determinare questo:
Nota: l' asoperatore spiega come digitare cast in Swift.
// Conditionally
if let thing = something as? Int {
print(thing) // 0
}
// Optionally
let thing = something as? Int
print(thing) // Optional(0)
// Forcibly
let thing = something as! Int
print(thing) // 0, if no exception is raised
Notare la differenza tra le due asparole chiave. Come prima quando abbiamo scartato con la forza un optional, abbiamo usato l' !operatore bang per farlo. Qui farai la stessa cosa ma invece di lanciare solo un non opzionale, lo stai lanciando anche come Int. E deve essere in grado di essere downcast come Int, altrimenti, come usare l'operatore bang quando il valore è che la niltua applicazione andrà in crash.
E per usare queste variabili in qualche modo o operazione matematica, devono essere scartate per poterlo fare.
Ad esempio, in Swift possono essere gestiti solo tipi di dati numerici validi dello stesso tipo. Quando lanci un tipo con il as!tuo, stai forzando il downcast di quella variabile come se tu fossi certo che sia di quel tipo, quindi sicuro da usare e non bloccare la tua applicazione. Questo va bene fintanto che la variabile è davvero del tipo in cui la stai lanciando, altrimenti avrai un pasticcio tra le mani.
Tuttavia, il casting con as!consentirà la compilazione del codice. Casting con an as?è una storia diversa. In effetti, as?dichiara il tuo Intcome un tipo di dati completamente diverso tutti insieme.
Ora è Optional(0)
E se hai mai provato a fare i compiti scrivendo qualcosa del genere
1 + Optional(1) = 2
Il tuo insegnante di matematica ti avrebbe probabilmente dato una "F". Lo stesso con Swift. Tranne che Swift preferirebbe non compilare affatto piuttosto che darti un voto. Perché alla fine della giornata, infatti, l'opzione potrebbe essere nulla .
Safety First Kids.
