Swift высоко ценит безопасность типов. Весь язык Swift был разработан с учетом безопасности. Это одна из отличительных черт Swift, которую стоит приветствовать с распростертыми объятиями. Это поможет в разработке чистого, читабельного кода и поможет предотвратить сбой вашего приложения.
Все опции в Swift обозначены ?символом. Устанавливая ?после имени типа , в котором вы объявляя в качестве факультативных вы по существу литье это не как тип , в котором находится на рассмотрении ?, но вместо этого в качестве дополнительного типа.
Примечание: Переменный или типа Intявляется не таким же , как Int?. Это два разных типа, которые нельзя эксплуатировать друг на друге.
Использование опционально
var myString: String?
myString = "foobar"
Это не значит, что вы работаете с типом String. Это означает, что вы работаете с типом String?(String Optional или Optional String). На самом деле, когда вы пытаетесь
print(myString)
во время выполнения консоль отладки напечатает Optional("foobar"). Часть « Optional()» указывает, что эта переменная может иметь или не иметь значение во время выполнения, но именно так и происходит в настоящее время со строкой «foobar». Эта « Optional()» индикация останется, если вы не сделаете то, что называется «развертывание» необязательного значения.
Развертывание необязательного означает, что вы используете этот тип как необязательный. Это создаст новый тип и присвоит значение, которое находилось в этом необязательном, новому необязательному типу. Таким образом, вы можете выполнять операции с этой переменной, поскольку компилятор гарантированно имеет твердое значение.
Условно Unwrapping проверит, является ли значение в дополнительном nilили нет. Если это не так nil, будет вновь созданная константная переменная, которой будет присвоено значение и развернута в необязательную константу. И оттуда вы можете смело использовать необязательные в ifблоке.
Примечание. Вы можете присвоить своей условно развернутой константе то же имя, что и необязательной переменной, которую вы разворачиваете.
if let myString = myString {
print(myString)
// will print "foobar"
}
Условное развёртывание опций - это самый чистый способ получить доступ к значению опциона, потому что если оно содержит значение nil, то все в блоке if let не будет выполняться. Конечно, как любое выражение if, вы можете включить блок else
if let myString = myString {
print(myString)
// will print "foobar"
}
else {
print("No value")
}
Принудительная распаковка выполняется с помощью так называемого !("взрыва") оператора. Это менее безопасно, но все же позволяет вашему коду компилироваться. Однако всякий раз, когда вы используете оператор bang, вы должны быть уверены на 1000%, что ваша переменная действительно содержит твердое значение перед принудительным развертыванием.
var myString: String?
myString = "foobar"
print(myString!)
Это выше полностью действительный код Swift. Он печатает значение, myStringкоторое было установлено как «foobar». Пользователь увидит foobarнапечатанное в консоли и все. Но давайте предположим, что значение никогда не было установлено:
var myString: String?
print(myString!)
Теперь у нас другая ситуация в наших руках. В отличие от Objective-C, всякий раз, когда делается попытка принудительно развернуть необязательный параметр, и необязательный параметр не был установлен, и nilпри попытке развернуть необязательный элемент, чтобы увидеть, что внутри вашего приложения, будет аварийно завершать работу.
Развертывание с типом литья . Как мы уже говорили ранее, хотя вы unwrappingнеобязательный, вы на самом деле приводите к не необязательному типу, вы также можете привести не необязательный тип к другому типу. Например:
var something: Any?
Где-то в нашем коде переменная somethingбудет установлена с некоторым значением. Может быть, мы используем дженерики или, может быть, есть какая-то другая логика, которая заставит это измениться. Итак, позже в нашем коде мы хотим использовать, somethingно все равно сможем обрабатывать его по-разному, если это другой тип. В этом случае вы захотите использовать asключевое слово, чтобы определить это:
Примечание: asоператор - это то, как вы печатаете приведение в 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
Обратите внимание на разницу между двумя asключевыми словами. Как и раньше, когда мы принудительно разворачивали опциональный файл, мы использовали для этого !оператор bang. Здесь вы будете делать то же самое, но вместо того, чтобы разыгрывать как необязательное, вы также разыгрываете его Int. И он должен быть в состоянии быть пониженным, как Int, в противном случае, как при использовании оператора взрыва, когда значение nilвашего приложения потерпит крах.
И для того, чтобы использовать эти переменные вообще в некоторой сортировке или математической операции, они должны быть развернуты, чтобы сделать это.
Например, в Swift только допустимые числовые типы данных одного типа могут работать друг с другом. Когда вы приводите тип с помощью параметра, as!вы принудительно понижаете значение этой переменной, как если бы вы были уверены, что она принадлежит к этому типу, поэтому она безопасна для работы и не приводит к сбою приложения. Это нормально, если переменная действительно того типа, к которому вы ее приводите, иначе у вас будет беспорядок.
Тем не менее приведение с помощью as!позволит вашему коду компилироваться. Кастинг с as?- это другая история. На самом деле, as?объявляет вас Intкак совершенно другой тип данных все вместе.
Теперь это Optional(0)
И если вы когда-нибудь пытались сделать домашнее задание, написав
1 + Optional(1) = 2
Ваш учитель математики, вероятно, дал бы вам "F". То же самое со Свифтом. За исключением того, что Свифт предпочел бы вообще не компилировать, а не давать оценку. Потому что в конце дня необязательный может фактически быть ноль .
Безопасность первых детей.
