Что значит «развернуть экземпляр»? Зачем это нужно?

Насколько я могу понять (это тоже для меня в новинку) ...

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

В «обернутом» состоянии значение необязательной переменной представляет собой перечисление с двумя возможными значениями (немного похоже на логическое значение). Это перечисление описывает, содержит ли переменная значение (Some(T)) или нет (None).

Если есть значение, его можно получить "разворачиванием" переменной (получением T от Some(T)).

Чем john!.apartment = number73 отличается от john.apartment = number73? (Перефразировано)

Если вы пишете имя необязательной переменной (например, текст john без !), это относится к "завернутому" перечислению (Some / None), а не к самому значению (T). Итак, john не является экземпляром Person и не имеет члена apartment:

john.apartment
// 'Person?' does not have a member named 'apartment'

Фактическое значение Person можно развернуть различными способами:

• "принудительное развертывание": john! (возвращает значение Person, если оно существует, ошибка времени выполнения, если оно равно нулю)
• "необязательная привязка": if let p = john { println(p) } (выполняет println, если значение существует)
• "optional chaining": john?.learnAboutSwift() (выполняет этот выдуманный метод, если значение существует)

Я предполагаю, что вы выбираете один из этих способов разворачивания в зависимости от того, что должно произойти в случае nil и насколько это вероятно. Этот дизайн языка требует явной обработки случая nil, что, как я полагаю, повышает безопасность по сравнению с Obj-C (где легко забыть обработать случай nil).

Обновление:

Восклицательный знак также используется в синтаксисе для объявления «Неявно развернутых дополнительных параметров».

До сих пор в примерах переменная john была объявлена ​​как var john:Person? и является необязательной. Если вам нужно фактическое значение этой переменной, вы должны развернуть его, используя один из трех методов, описанных выше.

Если бы вместо этого она была объявлена ​​как var john:Person!, переменная была бы неявно развернутой необязательной (см. Раздел с этим заголовком в книге Apple). Нет необходимости разворачивать этот вид переменной при доступе к значению, и john можно использовать без дополнительного синтаксиса. Но в книге Apple говорится:

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

Обновление 2:

В статье Майка Эша "Интересные функции Swift" мотивация для необязательных типов. Я думаю, это отличное, четкое письмо.

Обновление 3:

Еще одна полезная статья о неявно развернутом необязательном использовании восклицательного знака: "Swift and the Last Mile" Криса Адамсона. В статье объясняется, что это прагматическая мера, используемая Apple для объявления типов, используемых их фреймворками Objective-C, которые могут содержать nil. Объявление типа необязательным (с использованием ?) или неявно развернутым (с использованием !) - это «компромисс между безопасностью и удобством». В примерах, приведенных в статье, Apple решила объявить типы как неявно развернутые, что сделало вызывающий код более удобным, но менее безопасным.

Возможно, в будущем Apple может прочесать свои фреймворки, устраняя неопределенность неявно развернутых («вероятно, никогда не нулевых») параметров и заменяя их необязательными («безусловно, может быть нулевым в определенных [надеюсь, задокументированных!] Обстоятельствах») или стандартными нестандартными. -опциональные («никогда не равные нулю») объявления, основанные на точном поведении их кода Objective-C.

Вот в чем, я думаю, разница:

var john: Person?

Значит, Джон может быть нулевым

john?.apartment = number73

Компилятор интерпретирует эту строку как:

if john != nil {
    john.apartment = number73
}

В то время как

john!.apartment = number73

Компилятор интерпретирует эту строку так просто:

john.apartment = number73

Следовательно, использование ! развернет оператор if и заставит его работать быстрее, но если john равен nil, тогда произойдет ошибка времени выполнения.

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

Обновление:

Возвращаясь к этому ответу через 4 года, так как я получил от него самую высокую репутацию в Stackoverflow :) Я немного неправильно понял значение разворачивания в то время. Теперь, по прошествии 4 лет, я считаю, что смысл разворачивания здесь состоит в том, чтобы расширить код из его первоначальной компактной формы. Также это означает устранение неопределенности вокруг этого объекта, поскольку мы по определению не уверены, равен он нулю или нет. Так же, как ответ Эшли выше, думайте об этом как о подарке, в котором ничего не может быть. Но я все еще думаю, что развертывание - это развертывание кода, а не развертывание на основе памяти, как при использовании enum.

