Swift 101 - Работа с новите опционни стойности на Swift

Езикът за програмиране на Swift има нова функция, наречена незадължителни, които преди това не бяха достъпни в Objective-C. Те са подобни на незадължителните типове в Java и нулеви типове в C # програмния език.

Защо да използвате опции?

Може би си мислите "Мога да игнорирам незадължителните - това е функция, която никога няма да използвам", но ви препоръчвам да прочетете по-нататък. Ще откриете, че трябва да използвате незадължителни в Swift, ако някога се нуждаете от стойност, която е нула!

Незадължителните стойности в Swift ви позволяват да бъдете по-прецизни в кода си, като ви позволяват да укажете кога е добре дадена празна стойност да е празна (и когато не е така!) неочаквана стойност nil.

Опциите на Swift също така помагат за по-добро отразяване на кода на приложението ви в способностите, които вече имате в Core Data, за да укажете, че даден атрибут на обект е по избор. Както е показано на фигура 1, можете да укажете типа на атрибута (String, в този случай), както и да посочите дали стойността не е задължителна.

Фигура 1 - Можете да укажете, че атрибутът на обект от данни е незадължителен.

Сега Swift ви позволява да направите същото с вашите свойства и променливи. Ето една еквивалентна опционална декларация в Swift:

var middleName: String?

Тази декларация създава променлива, наречена middleName от тип String . Въпросният знак ( ? ) След типа променлива String показва, че променливата middleName може да съдържа стойност, която може да бъде или String или nil . Всеки, който гледа този код, веднага знае, че имената на middleName могат да бъдат нула . Това е само-документиране!

Ако не зададете първоначална стойност за незадължителна константа или променлива (както е показано по-горе), стойността автоматично ще бъде нулирана за вас. Ако предпочитате, можете изрично да зададете първоначалната стойност на нула:

var middleName: String? = nil

Сега нека погледнем по-отблизо как се използва нула в Swift.

нула в Суифт

Може да не е очевидно на пръв поглед, но само незадължителни могат да бъдат нула . Както е посочено в книгата на Apple Swift Programming Language (достъпна безплатно в iBooks Store):

nil не може да се използва с незадължителни константи и променливи. Ако една константа или променлива в кода ви трябва да може да се справи с липсата на стойност при определени условия, винаги я декларирайте като незадължителна стойност на подходящия тип.

Това означава, че не можете да направите нещо подобно, защото променливата firstName не е маркирана с въпросник, за да указва, че е по избор:

var firstName: String = nil

Този код генерира следната грешка при компилирането:

Тип 'String' не съответства на протокола 'NilLiteralConvertible' .

Също така е важно да се отбележи, че нула в Swift е различна от нула в Objective-C. В Objective-C, nil е показалец към несъществуващ обект. В Swift, nil просто показва липсата на стойност - не е показалец. Това означава, че можете да укажете опции за произволен тип, а не само за типове обекти.

Достъп до опционални стойности

За разлика от други езици за програмиране, в Swift не можете да получите достъп до допълнителна стойност директно . Трябва първо да разгънете незадължителната, за да получите достъп до съответната стойност. Вземете например следния код:

var firstName: String = "Ryan"

var middleName: String? = "Майкъл"

var firstAndMiddleNames: String

firstAndMiddleNames = firstName + "+ middleName

Първите три реда код обявяват променливата StringName String, променливата String за средно име, и променливата StringAndMiddleNames String. Следващият ред от код свързва (обединява) стойностите на променливата firstName и middleName заедно с интервал между тях. Може да се изненадате, че този ред код генерира следната грешка при компилирането:

Стойност на типа опция "String?" не разгъната; искаш да използваш "!" или '?'?

Това е един от механизмите за защита на Суифт. Това ви принуждава да признаете, че дадена стойност може да бъде нулева . И така, как да разгънете незадължително? Има два основни начина, описани в следващите раздели.

Използване на принудително разопаковане за незадължителни

Както бе предложено от грешката на компилатора в предишния раздел, един от начините за разгъване на незадължителна стойност е да се използва удивителният знак (!) След опцията, за да го разгънете изрично. Например:

firstAndMiddleNames = firstName + " " + middleName!

Това ръчно принуждава стойността на middleName да се разопакова. Въпреки това, ако middleName съдържа нула по време на изпълнение, това ще доведе до EXC_BAD_INSTRUCTION грешка по време на изпълнение. Така че, очевидно не бихте искали да използвате принудително разгъване, освен ако не сте абсолютно сигурни, че стойността не е нула .

Използване на опционално обвързване за отключване на опциите

Можете да използвате техника, известна като незадължителна връзка, за да проверите дали дадена опция съдържа стойност, и ако е така, запазете тази стойност във временна променлива или константа. За да видите как работи това с предишния ни пример, вижте този код:

var firstName: String = "Ryan"

var middleName: String? = "Майкъл"

var firstAndMiddleNames: String

ако нека средна = средно име

{

firstAndMiddleNames = firstName + "+ + middle

}

още

{

firstAndMiddleNames = firstName

}

Когато условието if се проверява по време на изпълнение, ако променливата middleName съдържа стойност String, условието се оценява на true, стойността, съдържаща се в middleName променливата, се разопакова, съхранява в средната константа и кодът в рамките на фигурни скоби на оператора if. се изпълнява.

Ако променливата middleName съдържа nil, условието се оценява на false, незадължителната стойност не се разгъва и се изпълнява кодът в къдравите скоби на оператора else .

Имплицитно неопаковани опции

Swift също има нещо, наречено незадължително неопределени опции. Това са опции, които не трябва да бъдат разгънати, използвайки или принудително разгъване (!) Или незадължително свързване, защото те се разгъват косвено (автоматично). Те се обявяват с удивителен знак (!) Вместо с въпросник (?).

Често виждате имплицитно неопаковани незадължителни опции, когато работите с обекти на Interface Builder (свойства IBOutlet ). Например:

@IBOutlet weak var lblDescription: UILabel!

В този код свойството на изхода lblDescription има удивителен знак след него, което указва, че е косвено разопакован. Това ви позволява да влезете в имота, без да го разгъвате.

В този пример, обектът на изхода не е гарантирано да съдържа препратка към етикет, но е абсолютно задължителна. Ако не съдържа препратка към етикет, това означава, че връзката между изхода и етикета е счупена. В този случай е добре да имате грешка по време на изпълнение, защото искате да знаете, че връзката е прекъсната, така че можете да я поправите!

Очевидно е, че в случаите, когато не сте 100 процента сигурни, че константа или променлива съдържа стойност, трябва вместо това да използвате редовна опция.

заключение

Незадължителните са чудесна нова функция на Swift, която ви позволява безопасно да управлявате нулевите стойности в приложенията си за iOS. Препоръчвам ви да прегледате тази публикация няколко пъти, за да сте сигурни, че разбирате основните понятия, и след това се върнете в книгата на Apple за Swift Programming Language, за да научите повече за това как се използват незадължителните в Swift.