La guía del lenguaje de programación Swift tiene el siguiente ejemplo:

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

//From Apple's “The Swift Programming Language” guide (https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html)

Luego, al asignar el departamento a la persona, usan un signo de exclamación para "desenvolver la instancia":

john!.apartment = number73

¿Qué significa "desenvolver la instancia"? ¿Por qué es necesario? ¿Cómo es diferente de hacer lo siguiente?

john.apartment = number73

Soy muy nuevo en el lenguaje Swift. Solo trato de entender lo básico.

ACTUALIZACIÓN:
La gran pieza del rompecabezas que me faltaba (no se indica directamente en las respuestas, al menos no al momento de escribir esto) es que cuando haces lo siguiente:

var john: Person?

eso NO significa que " johnes de tipo Persony podría ser nulo", como originalmente pensé. Simplemente estaba malinterpretando eso Persony Person?son tipos completamente separados. Una vez que entendí eso, todo lo demás ?, la !locura y las excelentes respuestas a continuación, tenían mucho más sentido.

¿Qué significa "desenvolver la instancia"? ¿Por qué es necesario?

Hasta donde puedo hacer ejercicio (esto también es muy nuevo para mí) ...

El término "envuelto" implica que debemos pensar en una variable Opcional como un regalo, envuelto en papel brillante, que podría (¡lamentablemente!) Estar vacío .

Cuando se "ajusta", el valor de una variable opcional es una enumeración con dos valores posibles (un poco como un booleano). Esta enumeración describe si la variable tiene un valor ( Some(T)) o no ( None).

Si hay un valor, esto puede obtenerse "desenvolviendo" la variable (obteniendo el Tde Some(T)).

¿Cómo es john!.apartment = number73diferente de john.apartment = number73? (Parafraseado)

Si escribe el nombre de una variable Opcional (por ejemplo john, texto , sin el !), esto se refiere a la enumeración "envuelta" (Algunos / Ninguno), no al valor en sí (T). Entonces johnno es una instancia de Person, y no tiene un apartmentmiembro:

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

El Personvalor real se puede desenvolver de varias maneras:

• "desenvolvimiento forzado": john!(da el Personvalor si existe, error de tiempo de ejecución si es nulo)
• "enlace opcional": if let p = john { println(p) }(ejecuta printlnel valor si existe)
• "encadenamiento opcional": john?.learnAboutSwift()(ejecuta este método inventado si el valor existe)

Supongo que eliges una de estas formas de desenvolver, dependiendo de lo que suceda en el caso nulo y de cuán probable sea. Este diseño de lenguaje obliga a que el caso nulo se maneje explícitamente, lo que supongo que mejora la seguridad sobre Obj-C (donde es fácil olvidar manejar el caso nulo).

Actualización :

El signo de exclamación también se usa en la sintaxis para declarar "Opciones implícitas sin envolver".

En los ejemplos hasta ahora, la johnvariable ha sido declarada como var john:Person?, y es una Opcional. Si desea el valor real de esa variable, debe desenvolverla, utilizando uno de los tres métodos anteriores.

Si se declarara como en su var john:Person!lugar, la variable sería una Opcional implícitamente sin envolver (consulte la sección con este encabezado en el libro de Apple). No es necesario desenvolver este tipo de variable al acceder al valor, y johnpuede usarse sin sintaxis adicional. Pero el libro de Apple dice:

Las opciones implícitamente desenvueltas no deben usarse cuando existe la posibilidad de que una variable se vuelva nula en un momento posterior. Utilice siempre un tipo opcional normal si necesita verificar un valor nulo durante la vida útil de una variable.

Actualización 2 :

El artículo " Características interesantes de Swift " de Mike Ash ofrece cierta motivación para los tipos opcionales. Creo que es genial, una escritura clara.

Actualización 3 :