TL;DR

Что означает восклицательный знак в языке Swift?

Восклицательный знак фактически говорит: «Я знаю, что этот необязательный параметр определенно имеет значение; пожалуйста, используйте это ». Это называется принудительным разворачиванием значения необязательного параметра:

Пример

let possibleString: String? = "An optional string."
print(possibleString!) // requires an exclamation mark to access its value
// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."
print(assumedString)  // no exclamation mark is needed to access its value
// prints "An implicitly unwrapped optional string."

Источник: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_399

Если бы john был необязательным var (объявленным таким образом)

var john: Person?

тогда Джон может не иметь значения (на языке ObjC, значение nil)

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

if let otherPerson = john {
    otherPerson.apartment = number73
}

Внутренняя часть этого будет оцениваться только в том случае, если у john есть значение.

Немного общей картины, чтобы добавить к другим полезным, но более детальным ответам:

В Swift восклицательный знак появляется в нескольких контекстах:

• Принудительное разворачивание: let name = nameLabel!.text
• Неявно развернутые опции: var logo: UIImageView!
• Принудительный кастинг: logo.image = thing as! UIImage
• Необработанные исключения: try! NSJSONSerialization.JSONObjectWithData(data, [])

Каждый из них представляет собой разную языковую конструкцию с разным значением, но все они имеют три общие общие черты:

1. Восклицательные знаки обходят проверки безопасности Swift во время компиляции.

Когда вы используете ! в Swift, вы, по сути, говорите: «Эй, компилятор, я знаю, что вы думаете, что здесь может произойти ошибка, но я знаю с полной уверенностью, что это никогда не произойдет. буду."

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

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

2. Восклицательные знаки - потенциальные аварии.

Восклицательный знак также говорит: «Привет, Свифт, я настолько уверен, что эта ошибка никогда не может произойти, поэтому лучше для вас вывести из строя все мое приложение, чем мне запрограммируйте для него путь восстановления ".

Это опасное утверждение. Он может быть правильным: в критически важном коде, когда вы хорошо обдумываете инварианты своего кода, может оказаться, что фиктивный вывод хуже, чем сбой.

Однако, когда я вижу ! в дикой природе, он редко используется так осознанно. Вместо этого это слишком часто означает: «это значение было необязательным, и я особо не задумывался о том, почему он может быть равен нулю или как правильно справиться с этой ситуацией, но добавление ! заставило его скомпилировать ... так что мой код правильный, верно? "

Остерегайтесь высокомерия восклицательного знака. Вместо…

3. Восклицательные знаки лучше всего использовать экономно.

У каждой из этих ! конструкций есть ? аналог, который заставляет вас иметь дело с случаем error / nil:

• Условная распаковка: if let name = nameLabel?.text { ... }
• Варианты: var logo: UIImageView?
• Условное приведение: logo.image = thing as? UIImage
• Нулевые исключения при сбое: try? NSJSONSerialization.JSONObjectWithData(data, [])

Если вы испытываете искушение использовать !, всегда хорошо подумать, почему вы не используете вместо этого ?. Действительно ли сбой вашей программы - лучший вариант, если операция ! завершится неудачно? Почему это значение необязательное / недопустимое?

Есть ли разумный путь восстановления, который ваш код мог бы использовать в случае нулевого значения / ошибки? Если да, закодируйте это.

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

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

Я периодически ищу ! во всей кодовой базе и проверяю каждое его использование. Очень немногие обычаи выдерживают проверку. (На момент написания этой статьи во всей структуре Siesta было ровно два экземпляры.)

Это не значит, что вы не должны никогда использовать ! в своем коде - просто вы должны использовать его осознанно и никогда не использовать его по умолчанию.

john является необязательным var и может содержать значение nil. Чтобы гарантировать, что значение не равно нулю, используйте ! в конце имени var.

Из документации

«Убедившись, что необязательный параметр действительно содержит значение, вы можете получить доступ к его базовому значению, добавив восклицательный знак (!) в конце имени необязательного элемента. Восклицательный знак фактически говорит: «Я знаю, что этот необязательный параметр определенно имеет значение; пожалуйста, используйте его ».

