Ответ TL; DR

За очень немногими исключениями это правило является золотым:

Избегайте использования !

Объявить переменную опциональную (?), А не неявно развернутые опции (IUO) (!)

Другими словами, скорее используйте:
var nameOfDaughter: String?

Вместо:
var nameOfDaughter: String!

Развяжите необязательную переменную, используя if let or guard let

Либо разверните переменную следующим образом:

if let nameOfDaughter = nameOfDaughter {
    print("My daughters name is: \(nameOfDaughter)")
}

Или вот так:

guard let nameOfDaughter = nameOfDaughter else { return }
print("My daughters name is: \(nameOfDaughter)")

Этот ответ должен был быть кратким, для полного понимания прочитанный принятый ответ

Этот вопрос появляется ВСЕ ВРЕМЯ на SO. Это одна из первых вещей, с которыми сталкиваются новые разработчики Swift.

История:

Swift использует концепцию "Optionals" для обработки значений, которые могут содержать значение, или нет. В других языках, таких как C, вы можете сохранить значение 0 в переменной, чтобы указать, что оно не содержит значения. Однако, что, если 0 является допустимым значением? Тогда вы можете использовать -1. Что, если -1 является допустимым значением? И так далее.

Опционы Swift позволяют настраивать переменную любого типа, содержащую либо допустимое значение, либо не значение.

Вы помещаете вопросительный знак после типа, когда объявляете переменную, которая означает (введите x или нет значения).

Необязательный на самом деле контейнер, который содержит либо переменную данного типа, либо ничего.

Необязательно необходимо "распаковать", чтобы получить значение внутри.

"!" оператор - оператор "разворота силы". Он говорит: "Поверь мне, я знаю, что делаю. Я гарантирую, что когда этот код будет запущен, переменная не будет содержать нуль". Если вы ошибаетесь, вы терпите крах.

Если вы действительно сделаете знаете, что делаете, избегайте "!" оператор разворачивания силы. Вероятно, это самый большой источник сбоев для начинающих программистов Swift.

Как иметь дело с опциями:

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

Вы можете использовать "необязательную привязку" или "если пусть" сказать "если это необязательное значение содержит значение, сохраните это значение в новой необязательной переменной. Если опция не содержит значения, пропустите тело это утверждение if.

Вот пример необязательного связывания с нашим foo необязательным:

if let newFoo = foo //If let is called optional binding. {
  print("foo is not nil")
} else {
  print("foo is nil")
}

Обратите внимание, что переменная, которую вы определяете при использовании дополнительного биллинга, существует только (только в "видимости" ) в теле оператора if.

В качестве альтернативы вы можете использовать инструкцию охраны, которая позволяет вам выйти из вашей функции, если переменная равна nil:

func aFunc(foo: Int?) {
  guard let newFoo = input else { return }
  //For the rest of the function newFoo is a non-optional var
}

В Swift 2. Guard были добавлены утверждения Guard. Guard позволяет сохранить "золотой путь" через ваш код и избегать постоянно растущих уровней вложенных ifs, которые иногда возникают из-за использования необязательной привязки "if let".

Существует также конструкция, называемая "оператор объединения нуля". Он принимает форму "optional_var?? replacement_val". Он возвращает необязательную переменную с тем же типом, что и данные, содержащиеся в необязательном. Если опция содержит nil, она возвращает значение выражения после "??" символ.

Итак, вы можете использовать такой код:

let newFoo = foo ?? "nil" // "??" is the nil coalescing operator
print("foo = \(newFoo)")

Вы также можете использовать функцию try/catch или guard error, но, как правило, один из других методов, описанных выше, является более чистым.

EDIT:

Другой, немного более тонкий getcha с опциями - это "неявно разворачиваемые опционы". Когда мы объявляем foo, мы можем сказать:

var foo: String!

В этом случае foo по-прежнему является необязательным, но вам не нужно разворачивать его, чтобы ссылаться на него. Это означает, что каждый раз, когда вы пытаетесь ссылаться на foo, вы сбрасываете его, если он равен нулю.

Итак, этот код:

var foo: String!


let upperFoo = foo.capitalizedString

Будет сбой при ссылке на свойство foo capitalizedString, даже если мы не принудительно разворачиваем foo. печать выглядит отлично, но это не так.

Таким образом, вы хотите быть очень осторожным с неявно развернутыми опциями. (и, возможно, даже избегать их полностью, пока у вас не будет четкого понимания опционных.)