Otro artículo útil sobre el uso opcional implícitamente sin envolver para el signo de exclamación: " Swift and the Last Mile " de Chris Adamson. El artículo explica que esta es una medida pragmática de Apple utilizada para declarar los tipos utilizados por sus marcos Objective-C que pueden contener nulo. Declarar un tipo como opcional (usando ?) o implícitamente sin envolver (usando !) es "una compensación entre seguridad y conveniencia". En los ejemplos dados en el artículo, Apple ha decidido declarar los tipos como implícitamente desenvueltos, haciendo que el código de llamada sea más conveniente, pero menos seguro.

Tal vez Apple podría revisar sus marcos en el futuro, eliminando la incertidumbre de los parámetros implícitamente desenvueltos ("probablemente nunca nulos") y reemplazándolos por opcionales ("ciertamente podría ser nulo en particular [¡con suerte, documentado!] Circunstancias") o no estándar -opcionales ("nunca es nulo"), basadas en el comportamiento exacto de su código Objective-C.

Esto es lo que creo que es la diferencia:

var john: Person?

Significa que John puede ser nulo

john?.apartment = number73

El compilador interpretará esta línea como:

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

Mientras

john!.apartment = number73

El compilador interpretará esta línea simplemente:

john.apartment = number73

Por lo tanto, usando! desenvolverá la instrucción if y hará que se ejecute más rápido, pero si john es nulo, se producirá un error de tiempo de ejecución.

Entonces, envolver aquí no significa que está envuelto en memoria, pero significa que está envuelto en código, en este caso está envuelto con una declaración if, y debido a que Apple presta mucha atención al rendimiento en tiempo de ejecución, quieren darle una forma de haga que su aplicación funcione con el mejor rendimiento posible.

Actualizar:

Volviendo a esta respuesta después de 4 años, ya que obtuve la mayor reputación en Stackoverflow :) No entendí un poco el significado de desenvolver en ese momento. Ahora, después de 4 años, creo que el significado de desenvolver aquí es expandir el código de su forma compacta original. También significa eliminar la vaguedad alrededor de ese objeto, ya que no estamos seguros por definición de que sea nulo o no. Al igual que la respuesta de Ashley anterior, piense en ello como un regalo que no podría contener nada. Pero sigo pensando que el desenvolvimiento es desenvolvimiento de código y no desenvolvimiento basado en memoria como el uso de la enumeración.

TL; DR

¿Qué significa un signo de exclamación en el lenguaje Swift?

El signo de exclamación efectivamente dice: “Sé que este opcional definitivamente tiene un valor; por favor úsalo ". Esto se conoce como desenvolvimiento forzado del valor del opcional:

Ejemplo

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."

Fuente: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_399

Si juan fuera una var opcional (declarada así)

var john: Person?

entonces sería posible que John no tuviera ningún valor (en el lenguaje de ObjC, valor nulo)

El signo de exclamación básicamente le dice al compilador "Sé que esto tiene un valor, no necesita probarlo". Si no desea utilizarlo, puede probarlo condicionalmente:

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

El interior de esto solo evaluará si John tiene un valor.

Alguna perspectiva general para agregar a las otras respuestas útiles pero más centradas en los detalles:

En Swift, el signo de exclamación aparece en varios contextos:

• Envoltura forzada: let name = nameLabel!.text
• Opcionales implícitamente sin envolver: var logo: UIImageView!
• Fundición forzada: logo.image = thing as! UIImage
• Excepciones no manejadas: try! NSJSONSerialization.JSONObjectWithData(data, [])

Cada uno de estos es una construcción de lenguaje diferente con un significado diferente, pero todos tienen tres cosas importantes en común:

1. Los signos de exclamación eluden los controles de seguridad en tiempo de compilación de Swift.

Cuando lo usa !en Swift, esencialmente dice: "Oye, compilador, sé que cree que podría ocurrir un error aquí, pero sé con total certeza que nunca lo hará".

No todo el código válido cabe en la caja del sistema de tipos de tiempo de compilación de Swift, o la comprobación de tipos estáticos de cualquier idioma, para el caso. Hay situaciones en las que puede probar lógicamente que nunca se producirá un error, pero no puede probarlo al compilador . Es por eso que los diseñadores de Swift agregaron estas características en primer lugar.

Sin embargo, cada vez que usa !, descarta tener una ruta de recuperación para un error, lo que significa que ...