Другой способ проверить ненулевое значение (необязательное разворачивание)

    if let j = json {
        // do something with j
    }

Вот некоторые примеры:

var name:String = "Hello World"
var word:String?

Где word - необязательное значение. означает, что он может содержать или не содержать значение.

word = name 

Здесь name имеет значение, поэтому мы можем его присвоить

var cow:String = nil
var dog:String!

Если dog принудительно развернут, значит, он должен содержать значение

dog = cow

Приложение выйдет из строя, потому что мы назначаем nil развернутым

В этом случае...

вар Джон: Человек!

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

Если вы пришли из языка семейства C, вы будете думать «указатель на объект типа X, который может быть адресом памяти 0 (NULL)», а если вы пришли из языка с динамической типизацией, вы будете думая: «Объект, который, вероятно, относится к типу X, но может иметь тип undefined». На самом деле ни один из них не является правильным, хотя окольным путём первый из них близок.

Вы должны думать об этом так, как если бы это был объект вроде:

struct Optional<T> {
   var isNil:Boolean
   var realObject:T
}

Когда вы тестируете свое необязательное значение с foo == nil, оно действительно возвращает foo.isNil, а когда вы говорите foo!, оно возвращает foo.realObject с утверждением, что foo.isNil == false. Это важно отметить, потому что, если foo на самом деле равно нулю, когда вы делаете foo!, это ошибка времени выполнения, поэтому обычно вы хотите использовать условное let вместо этого, если вы не уверены, что значение не будет равно нулю. Этот вид уловки означает, что язык может быть строго типизирован, не заставляя вас проверять, везде ли значения равны нулю.

На практике это не совсем так, потому что работа выполняется компилятором. На высоком уровне существует тип Foo?, который отделен от Foo, и это не позволяет функциям, принимающим тип Foo, получать значение nil, но на низком уровне необязательное значение не является истинным объектом, потому что у него нет свойств или методов. ; вполне вероятно, что на самом деле это указатель, который может быть равен NULL (0) с соответствующим тестом при принудительном развертывании.

Есть и другая ситуация, когда вы увидите восклицательный знак на типе, например:

func foo(bar: String!) {
    print(bar)
}

Это примерно эквивалентно принятию необязательного параметра с принудительным развертыванием, то есть:

func foo(bar: String?) {
    print(bar!)
}

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

! означает, что вы принудительно разворачиваете объект! следует. Дополнительную информацию можно найти в документации Apple, которую можно найти здесь: https://developer.apple.com/library/ios/documentation/swift/conceptual/Swift_Programming_Language/TheBasics.html

Если вы знакомы с C #, это похоже на типы, допускающие значение NULL, которые также объявляются с помощью вопросительного знака:

Person? thisPerson;

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

thisPerson.Value

В объективном C переменные без значения были равны 'nil' (также можно было использовать 'nil' значения, такие же, как 0 и false), следовательно, можно было использовать переменные в условных операторах (переменные, имеющие значения, такие же, как 'TRUE 'и те, у которых нет значений, были равны' ЛОЖЬ ').

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

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

var hw = "Hello World"

Здесь, несмотря на то, что 'hw' является строкой, его нельзя использовать в операторе if, как в объекте C.

//This is an error

if hw

 {..}

Для этого его нужно создать как,

var nhw : String? = "Hello World"

//This is correct

if nhw

 {..}

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

Вкратце (!): После того, как вы объявили переменную и уверены, что переменная содержит значение.

let assumedString: String! = "Some message..."
let implicitString: String = assumedString

иначе вам придется делать это каждый раз после передачи значения ...

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation mark

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

john.apartment = number73

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

john!.apartment = number73

обещает компилятору, что john не равен нулю, затем разворачивает необязательный элемент, чтобы получить значение john и обращается к свойству квартиры john. Используйте это, если вы знаете, что john не равен нулю. Если вы назовете это необязательным значением nil, вы получите ошибку времени выполнения.

В документации есть хороший пример использования этого параметра, где convertNumber является необязательным.

if convertedNumber {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}

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

var optionalExample: String?

Эта переменная не имеет значения. Если бы я развернул его, программа вылетела бы из строя, и Xcode сообщит вам, что вы пытались развернуть необязательный элемент со значением nil.

