У меня была эта ошибка, когда я пытался установить значения 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's being initialized and loaded
            destination.updateView(itemData:  item)
        }
    }
}

Destination Controller:

// 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
}

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

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

.

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

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

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

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

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

var i : Optional<Int>

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

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

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

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

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

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

TL; DR answer

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

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

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

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

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

Исключить необязательную переменную с помощью if let или 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 использует концепцию «Опционы» для обработки значений, которые могут содержать значение, или нет. В других языках, таких как C, вы можете сохранить значение 0 в переменной, чтобы указать, что оно не содержит значения. Однако, что, если 0 является допустимым значением? Тогда вы можете использовать -1. Что, если -1 является допустимым значением? И так далее.

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

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

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

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

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

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

Как бороться с опциями:

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

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

Ниже приведен пример необязательной привязки с нашим foo необязательным:

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

Примечание. что переменная, которую вы определяете при использовании дополнительного biding, существует (только «в области видимости») в теле оператора 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, но, как правило, один из других методов выше - более чистый.

РЕДАКТИРОВАТЬ:

Еще один, немного более тонкий ключ с опциями - это «неявно разворачиваемые опционы». Когда мы объявляем foo, мы можем сказать:

var foo: String!

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

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

var foo: String!


let upperFoo = foo.capitalizedString

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

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

Нижняя строка. Когда вы впервые изучаете Swift, притворитесь, что символ «!» не является частью язык. Вероятно, вы получите int o проблема.