Šajā rakstā jūs uzzināsiet par izvēles iespējām, to lietošanas gadījumiem un izvēles iespējām Swift.
Iepriekšējā rakstā mēs uzzinājām par dažādiem Swift pieejamajiem datu tipiem, kā arī pamanījām, ka šo tipu mainīgais vai pastāvīgais deklarētais satur noklusējuma vērtību.
Piemērs:
ļaujiet drukāt someValue = Int () (someValue)
Palaidot programmu, izeja būs:
0
Tomēr Swift ir vēl viens datu tips, ko sauc par izvēles, kura noklusējuma vērtība ir nulles vērtība ( nil). Varat izmantot pēc izvēles, ja vēlaties, lai mainīgais vai konstante nesatur tajā vērtību. Izvēles tips var saturēt vērtību vai arī tā nav (nulles vērtība).
Netehniski jūs varat domāt pēc izvēles kā apavu kastes. Apavu kastē var būt vai nav apavu. Tātad, jums vajadzētu zināt iepriekš, piekļūstot apavam no kastes.
Kā pasludināt izvēles?
Jūs varat vienkārši pārstāvēt datu veids kā izvēles, pievienojot !vai ?uz Type. Ja izvēles opcijā ir vērtība, tā atgriež vērtību Optional, ja tā nav nil.
1. piemērs: Kā pasludināt izvēles iespēju programmā Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Palaidot programmu, izeja būs:
nulle nulle
Iepriekš minētajā programmā mēs esam inicializējuši izvēles veidu, izmantojot ?un !. Abi veidi ir derīgi, lai izveidotu izvēles iespēju, taču ir viena būtiska atšķirība, kuru mēs izpētīsim tālāk.
Deklarējot neobligātu Int, mainīgajam būs vai nu vesela skaitļa vērtība, vai arī tai nebūs vērtības. Tā kā mainīgajam nav piešķirta vērtība, ekrānā varat redzēt abus printpārskatu izvadus nil.
2. piemērs: Vērtības piešķiršana un piekļuve no izvēles
let someValue:Int? = 5 print(someValue) print(someValue!)
Palaidot programmu, izeja būs:
Pēc izvēles (5) 5
Iepriekš minētajā programmā mēs esam deklarējuši Inttipa izvēles iespēju un tajā piešķīruši 5. vērtību.
Kā jūs varat redzēt, drukāšanas fakultatīva kā print(someValue)nedod jums 5, bet Optional(5). Tas ir formā, kā aprakstīts iepriekš Optional. Lai piekļūtu no tā, mums ir nepieciešams mehānisms, ko sauc par atritināšanu .
Varat atritināt izvēles !iespēju, mainīgā / konstante beigās pievienojot rakstzīmi tāpat kā nākamajā rindā print(someValue!). print(someValue!)ekrānā atritina izvēles un izejas 5.
Tomēr atcerieties, ka šāda veida attīšanas mehānisms jāizmanto tikai tad, ja esat pārliecināts, ka izvēles opcijai būs vērtība, kad tam piekļūsit.
3. piemērs: skaidri paziņojiet par neiesaiņotu izvēli
Varat arī izveidot neiesaiņotu izvēles iespēju kā:
let someValue:Int! = 5 print(someValue)
Palaidot programmu, izeja būs:
5
Iepriekš minētajā programmā Int!tiek izveidota neiesaiņota izvēles iespēja, kas automātiski atritina vērtību, kamēr tai piekļūstat, lai jums nekad nebūtu jāpievieno !raksturs.
Esiet pārliecināts, ka, lietojot šāda veida opcijas, mainīgajam vienmēr būs nepieciešama vērtība, kad tam piekļūstat. Ja jūs to nedarīsit, jūs saņemsiet fatālu kļūdu avāriju.
4. piemērs: Fatāla kļūda, piekļūstot nulles neiesaiņotam izvēles variantam
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Palaidot programmu, jūs saņemsiet avāriju kā liktenīgu kļūdu: negaidīti atrada nulli, atritinot izvēles vērtību, jo kods unwrappedValue:Int = someValuemēģina piešķirt vērtību no Optional someValue mainīgajam uncrappedValue.
Tomēr somevalue ir Optionalveids, kas satur nilvērtību. Mēģinot piešķirt nulles vērtību mainīgajam uncrappedValue, kas nav obligāts, novedīs pie avārijas.
Ir dažādi paņēmieni, kā rīkoties šajā gadījumā, un tie ir paskaidroti turpmāk.
Izvēles apstrāde
Lai izmantotu izvēles vērtību, tā ir jāatsaiņo. Labāks veids, kā izmantot izvēles vērtību, ir nosacīts attīšana, nevis piespiešana, izmantojot !operatoru.
Tas notiek tāpēc, ka nosacīti attīšana prasa pārbaudīt, vai šim mainīgajam ir vērtība? . Ja jā, norādiet vērtību, pretējā gadījumā tā rīkosies ar nulles lietu.
Gluži pretēji, spēka attīšana saka, ka šim mainīgajam ir vērtība, kamēr jūs to izmantojat . Tāpēc, piespiežot iztīt mainīgo, kas ir nulle, jūsu programma negaidīti atrastu nulli, vienlaikus atceļot papildu izņēmumu un avarējot . Daži no nosacītās attīšanas paņēmieniem ir paskaidroti turpmāk:
1. Ja-paziņojums
Varat izmantot if apgalvojumu un salīdzināt pēc izvēles ar nulli, lai uzzinātu, vai izvēles opcijā ir vērtība vai nav. Ja paziņojumā varat izmantot operatoru "vienāds ar" ( ==) vai operatoru "nav vienāds ar" ( !=).
5. piemērs: Izvēles apstrāde ar paziņojumu if else
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") )
Palaidot programmu, izeja būs:
nesatur vērtību. Tam ir zināma vērtība 0
Iepriekš minētajā programmā kods if if izpilda, ja neobligāti satur vērtību, pretējā gadījumā izpilda pārējo bloku. Galvenais izvēles apstrādes trūkums, izmantojot šo tehniku, ir tas, ka jums joprojām ir jāatsaiņo vērtība no izvēles, izmantojot !operatoru.
2. Iesiešana pēc izvēles (ja tā ir atļauta)
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
Iepriekš minētajā programmā mainīgais someValue ir definēts kā neobligāts un satur nulles vērtību. Nulle apvienošanās operators neizvada neobligāto, tāpēc atgriež defaultValue. Tāpēc paziņojums print(unwrappedValue)konsolē izvada 5.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Palaidot programmu, izeja būs:
10
Tomēr iepriekšminētajā programmā izvēles mainīgais someValue tiek inicializēts ar vērtību 10. Tātad nulles apvienošanās operators veiksmīgi atritina vērtību no someValue. Tāpēc paziņojums konsolē someValue ?? defaultValueatgriež 10, un izraksts print(unwrappedValue)izved 10.
