Вот что я считаю разницей:

var john: Person?

Средство john может быть nil

john?.apartment = number73

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

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

В то время как

john!.apartment = number73

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

john.apartment = number73

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

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

Обновить:

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

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?

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

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

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

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

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

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

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

Каждая из них - это другая языковая конструкция с другим смыслом, но все они имеют три важные вещи:

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

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

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

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

2. Восклицательными знаками являются потенциальные сбои.

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

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

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

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

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

Каждый из них ! Конструкции имеют ? который заставляет вас иметь дело с ошибкой/ноль:

• Условное развертывание: if let name = nameLabel?.text {... }
• var logo: UIImageView?: var logo: UIImageView?
• Условные отливки: logo.image = thing as? UIImage logo.image = thing as? UIImage
• Исключения Nil-on-failure: try? NSJSONSerialization.JSONObjectWithData(data, []) try? NSJSONSerialization.JSONObjectWithData(data, [])

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

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

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

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

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

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

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

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

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

Другой способ проверить значение nil равно

    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 для распаковки

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

var John: Person!

это означает, что вначале у Джона будет значение nil, оно будет установлено, и один раз установить никогда больше не будет nil-led. Поэтому для удобства я могу использовать более простой синтаксис для доступа к необязательному var, потому что это "неявно развернутый необязательный"

var currentTitle:String?
//currentTitle = "Title Name"
println("title: \(currentTitle?)") //title: nil
println("title: \(currentTitle!)") //runtime exception

var currentTitle:String?
currentTitle = "Title Name"
println("title: \(currentTitle?)") //title: Optonal("Title Name")
println("title: \(currentTitle!)") //title: Title Name

В некоторых случаях мы не можем двигаться вперед, когда необязательное значение равно 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 на самом деле является nil, когда вы делаете foo!, это ошибка времени выполнения, поэтому обычно вы хотите использовать условное разрешение вместо этого, если вы не уверены, что значение не будет равно нулю. Этот тип обмана означает, что язык может быть строго типизирован, не заставляя вас проверять, являются ли значения нулями везде.

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

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

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

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

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

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

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

Person? thisPerson;

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

thisPerson.Value

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

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

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

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

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

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

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

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

 {..}

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

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

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

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

в случае 2 произойдет сбой.

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

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

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

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

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

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

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

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

В ПРОСТОЙ СЛОВАХ

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

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

var optionalExample: String?

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

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

Джон является необязательным Лицом, то есть он может содержать значение или быть ноль.

john.apartment = number73

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

john!.apartment = number73

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

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

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

Simple the Optional variable allows nil to be stored.

var str : String? = nil

str = "Data"

To convert Optional to the Specific DataType, We unwrap the variable using the keyword "!"

func get(message : String){
   return
}

get(message : str!)  // Unwapped to pass as String

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

• Имеет ли тип person? член/свойство apartment? ИЛИ
• Имеет ли тип person член/свойство apartment?

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

_{Чтобы понять, что вам может потребоваться супер-базовый уровень понимания Generics. См. здесь. Многие вещи в 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

В качестве будущей дискуссии о том, почему использование ! для разворачивания иногда не рекомендуется, см. этот Q & A