2. Los puntos de exclamación son posibles accidentes.

Un signo de exclamación también dice: "Hola Swift, estoy tan seguro de que este error nunca puede ocurrir que es mejor que bloquees toda mi aplicación que codificar una ruta de recuperación para ella".

Esa es una afirmación peligrosa. Se puede ser la correcta: en clave de misión crítica en la que han pensado mucho sobre invariantes de su código, puede ser que la salida falsa es peor que un accidente.

Sin embargo, cuando veo !en la naturaleza, rara vez se usa con tanta atención. En cambio, con demasiada frecuencia significa, "este valor era opcional y realmente no pensé demasiado sobre por qué podría ser nulo o cómo manejar adecuadamente esa situación, pero agregarlo !lo compiló ... así que mi código es correcto, ¿verdad?"

Cuidado con la arrogancia del signo de exclamación. En lugar…

3. Los puntos de exclamación se usan mejor con moderación.

Cada una de estas !construcciones tiene una ?contraparte que te obliga a lidiar con el caso de error / nulo:

• Desenvoltura condicional: if let name = nameLabel?.text { ... }
• Opcionales: var logo: UIImageView?
• Lanzamientos condicionales: logo.image = thing as? UIImage
• Excepciones sin falla: try? NSJSONSerialization.JSONObjectWithData(data, [])

Si tiene la tentación de usar !, siempre es bueno considerar cuidadosamente por qué no lo está usando ?. ¿Bloquear su programa es realmente la mejor opción si la !operación falla? ¿Por qué ese valor es opcional / no disponible?

¿Existe una ruta de recuperación razonable que su código podría tomar en el caso de nulo / error? Si es así, codifíquelo.

Si no puede ser nulo, si el error nunca puede suceder, ¿hay alguna forma razonable de reelaborar su lógica para que el compilador lo sepa? Si es así, hazlo; su código será menos propenso a errores.

Hay momentos en que no hay una forma razonable de manejar un error, y simplemente ignorar el error, y así proceder con datos incorrectos, sería peor que estrellarse. Esos son los momentos para usar el desenvolvimiento forzado.

Periódicamente busco en toda mi base de código !y audito cada uso del mismo. Muy pocos usos resisten el escrutinio. (Al escribir estas líneas, todo el marco de Siesta tiene exactamente dos instancias de él).

Eso no quiere decir que nunca debe usarlo !en su código, solo que debe usarlo conscientemente y nunca hacerlo la opción predeterminada.

johnEs opcional var. Entonces puede ser contiene un nilvalor. Para asegurarse de que el valor no sea nulo, utilice un !al final del varnombre.

De la documentación

“Una vez que esté seguro de que el opcional contiene un valor, puede acceder a su valor subyacente agregando un signo de exclamación (!) Al final del nombre del opcional. El signo de exclamación efectivamente dice: “Sé que este opcional definitivamente tiene un valor; por favor úsalo ".

Otra forma de verificar el valor no nulo es

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

Aquí hay unos ejemplos:

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

Donde wordes un valor opcional. significa que puede o no contener un valor.

word = name 

Aquí nametiene un valor para que podamos asignarlo

var cow:String = nil
var dog:String!

Donde dogse desenvuelve con fuerza significa que debe contener un valor

dog = cow

La aplicación se bloqueará porque estamos asignados nila desenvuelto

En este caso...

var John: Persona!

significa que, inicialmente, John tendrá un valor nulo, se establecerá y una vez que se establezca, nunca volverá a estar dirigido por nada. Por lo tanto, por conveniencia, puedo usar la sintaxis más fácil para acceder a una variable opcional porque esta es una "opción implícitamente desenvuelta"

Si ha venido de un lenguaje de familia C, estará pensando "puntero al objeto de tipo X, que podría ser la dirección de memoria 0 (NULL)", y si viene de un lenguaje de tipo dinámico, estará pensando "Objeto que probablemente sea de tipo X pero podría ser de tipo indefinido". Ninguno de estos es realmente correcto, aunque de manera indirecta, el primero está cerca.

La forma en que debería pensar es como si fuera un objeto como:

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