Нижняя строка: когда вы впервые изучаете Swift, притворитесь "!" символ не является частью языка. Вероятно, вы попадете в неприятности.

Так как в приведенных выше ответах четко объясняется, как безопасно играть с опциями. Я попытаюсь объяснить, какие опции действительно быстрые.

Другой способ объявить необязательную переменную

var i : Optional<Int>

И необязательный тип - это не что иное, как перечисление с двумя случаями, i.e

 enum Optional<Wrapped> : ExpressibleByNilLiteral {
    case none 
    case some(Wrapped)
    .
    .
    .
}

Итак, чтобы назначить nil нашей переменной i. Мы можем сделать var i = Optional<Int>.none или присвоить значение, мы передадим некоторое значение var i = Optional<Int>.some(28)

Согласно быстрому, "ноль" - это отсутствие ценности. И создать экземпляр, инициализированный с помощью nil Мы должны соответствовать протоколу с именем ExpressibleByNilLiteral и отлично, если вы его догадались, только Optionals соответствует ExpressibleByNilLiteral и соответствует другим типам.

ExpressibleByNilLiteral имеет единственный метод, называемый init(nilLiteral:), который инициализирует instace с nil. Обычно вы не вызываете этот метод и, согласно быстрой документации, не рекомендуется называть этот инициализатор напрямую, когда компилятор вызывает его всякий раз, когда вы инициализируете необязательный тип с nil литералом.

Даже я должен обернуть (не каламбур) голову вокруг опций: D Счастливый Swfting All.

Во-первых, вы должны знать, что такое необязательное значение. Вы можете перейти на The Swift Programming Launage

для деталей.

Во-вторых, вы должны знать, что необязательное значение имеет два состояния. Один - это полное значение, а другое - значение nil. Поэтому перед реализацией необязательного значения вы должны проверить, в каком состоянии оно находится.

Вы можете использовать if let ... или guard let ... else и т.д.

Другим способом, если вы не хотите проверять его состояние перед вашим исполнением, вы также можете использовать var buildingName = buildingName ?? "buildingName".

У меня была эта ошибка, когда я пытался установить значения Outlets из метода подготовки к методу segue следующим образом:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // This line pops up the error
            destination.nameLabel.text = item.name
        }
    }
}

Затем я узнал, что не могу установить значения точек выхода контроллера назначения, потому что контроллер еще не загружен или не инициализирован.

Итак, я решил это так:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // Created this method in the destination Controller to update its outlets after it being initialized and loaded
            destination.updateView(itemData:  item)
        }
    }
}

Контроллер назначения:

// This variable to hold the data received to update the Label text after the VIEW DID LOAD
var name = ""

// Outlets
@IBOutlet weak var nameLabel: UILabel!

override func viewDidLoad() {
    super.viewDidLoad()

    // Do any additional setup after loading the view.
    nameLabel.text = name
}

func updateView(itemDate: ObjectModel) {
    name = itemDate.name
}

Я надеюсь, что этот ответ поможет любому, кто там, с той же проблемой, что и я, я заметил, что выделенный ответ - отличный ресурс для понимания опций и того, как они работают, но не затронул проблему непосредственно.

По сути, вы пытались использовать значение nil в тех местах, где Swift разрешает использовать только значения, отличные от nil, сказав компилятору, что он будет доверять вам, что там никогда не будет значения nil, что позволит вашему приложению компилироваться.

Есть несколько сценариев, которые приводят к такой фатальной ошибке:

1. принудительное развертывание:

   let user = someVariable!
   

   Если someVariable равен нулю, вы получите сбой. Делая принудительную развёртку, вы перекладывали ответственность компилятора на вас, в основном выполняя принудительную развёртку, вы гарантируете компилятору, что там никогда не будет значений nil. И угадайте, что произойдет, если каким-то образом значение nil заканчивается в someVariable?

   Решение? Используйте необязательную привязку (иначе if-let), выполните там обработку переменных:

   if user = someVariable {
       // do your stuff
   }
   

2. принудительное (вниз) приведение:

   let myRectangle = someShape as! Rectangle
   

   Здесь путем принудительного приведения вы говорите компилятору больше не беспокоиться, так как у вас всегда будет экземпляр Rectangle. И пока это действительно так, вам не о чем беспокоиться. Проблемы начинаются, когда вы или ваши коллеги из проекта начинаете распространять не прямоугольные значения.

   Решение? Используйте необязательную привязку (иначе if-let), выполните там обработку переменных:

   if let myRectangle = someShape as? Rectangle {
       // yay, I have a rectangle
   }
   