Надеюсь, это помогло.

ПРОСТЫМИ СЛОВАМИ

ИСПОЛЬЗОВАНИЕ Восклицательного знака означает, что переменная не должна содержать нулевое значение (оно никогда не может быть нулевым).

Вся история начинается с функции swift, называемой optional vars. Это вары, которые могут иметь значение или не иметь значения. В общем, swift не позволяет нам использовать переменную, которая не инициализирована, так как это может привести к сбоям или непредвиденным причинам, а также сервер заполнитель для бэкдоров. Таким образом, чтобы объявить переменную, значение которой изначально не определено, мы используем '?'. Когда такая переменная объявляется, чтобы использовать ее как часть какого-либо выражения, ее необходимо развернуть перед использованием, развертывание - это операция, посредством которой обнаруживается значение переменной, это применимо к объектам. Без развертывания, если вы попытаетесь использовать их, у вас будет ошибка времени компиляции. Чтобы развернуть переменную, которая является необязательной переменной var, воспользуйтесь восклицательным знаком "!" используется.

Теперь бывают случаи, когда вы знаете, что таким необязательным переменным будут присвоены значения системой, например, или вашей собственной программой, но когда-нибудь позже, например, через выходы пользовательского интерфейса, в такой ситуации вместо объявления необязательной переменной с помощью вопросительного знака "?" мы используем "!".

Таким образом, система знает, что эта переменная, объявленная с "!" является необязательным прямо сейчас и не имеет значения, но получит значение позже в своем жизненном цикле.

Таким образом, восклицательный знак имеет два разных использования: 1. Для объявления переменной, которая будет необязательной и определенно получит значение позже. 2. Чтобы развернуть необязательную переменную перед ее использованием в выражении.

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

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

if (myNumber != 3){
 // if myNumber is NOT 3 do whatever is inside these brackets.
)

Необязательная переменная может содержать значение или не содержать

случай 1: var myVar:String? = "Something"

случай 2: var myVar:String? = nil

теперь, если вы спросите myVar !, вы говорите компилятору вернуть значение в случае 1, он вернет "Something"

в случае 2 он выйдет из строя.

Имея в виду ! mark заставит компилятор вернуть значение, даже если его нет. вот почему название Принудительное разворачивание.

Для сотрудников Google:

john!.department

... сообщает компилятору:

• Я знаю, что john не является обязательным
• Используйте его так, как будто он имеет ценность
• Просто рухни, если нет

В производстве используйте guard let или if let, чтобы справиться с ситуацией обесценивания и аннулирования серьезных сбоев.

СПРОСИТЕ СЕБЯ

• Есть ли у типа person? член / свойство apartment? ИЛИ
• Есть ли у типа person член / свойство apartment?

Если вы не можете ответить на этот вопрос, продолжайте читать:

_{Для понимания вам может потребоваться сверхбазовый уровень понимания универсальных шаблонов. См. здесь. Многие вещи в Swift написаны с использованием Generics. Включены опции}

Приведенный ниже код был доступен из этого Стэнфордского видео. Настоятельно рекомендую посмотреть первые 5 минут

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

enum Optional<T>{
    case None
    case Some(T)
}

let x: String? = nil //actually means:

let x = Optional<String>.None

let x :String? = "hello" //actually means:

let x = Optional<String>.Some("hello")

var y = x! // actually means:

switch x {
case .Some(let value): y = value
case .None: // Raise an exception
}

Необязательная привязка:

let x:String? = something
if let y = x {
    // do something with y
}
//Actually means:

switch x{
case .Some(let y): print)(y) // or whatever else you like using 
case .None: break
}

когда вы говорите var john: Person?, вы на самом деле имеете в виду такие:

enum Optional<Person>{
case .None
case .Some(Person)
}

Есть ли в приведенном выше перечислении какое-либо свойство с именем apartment? Вы где-нибудь это видите? Его там совсем нет! Однако если вы его развернете, то есть сделаете person!, тогда вы сможете ... то, что он делает под капотом, это: Optional<Person>.Some(Person(name: "John Appleseed"))

Если бы вы определили var john: Person вместо: var john: Person?, тогда вам больше не нужно было бы использовать !, потому что сам Person имеет член apartment

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