Cuando está probando su valor opcional con foo == nilrealmente está regresando foo.isNil, y cuando dice foo!que está regresando foo.realObjectcon una afirmación de que foo.isNil == false. Es importante tener en cuenta esto porque si en foorealidad es nulo cuando lo hacesfoo! , es un error de tiempo de ejecución, por lo que generalmente querría usar un let condicional en lugar de estar muy seguro de que el valor no será nulo. Este tipo de truco significa que el lenguaje puede ser fuertemente tipado sin obligarlo a probar si los valores son nulos en todas partes.

En la práctica, realmente no se comporta así porque el compilador realiza el trabajo. En un nivel alto hay un tipo Foo?que es independiente de Foo, y que evita que los funcs que aceptan el tipo Fooreciban un valor nulo, pero en un nivel bajo un valor opcional no es un objeto verdadero porque no tiene propiedades ni métodos; es probable que, de hecho, sea un puntero que puede ser NULL (0) con la prueba adecuada cuando se desenrolla a la fuerza.

Hay otra situación en la que verías un signo de exclamación en un tipo, como en:

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

Esto es más o menos equivalente a aceptar un opcional con un desenvolvimiento forzado, es decir:

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

Puede usar esto para tener un método que técnicamente acepta un valor opcional pero que tendrá un error de tiempo de ejecución si es nulo. En la versión actual de Swift, esto aparentemente pasa por alto la afirmación de no es nula, por lo que en su lugar tendrá un error de bajo nivel. Generalmente no es una buena idea, pero puede ser útil al convertir código de otro idioma.

Los ! significa que estás forzando a desenvolver el objeto! sigue. Se puede encontrar más información en la documentación de Apple, que se puede encontrar aquí: https://developer.apple.com/library/ios/documentation/swift/conceptual/Swift_Programming_Language/TheBasics.html

Si está familiarizado con C #, esto es como los tipos anulables que también se declaran con un signo de interrogación:

Person? thisPerson;

Y el signo de exclamación en este caso es equivalente a acceder a la propiedad .Value del tipo anulable de esta manera:

thisPerson.Value