3. Неявно развернутые опции. Предположим, у вас есть следующее определение класса:

   class User {
       var name: String!
   
       init() {
           name = "(unnamed)"
       }
   
       func nicerName() {
           return "Mr/Ms " + name
       }
   }
   

   Теперь, если никто не напутает со свойством name, установив для него значение nil, тогда оно будет работать, как и ожидалось, однако, если User инициализируется из JSON, в котором отсутствует ключ name, вы получите фатальную ошибку при попытке использовать свойство,

   Решение? Не используйте их :) Если вы не уверены на 102%, что свойство всегда будет иметь значение, отличное от нуля, к моменту его использования. В большинстве случаев преобразование в необязательный или необязательный будет работать. Если вы сделаете его необязательным, компилятор также поможет вам, указав пропущенные вами пути кода, указав значение этого свойства.

4. Не подключенные или еще не подключенные розетки. Это частный случай сценария № 3. По сути, у вас есть некоторый загруженный XIB класс, который вы хотите использовать.

   class SignInViewController: UIViewController {
   
       @IBOutlet var emailTextField: UITextField!
   }
   

   Теперь, если вы пропустили подключение к розетке из редактора XIB, приложение вылетит, как только вы захотите использовать розетку. Решение? Убедитесь, что все розетки подключены. Или использовать ? оператор на них: emailTextField?.text = "[email protected]". Или объявите выход как необязательный, хотя в этом случае компилятор заставит вас развернуть его по всему коду.

5. Значения, поступающие из Objective-C, и которые не имеют аннотаций обнуляемости. Предположим, у нас есть следующий класс Objective-C:

   @interface MyUser: NSObject
   @property NSString *name;
   @end
   

   Теперь, если аннотации обнуляемости не заданы (явно или через NS_ASSUME_NONNULL_BEGIN/NS_ASSUME_NONNULL_END), свойство name будет импортировано в Swift как String! (IUO - неявно развернутый необязательный). Как только какой-то swift-код захочет использовать это значение, он потерпит крах, если name равно nil.

   Решение? Добавьте аннулируемые аннотации к вашему коду Objective-C. Однако остерегайтесь, когда компилятор Objective-C немного допустим, когда дело доходит до обнуляемости, вы можете получить нулевые значения, даже если вы явно пометили их как nonnull.

Позвольте понять это глубокое погружение, одна из самых важных вещей в Swift Language.

Необязательный в Swift означает возможность того, что значение переменной или константы может присутствовать или отсутствовать. Это не гарантирует ценность.

Как правило, переменная/константа не может иметь значение nil, если явно не указано, что переменная может иметь значение nil. Например

let a : Int = nil

не будет компилироваться.

Зачем нужны дополнительные

Во многих случаях в программировании реального мира требуются дополнительные функции. Например, если вы ищете ключ в словаре, он может присутствовать или может отсутствовать. Если вы загружаете данные с сервера, не всегда гарантируется, что вы получите ожидаемые данные. Если вы пытаетесь преобразовать какое-либо значение данных в другой тип, не гарантируется, что значение получит тип, приведенный к цели и возвращенный. Это всего лишь несколько примеров. Этот список вариантов использования длинный.

Как объявить опционные

Объявление опций очень просто. Вам просто нужно написать тип, заканчивающийся знаком вопроса. Поэтому, если вы хотите объявить переменную Int, которая может иметь значение nil (объявив необязательный тип Int). Вы можете сделать это так

var a : Int?

Вы можете иметь опцию любого типа, включая ваши пользовательские типы.

В зависимости от вашего контекста вам может потребоваться убедиться, что в необязательном значении присутствует. Доступ к фактическому значению, присутствующему в опциональном, называется распаковкой. Существуют различные способы разворачивания по желанию. Но это не всегда требуется для вас, чтобы развернуть значения, чтобы использовать его. Например, если вы используете свое необязательное значение в качестве параметра функции, которая разрешает необязательные действия, вы можете передать свое значение как необязательное, не разворачивая его. Есть несколько способов развернуть необязательное значение. Вы можете найти все способы, чтобы развернуть дополнительные функции здесь.

Хотя для использования опциональных вам не нужно знать, как они реализованы в Swift. Но всегда лучше знать это, это помогает расширить ваше понимание. Итак, давайте исследуем это

Как реализованы дополнительные функции в Swift?

Вы используете необязательный тип всякий раз, когда используете необязательные значения. Тип Optional - это перечисление с двумя падежами. Optional.none эквивалентен литералу nil. Optional.some(Wrapped) хранит упакованное значение. Например:

let number: Int? = Optional.some(56)
let noNumber: Int? = Optional.none
print(noNumber == nil)    // Prints "true"
The definition of Optional is like this in Swift

public enum Optional<Wrapped> : ExpressibleByNilLiteral {

/// The absence of a value.
///
/// In code, the absence of a value is typically written using the 'nil'
/// literal rather than the explicit '.none' enumeration case.
case none

/// The presence of a value, stored as 'Wrapped'.
case some(Wrapped)
}

Выше приведено только частичное определение Optional (показаны только случаи, а не методы).

Итак, увидев определение, вы знаете, что мы можем объявить необязательный Int как

//long form to delcare an optional Int
let number: Optional<Int>

Это просто длинная форма. Вы должны избегать использования его для удобства чтения. Вы всегда должны объявлять свои дополнительные опции с завершающим вопросительным знаком (?) С типом.

Что-то о нуле в Swift

Стрижи ноль не то же самое, что ноль во многих других языках. В большинстве других языков nil - указатель на несуществующий объект. В Swift nil - это не указатель, а отсутствие значения определенного типа. Необязательные типы любого типа могут быть установлены на ноль, а не только на типы объектов. Помните, что nil нельзя использовать с неопциональными константами и переменными. Если константа или переменная в вашем коде должны работать с отсутствием значения при определенных условиях, всегда объявляйте его как необязательное значение соответствующего типа.

Один вопрос перед закрытием темы. Рассмотрим следующий фрагмент кода

var a : Int? = 5
var b =  a
b = nil ///IS IT OK?

Каково ваше предположение? Можно ли здесь назначить ноль? ДА!. Поскольку b присваивается переменная, которая сама является необязательной Int, поэтому выведенный тип для b также будет необязательным Int.

Так что это то, что необязательно в Swift.

Источник: https://swiftwithsadiq.wordpress.com/2017/08/01/optionals-in-swift/

Это более важный комментарий, и поэтому неявно развернутые дополнительные параметры могут быть обманчивы, когда дело доходит до отладки nil значений.

Подумайте о следующем коде: он компилируется без ошибок/предупреждений:

c1.address.city = c3.address.city

Тем не менее, во время выполнения он выдает следующую ошибку: Неустранимая ошибка: неожиданно обнаружен ноль при развертывании необязательного значения

Можете ли вы сказать мне, какой объект nil?

Вы не можете!

Полный код будет:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        var c1 = NormalContact()
        let c3 = BadContact()

        c1.address.city = c3.address.city // compiler hides the truth from you and then you sudden get a crash
    }
}

struct NormalContact {
    var address : Address = Address(city: "defaultCity")
}

struct BadContact {
    var address : Address!
}

struct Address {
    var city : String
}

Короче говоря, используя var address: Address! вы скрываете возможность того, что переменная может быть nil от других читателей. И когда он выходит из строя, вы говорите: "Какого черта?! Мой address не является обязательным, так почему я рушаюсь?!".

Следовательно лучше написать так:

c1.address.city = c2.address!.city  // ERROR:  Fatal error: Unexpectedly found nil while unwrapping an Optional value 

Можете ли вы сказать мне, что это был за nil?

На этот раз код стал более понятным для вас. Вы можете рационализировать и думать, что, скорее всего, это параметр address который был принудительно развернут.

Полный код будет:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        var c1 = NormalContact()
        let c2 = GoodContact()

        c1.address.city = c2.address!.city
        c1.address.city = c2.address?.city // not compile-able. No deceiving by the compiler
        c1.address.city = c2.address.city // not compile-able. No deceiving by the compiler
        if let city = c2.address?.city {  // safest approach. But that not what I'm talking about here. 
            c1.address.city = city
        }

    }
}

struct NormalContact {
    var address : Address = Address(city: "defaultCity")
}

struct GoodContact {
    var address : Address?
}

struct Address {
    var city : String
}

фатальная ошибка: неожиданно найден nil при развертывании необязательного значения

В нем говорится, что вы используете переменную, значение которой не инициализировано или не задано nil.

Например

var tempVar: String?
print(tempVar!)

tempVar не инициализирован, поэтому в этом случае произойдет сбой приложений, поэтому вам нужно использовать

print(tempVar ?? "") 

Дополнительную информацию см. В разделе "Дополнительная цепочка"

Если вы столкнулись с этой ошибкой при работе с "tableview", вы должны проверить "идентификатор ячейки"