En el objetivo C, las variables sin valor eran iguales a 'nulo' (también era posible usar valores 'nulo' igual a 0 y falso), por lo tanto, era posible usar variables en declaraciones condicionales (las variables que tienen valores son iguales a 'VERDADERO' 'y aquellos sin valores eran iguales a' FALSO ').

Swift proporciona seguridad de tipo al proporcionar 'valor opcional'. es decir, evita errores formados al asignar variables de diferentes tipos.

Entonces, en Swift, solo se pueden proporcionar booleanos en las declaraciones condicionales.

var hw = "Hello World"

Aquí, aunque 'hw' es una cadena, no se puede usar en una declaración if como en el objetivo C.

//This is an error

if hw

 {..}

Para eso necesita ser creado como,

var nhw : String? = "Hello World"

//This is correct

if nhw

 {..}

Los ! al final de un objeto dice que el objeto es opcional y que se desenvuelve si de lo contrario puede devolver un valor nulo. Esto a menudo se usa para atrapar errores que de otro modo bloquearían el programa.

En resumen (!): Después de declarar una variable y de estar seguro de que la variable tiene un valor.

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

de lo contrario, tendría que hacer esto cada vez que pase el valor ...

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

John es una persona opcional, lo que significa que puede tener un valor o ser nulo.

john.apartment = number73

se usa si juan no es un opcional. Como John nunca es nulo, podemos estar seguros de que no llamará a un apartamento con un valor nulo. Mientras

john!.apartment = number73

promete al compilador que John no es nulo, luego desenvuelve lo opcional para obtener el valor de John y accede a la propiedad del apartamento de John. Use esto si sabe que John no es nulo. Si llama a esto en un cero opcional, obtendrá un error de tiempo de ejecución.

La documentación incluye un buen ejemplo para usar esto donde convertNumber es opcional.

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

En pocas palabras, los signos de exclamación significan que se está desenvolviendo un opcional. Un opcional es una variable que puede tener un valor o no, por lo que puede verificar si la variable está vacía, utilizando una instrucción if let como se muestra aquí , y luego forzar el desenvolvimiento. Sin embargo, si fuerza a desenvolver un opcional que está vacío, su programa se bloqueará, ¡así que tenga cuidado! Las opciones se declaran poniendo un signo de interrogación al final de una asignación explícita a una variable, por ejemplo, podría escribir:

var optionalExample: String?

Esta variable no tiene valor. Si lo desenvolviera, el programa se bloquearía y Xcode le diría que intentó desenvolver un opcional con un valor nulo.

Espero que haya ayudado.

En palabras simples

USANDO El signo de exclamación indica que la variable debe constar de un valor nulo (nunca será nulo)

Toda la historia comienza con una característica de swift llamada vars opcionales. Estos son los vars que pueden tener un valor o no tener un valor. En general, swift no nos permite usar una variable que no está inicializada, ya que esto puede provocar bloqueos o razones inesperadas y también un servidor de marcador de posición para puertas traseras. Por lo tanto, para declarar una variable cuyo valor no se determina inicialmente, usamos un '?'. Cuando se declara dicha variable, para usarla como parte de alguna expresión hay que desenvolverla antes de usarla, desenvolver es una operación a través de la cual se descubre el valor de una variable que se aplica a los objetos. Sin desenvolver si intentas usarlos, tendrás un error de tiempo de compilación. Para desenvolver una variable que es una var opcional, el signo de exclamación "!" es usado

Ahora hay momentos en que sabe que a tales variables opcionales se les asignarán valores por sistema, por ejemplo, o por su propio programa, pero en algún momento posterior, por ejemplo, salidas de interfaz de usuario, en tal situación en lugar de declarar una variable opcional usando un signo de interrogación "?" usamos "!".

Así, el sistema sabe que esta variable que se declara con "!" es opcional en este momento y no tiene valor, pero recibirá un valor más adelante en su vida útil.

Por lo tanto, el signo de exclamación tiene dos usos diferentes: 1. Para declarar una variable que será opcional y recibirá un valor definitivamente más tarde 2. Para desenvolver una variable opcional antes de usarla en una expresión.

Las descripciones anteriores evitan demasiadas cosas técnicas, espero.

Si lo usa como opcional, desenvuelve el opcional y ve si hay algo allí. Si lo usa en una declaración if-else, es un código para NOT. Por ejemplo,

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

Una variable opcional puede contener un valor o no

caso 1: var myVar:String? = "Something"

caso 2: var myVar:String? = nil

ahora si le preguntas a myVar !, le estás diciendo al compilador que devuelva un valor en el caso 1, devolverá "Something"

en el caso 2 se bloqueará.

Sentido ! mark forzará al compilador a devolver un valor, incluso si no está allí. Es por eso que el nombre Force Unwrapping .

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

PREGÚNTESE

• ¿El tipo person?tiene un apartmentmiembro / propiedad? O
• ¿El tipo persontiene un apartmentmiembro / propiedad?

Si no puede responder esta pregunta, continúe leyendo:

_{Para comprenderlo, es posible que necesite un nivel súper básico de comprensión de los genéricos . Ver aquí . Muchas cosas en Swift se escriben usando genéricos. Opcionales incluidos}

El siguiente código se ha puesto a disposición en este video de Stanford . Le recomiendo que mire los primeros 5 minutos

Un opcional es una enumeración con solo 2 casos

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
}

Encuadernación opcional:

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
}

cuando dices var john: Person?que realmente quieres decir eso:

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

¿La enumeración anterior tiene alguna propiedad nombrada apartment? ¿Lo ves en alguna parte? Es que no hay en absoluto! Sin embargo, si lo desenvuelve, es decir, person!puede ... lo que hace debajo del capó es:Optional<Person>.Some(Person(name: "John Appleseed"))

Si hubiera definido en var john: Personlugar de: var john: Person?entonces ya no habría necesitado tener el !usado, porque Personsí tiene un miembro deapartment

Como una discusión futura sobre por qué !a veces no se recomienda usar para desenvolver, vea estas preguntas y respuestas