protocol extension swift optional

extension - swift syntax



¿Qué es un valor opcional en Swift? (12)

Aquí hay una declaración opcional equivalente en Swift:

var middleName: String?

Esta declaración crea una variable llamada middleName de tipo String. El signo de interrogación (?) Después del tipo de variable String indica que la variable middleName puede contener un valor que puede ser String o nil. Cualquiera que vea este código de inmediato sabe que middleName puede ser nulo. ¡Es autodocumentada!

Si no especifica un valor inicial para una constante o variable opcional (como se muestra arriba), el valor se establece automáticamente en nulo para usted. Si lo prefiere, puede establecer explícitamente el valor inicial en nil:

var middleName: String? = nil

para más detalles para leer opcional debajo del enlace

http://www.iphonelife.com/blog/31369/swift-101-working-swifts-new-optional-values

De la documentación de Apple :

Puede usar if y let que trabajen juntos con los valores que pueden faltar. Estos valores se representan como opcionales. Un valor opcional contiene un valor o contiene nil para indicar que falta el valor. Escriba un signo de interrogación ( ? ) Después del tipo de un valor para marcar el valor como opcional.

¿Por qué querrías usar un valor opcional?

Bien...

? (Opcional) indica que su variable puede contener un valor nulo mientras ! (sin envoltorio) indica que su variable debe tener una memoria (o valor) cuando se usa (se intenta obtener un valor de ella) en tiempo de ejecución.

La principal diferencia es que el encadenamiento opcional falla con gracia cuando el opcional es nulo, mientras que el desenvolvimiento forzado desencadena un error de tiempo de ejecución cuando el opcional es nulo.

Para reflejar el hecho de que el encadenamiento opcional se puede llamar en un valor nulo, el resultado de una llamada de encadenamiento opcional es siempre un valor opcional, incluso si la propiedad, el método o el subíndice que está consultando devuelve un valor no opcional. Puede usar este valor de retorno opcional para verificar si la llamada de encadenamiento opcional fue exitosa (la opcional devuelta contiene un valor), o no tuvo éxito debido a un valor nulo en la cadena (el valor opcional devuelto es nulo).

Específicamente, el resultado de una llamada de encadenamiento opcional es del mismo tipo que el valor de retorno esperado, pero envuelto en un opcional. Una propiedad que normalmente devuelve un Int devolverá un Int? cuando se accede a través de encadenamiento opcional.

var defaultNil : Int? // declared variable with default nil value println(defaultNil) >> nil var canBeNil : Int? = 4 println(canBeNil) >> optional(4) canBeNil = nil println(canBeNil) >> nil println(canBeNil!) >> // Here nil optional variable is being unwrapped using ! mark (symbol), that will show runtime error. Because a nil optional is being tried to get value using unwrapper var canNotBeNil : Int! = 4 print(canNotBeNil) >> 4 var cantBeNil : Int = 4 cantBeNil = nil // can''t do this as it''s not optional and show a compile time error

Aquí hay un tutorial básico en detalle, por el Comité de Desarrolladores de Apple: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html

Desde https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html :

El encadenamiento opcional es un proceso para consultar y llamar a propiedades, métodos y subíndices en un opcional que actualmente podría ser nulo. Si el opcional contiene un valor, la propiedad, el método o el subíndice de la llamada se realiza correctamente; si el opcional es nil, la propiedad, el método o la llamada de subíndice devuelve nil. Se pueden encadenar varias consultas, y la cadena completa falla con gracia si cualquier enlace en la cadena es nulo.

Para entender más profundamente, lea el enlace de arriba.

El valor opcional le permite mostrar ausencia de valor. Poco como NULL en SQL o NSNull en Objective-C. Supongo que esto será una mejora, ya que puede usarlo incluso para los tipos "primitivos".

// Reimplement the Swift standard library''s optional type enum OptionalValue<T> { case None case Some(T) } var possibleInteger: OptionalValue<Int> = .None possibleInteger = .Some(100)”

Extracto de: Apple Inc. "El lenguaje de programación Swift". IBooks. https://itun.es/gb/jEUH0.l

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

Swift proporciona seguridad de tipo proporcionando "valor opcional". Es decir, evita que se formen errores al asignar variables de diferentes tipos.

Entonces, en Swift, solo los booleanos pueden proporcionarse en sentencias condicionales.

var hw = "Hello World"

Aquí, aunque ''hw'' es una cadena, no se puede usar en una sentencia 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 {..}

Experimentemos con el siguiente código de juegos . Espero tener una idea clara de lo que es opcional y la razón de su uso.

var sampleString: String? ///Optional, Possible to be nil sampleString = nil ////perfactly valid as its optional sampleString = "some value" //Will hold the value if let value = sampleString{ /// the sampleString is placed into value with auto force upwraped. print(value+value) ////Sample String merged into Two } sampleString = nil // value is nil and the if let value = sampleString{ print(value + value) ///Will Not execute and safe for nil checking } // print(sampleString! + sampleString!) //this line Will crash as + operator can not add nil

Hice una breve respuesta, que resume la mayor parte de lo anterior, para eliminar la incertidumbre que había en mi cabeza como principiante:

Opuesto a Objective-C, ninguna variable puede contener nula en Swift, por lo que se agregó el tipo de variable opcional (variables con el sufijo "?"):

var aString = nil //error

La gran diferencia es que las variables Opcionales no almacenan valores directamente (como lo harían las variables Obj-C normales), contienen dos estados : " tiene un valor " o " tiene cero ":

var aString: String? = "Hello, World!" aString = nil //correct, now it contains the state "has nil"

Por eso, puedes revisar esas variables en diferentes situaciones:

if let myString = aString? { println(myString) } else { println("It''s nil") // this will print in our case }

Usando el "!" sufijo, también puede acceder a los valores envueltos en ellos, solo si existen . (es decir, no es nulo ):

let aString: String? = "Hello, World!" // var anotherString: String = aString //error var anotherString: String = aString! println(anotherString) //it will print "Hello, World!"

Es por eso que necesitas usar "?" y "!" y no usarlos todos por defecto. (este fue mi mayor desconcierto)

También estoy de acuerdo con la respuesta anterior: el tipo opcional no se puede utilizar como booleano .

No puede tener una variable que apunta a nil en Swift: no hay punteros y no hay punteros nulos. Pero en una API, a menudo desea poder indicar un tipo específico de valor o una falta de valor, por ejemplo, ¿mi ventana tiene un delegado y, de ser así, quién es? Los opcionales son la forma de Swift, segura para el tipo y segura en memoria, para hacer esto

Tomemos el ejemplo de un NSError , si no se devuelve un error, querría que fuera opcional devolver Nil. No tiene sentido asignarle un valor si no hay un error ...

var error: NSError? = nil

Esto también le permite tener un valor predeterminado. Por lo tanto, puede establecer un método como un valor predeterminado si la función no se pasa nada.

func doesntEnterNumber(x: Int? = 5) -> Bool { if (x == 5){ return true } else { return false } }

Un opcional en Swift es un tipo que puede contener un valor o ningún valor. Las opcionales se escriben agregando un ? a cualquier tipo:

var name: String? = "Bertie"

Los opcionales (junto con los genéricos) son uno de los conceptos Swift más difíciles de entender. Debido a la forma en que se escriben y utilizan, es fácil tener una idea equivocada de lo que son. Compara lo opcional de arriba para crear una cadena normal:

var name: String = "Bertie" // No "?" after String

Desde la sintaxis parece que una cadena opcional es muy similar a una cadena ordinaria. No es. Una cadena opcional no es una cadena con algún ajuste "opcional" activado. No es una variedad especial de cuerdas. Una cadena y una cadena opcional son tipos completamente diferentes.

Esto es lo más importante que debe saber: un opcional es un tipo de contenedor. Una cadena opcional es un contenedor que puede contener una cadena. Un Int opcional es un contenedor que puede contener un Int. Piense en un opcional como un tipo de paquete. Antes de abrirlo (o "desenvolver" en el idioma de los opcionales) no sabrá si contiene algo o nada.

Puede ver cómo se implementan las opciones en la biblioteca estándar de Swift escribiendo "Opcional" en cualquier archivo Swift y haciendo clic en él. Aquí está la parte importante de la definición:

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

Opcional es solo una enum que puede ser uno de dos casos: .none o .none . Si es .some , hay un valor asociado que, en el ejemplo anterior, sería la String "Hola". Un opcional utiliza Genéricos para dar un tipo al valor asociado. El tipo de una Cadena opcional no es String , es Optional , o más precisamente Optional<String> .

Todo lo que Swift hace con los opcionales es mágico para que la lectura y escritura de códigos sea más fluida. Desafortunadamente, esto oscurece la forma en que realmente funciona. Voy a pasar por algunos de los trucos más tarde.

Nota: Hablaré mucho sobre variables opcionales, pero también está bien crear constantes opcionales. Marco todas las variables con su tipo para facilitar la comprensión de los tipos de tipos que se crean, pero no es necesario que lo haga en su propio código.

Cómo crear opcionales

Para crear un opcional, agregue un ? después del tipo que desea envolver. Cualquier tipo puede ser opcional, incluso sus propios tipos personalizados. ¿No puedes tener un espacio entre el tipo y el ? .

var name: String? = "Bob" // Create an optional String that contains "Bob" var peter: Person? = Person() // An optional "Person" (custom type) // A class with a String and an optional String property class Car { var modelName: String // must exist var internalName: String? // may or may not exist }

Usando opcionales

Puedes comparar un opcional a nil para ver si tiene un valor:

var name: String? = "Bob" name = nil // Set name to nil, the absence of a value if name != nil { print("There is a name") } if name == nil { // Could also use an "else" print("Name has no value") }

Esto es un poco confuso. Implica que un opcional es una cosa u otra. O bien es nulo o es "Bob". Esto no es cierto, lo opcional no se transforma en otra cosa. Compararlo con nulo es un truco para hacer que el código sea más fácil de leer. Si un opcional es igual a cero, esto solo significa que la enumeración está establecida actualmente en .none .

Solo los opcionales pueden ser nulos.

Si intenta establecer una variable no opcional en nil, obtendrá un error.

var red: String = "Red" red = nil // error: nil cannot be assigned to type ''String''

Otra forma de ver los opcionales es como un complemento a las variables Swift normales. Son una contraparte de una variable que se garantiza que tiene un valor. Swift es un lenguaje cuidadoso que odia la ambigüedad. La mayoría de las variables se definen como no opcionales, pero a veces esto no es posible. Por ejemplo, imagine un controlador de vista que carga una imagen desde un caché o desde la red. Puede o no tener esa imagen en el momento en que se crea el controlador de vista. No hay forma de garantizar el valor de la variable de imagen. En este caso tendrías que hacerlo opcional. Comienza como nil y cuando se recupera la imagen, el opcional obtiene un valor.

Usando un opcional revela la intención de los programadores. En comparación con Objective-C, donde cualquier objeto podría ser nulo, Swift necesita que tengas claro cuándo puede faltar un valor y cuándo se garantiza que exista.

Para usar un opcional, lo "desenvuelven"

No se puede usar una String opcional en lugar de una String real. Para utilizar el valor envuelto dentro de un opcional, debe desenvolverlo. La forma más sencilla de desenvolver un opcional es agregar un ! después del nombre opcional. Esto se llama "fuerza de desenvolvimiento". Devuelve el valor dentro del opcional (como el tipo original) pero si el opcional es nil , provoca un bloqueo en tiempo de ejecución. Antes de desenvolverlo, debes estar seguro de que hay un valor.

var name: String? = "Bob" let unwrappedName: String = name! print("Unwrapped name: /(unwrappedName)") name = nil let nilName: String = name! // Runtime crash. Unexpected nil.

Comprobación y uso de un opcional.

Debido a que siempre debe verificar que no haya nada antes de desempaquetar y usar un opcional, este es un patrón común:

var mealPreference: String? = "Vegetarian" if mealPreference != nil { let unwrappedMealPreference: String = mealPreference! print("Meal: /(unwrappedMealPreference)") // or do something useful }

En este patrón, verifica que haya un valor presente, luego, cuando esté seguro de que lo está, forzará a desenvolverlo en una constante temporal para usar. Debido a que esto es algo muy común, Swift ofrece un atajo con "if let". Esto se llama "enlace opcional".

var mealPreference: String? = "Vegetarian" if let unwrappedMealPreference: String = mealPreference { print("Meal: /(unwrappedMealPreference)") }

Esto crea una constante temporal (o variable si reemplaza let por var ) cuyo alcance solo está dentro de las llaves de if. Debido a que tener que usar un nombre como "unwrappedMealPreference" o "realMealPreference" es una carga, Swift le permite reutilizar el nombre de la variable original, creando uno temporal dentro del alcance del corchete

var mealPreference: String? = "Vegetarian" if let mealPreference: String = mealPreference { print("Meal: /(mealPreference)") // separate from the other mealPreference }

Aquí hay un código para demostrar que se usa una variable diferente:

var mealPreference: String? = "Vegetarian" if var mealPreference: String = mealPreference { print("Meal: /(mealPreference)") // mealPreference is a String, not a String? mealPreference = "Beef" // No effect on original } // This is the original mealPreference print("Meal: /(mealPreference)") // Prints "Meal: Optional("Vegetarian")"

El enlace opcional funciona verificando si el opcional es igual a cero. Si no lo hace, desenvuelve lo opcional en la constante provista y ejecuta el bloque. En Xcode 8.3 y versiones posteriores (Swift 3.1), intentar imprimir un opcional como este provocará una advertencia inútil. Utilice la debugDescription de debugDescription la opcional para silenciarla:

print("/(mealPreference.debugDescription)")

¿Para qué son las opcionales?

Los opcionales tienen dos casos de uso:

  1. Cosas que pueden fallar (esperaba algo pero no tengo nada)
  2. Cosas que ahora no son nada, pero podrían ser algo más tarde (y viceversa)

Algunos ejemplos concretos:

  • Una propiedad que puede estar allí o no, como middleName o spouse en una clase de Person
  • Un método que puede devolver un valor o nada, como buscar una coincidencia en una matriz
  • Un método que puede devolver un resultado u obtener un error y no devolver nada, como intentar leer el contenido de un archivo (que normalmente devuelve los datos del archivo) pero el archivo no existe
  • Delegar propiedades, que no siempre tienen que establecerse y generalmente se establecen después de la inicialización
  • Por propiedades weak en las clases. Lo que apuntan se puede establecer en nil en cualquier momento
  • Un gran recurso que podría ser liberado para reclamar la memoria.
  • Cuando necesita una forma de saber cuándo se ha establecido un valor (datos aún no cargados> los datos) en lugar de usar un Boolean DataLoaded separado

Los opcionales no existen en Objective-C, pero hay un concepto equivalente, devolviendo nil. Los métodos que pueden devolver un objeto pueden devolver nil en su lugar. Se entiende que esto significa "la ausencia de un objeto válido" y se usa a menudo para decir que algo salió mal. Solo funciona con objetos Objective-C, no con primitivos o tipos C básicos (enumeraciones, estructuras). Objective-C a menudo tenía tipos especializados para representar la ausencia de estos valores ( NSNotFound que en realidad es NSIntegerMax , kCLLocationCoordinate2DInvalid para representar una coordenada no válida, -1 o algún valor negativo también se usan). El programador debe conocer estos valores especiales, por lo que deben documentarse y aprenderse para cada caso. Si un método no puede tomar nil como parámetro, esto debe documentarse. En Objective-C, nil era un puntero al igual que todos los objetos se definían como punteros, pero nil apuntaba a una dirección específica (cero). En Swift, nil es un literal que significa la ausencia de cierto tipo.

Comparando a nil

Antes podías usar cualquier opcional como Boolean :

let leatherTrim: CarExtras? = nil if leatherTrim { price = price + 1000 }

En versiones más recientes de Swift tienes que usar leatherTrim != nil . ¿Por qué es esto? El problema es que un Boolean se puede envolver en un opcional. Si tienes Boolean como este:

var ambiguous: Boolean? = false

tiene dos tipos de "falso", uno donde no hay ningún valor y otro donde tiene un valor pero el valor es false . Swift odia la ambigüedad, por lo que ahora siempre debes marcar un opcional contra nil .

Usted podría preguntarse cuál es el punto de un Boolean opcional? Al igual que con otros opcionales, el estado .none podría indicar que el valor aún no se conoce. Puede haber algo en el otro extremo de una llamada de red que demora un tiempo en sondear. Los booleanos opcionales también se llaman " booleanos de tres valores "

Trucos rápidos

Swift usa algunos trucos para permitir que funcionen las opcionales. Considere estas tres líneas de código opcional de aspecto ordinario;

var religiousAffiliation: String? = "Rastafarian" religiousAffiliation = nil if religiousAffiliation != nil { ... }

Ninguna de estas líneas debe compilar.

  • La primera línea establece una cadena opcional utilizando un literal de cadena, dos tipos diferentes. Incluso si esta era una String los tipos son diferentes
  • La segunda línea establece una cadena opcional a cero, dos tipos diferentes
  • La tercera línea compara una cadena opcional a cero, dos tipos diferentes

Revisaré algunos de los detalles de implementación de los opcionales que permiten que estas líneas funcionen.

Creando un opcional

Utilizando ? para crear un opcional es el azúcar sintáctico, habilitado por el compilador Swift. Si quieres hacerlo a lo largo, puedes crear un opcional como este:

var name: Optional<String> = Optional("Bob")

Esto llama al primer inicializador Optional , public init(_ some: Wrapped) , que infiere el tipo asociado al opcional usado del tipo usado entre los paréntesis.

La forma aún más larga de crear y configurar un opcional:

var serialNumber:String? = Optional.none serialNumber = Optional.some("1234") print("/(serialNumber.debugDescription)")

Configuración de un opcional a nil

Puede crear un opcional sin valor inicial, o crear uno con el valor inicial de nil (ambos tienen el mismo resultado).

var name: String? var name: String? = nil

Permitir que las opciones sean iguales a nil se habilita mediante el protocolo ExpressibleByNilLiteral (anteriormente denominado NilLiteralConvertible ). El opcional se crea con el segundo inicializador Optional , public init(nilLiteral: ()) . Los documentos dicen que no deberías usar ExpressibleByNilLiteral para nada excepto para opcionales, ya que eso cambiaría el significado de nil en tu código, pero es posible hacerlo:

class Clint: ExpressibleByNilLiteral { var name: String? required init(nilLiteral: ()) { name = "The Man with No Name" } } let clint: Clint = nil // Would normally give an error print("/(clint.name)")

El mismo protocolo le permite establecer un opcional ya creado en nil . Aunque no se recomienda, puede utilizar el inicializador literal nil directamente:

var name: Optional<String> = Optional(nilLiteral: ())

Comparando un opcional a nil

Los opcionales definen dos operadores especiales "==" y "! =", Que puede ver en la definición Optional . El primer == permite verificar si alguno de los opcionales es igual a cero. Dos opcionales diferentes que se configuran en .none siempre serán iguales si los tipos asociados son los mismos. Cuando se compara con nada, detrás de las escenas, Swift crea un opcional del mismo tipo asociado, establecido en .none y luego lo usa para la comparación.

// How Swift actually compares to nil var tuxedoRequired: String? = nil let temp: Optional<String> = Optional.none if tuxedoRequired == temp { // equivalent to if tuxedoRequired == nil print("tuxedoRequired is nil") }

El segundo operador == permite comparar dos opcionales. Ambos deben ser del mismo tipo y ese tipo debe ajustarse a Equatable (el protocolo que permite comparar cosas con el operador "==" normal). Swift (presumiblemente) desenvuelve los dos valores y los compara directamente. También maneja el caso donde uno o ambos de los opcionales son .none . Note la distinción entre comparando con el literal nil .

Además, le permite comparar cualquier tipo Equatable con un Equatable opcional de ese tipo:

let numberToFind: Int = 23 let numberFromString: Int? = Int("23") // Optional(23) if numberToFind == numberFromString { print("It''s a match!") // Prints "It''s a match!" }

Detrás de escena, Swift envuelve lo no opcional como opcional antes de la comparación. También funciona con literales ( if 23 == numberFromString { )

Dije que hay dos operadores == , pero en realidad hay un tercero que te permite poner nil en el lado izquierdo de la comparación

if nil == name { ... }

Opción de nombres

No existe una convención Swift para nombrar tipos opcionales de manera diferente a los tipos no opcionales. Las personas evitan agregar algo al nombre para mostrar que es opcional (como "optionMiddleName", o "possibleNumberAsString") y dejar que la declaración muestre que es un tipo opcional. Esto se dificulta cuando se desea asignar un nombre a algo para mantener el valor de un opcional. El nombre "middleName" implica que es un tipo de cadena, por lo que cuando extrae el valor de la cadena, a menudo puede terminar con nombres como "actualMiddleName" o "unwrappedMiddleName" o "realMiddleName". Utilice el enlace opcional y reutilice el nombre de la variable para evitar esto.

La definicion oficial

De developer.apple.com/library/prerelease/ios/documentation/Swift/… :

Swift también introduce tipos opcionales, que manejan la ausencia de un valor. Los opcionales dicen que "hay un valor, y es igual a x" o "no hay un valor en absoluto". Los opcionales son similares a usar nil con punteros en Objective-C, pero funcionan para cualquier tipo, no solo para clases. Los opcionales son más seguros y expresivos que los punteros nulos en Objective-C y están en el corazón de muchas de las características más poderosas de Swift.

Los opcionales son un ejemplo del hecho de que Swift es un lenguaje de tipo seguro. Swift le ayuda a tener en claro los tipos de valores con los que puede trabajar su código. Si parte de su código espera una Cadena, el tipo de seguridad le impide pasar un Int por error. Esto le permite detectar y corregir errores lo antes posible en el proceso de desarrollo.

Para terminar, aquí hay un poema de 1899 sobre opcionales:

Ayer sobre la escalera
Conocí a un hombre que no estaba allí
No estaba allí otra vez hoy
Ojalá quisiera que se fuera.
Antigonish

Más recursos:

Un opcional significa que Swift no está completamente seguro de si el valor corresponde al tipo: por ejemplo, Int? significa que Swift no está completamente seguro de si el número es un Int.

Para eliminarlo, hay tres métodos que podrías emplear.

1) Si está absolutamente seguro del tipo, puede usar un signo de exclamación para forzar el desenvolverlo, como esto:

// Here is an optional variable: var age: Int? // Here is how you would force unwrap it: var unwrappedAge = age!

Si obliga a desenvolver un opcional y es igual a cero, puede encontrar este error de bloqueo:

Esto no es necesariamente seguro, por lo que aquí hay un método que puede evitar que se bloquee en caso de que no esté seguro del tipo y valor:

Los métodos 2 y tres salvaguardan contra este problema.

2) El Opcional Implícitamente Sin Envolver

if let unwrappedAge = age { // continue in here }

Tenga en cuenta que el tipo desenvuelto es ahora Int , en lugar de Int? .

3) La declaración del guardia.

guard let unwrappedAge = age else { // continue in here }

A partir de aquí, puede seguir adelante y utilizar la variable desenvuelta. Asegúrate solo de forzar el desenvolvimiento (con un!), Si estás seguro del tipo de variable.

¡Buena suerte con tu proyecto!

Cuando empecé a aprender Swift era muy difícil darse cuenta de por qué opcional .

Vamos a pensar de esta manera. Consideremos una Person clase que tiene dos name propiedad y company .

class Person: NSObject { var name : String //Person must have a value so its no marked as optional var companyName : String? ///Company is optional as a person can be unemployed that is nil value is possible init(name:String,company:String?) { self.name = name self.companyName = company } }

Ahora vamos a crear algunos objetos de Person

var tom:Person = Person.init(name: "Tom", company: "Apple")//posible var bob:Person = Person.init(name: "Bob", company:nil) // also Possible because company is marked as optional so we can give Nil

Pero no podemos pasar de Nil a name

var personWithNoName:Person = Person.init(name: nil, company: nil)

Ahora vamos a hablar de por qué usamos optional? . Consideremos una situación en la que deseamos agregar Inc después de que el nombre de la compañía como apple sea apple Inc Necesitamos agregar Inc después del nombre de la compañía e imprimir.

print(tom.companyName+" Inc") ///Error saying optional is not unwrapped. print(tom.companyName!+" Inc") ///Error Gone..we have forcefully unwrap it which is wrong approach..Will look in Next line print(bob.companyName!+" Inc") ///Crash!!!because bob has no company and nil can be unwrapped.

Ahora veamos por qué lo opcional tiene lugar.

if let companyString:String = bob.companyName{///Compiler safely unwrap company if not nil.If nil,no unwrap. print(companyString+" Inc") //Will never executed and no crash!!! }

Vamos a reemplazar bob con tom

if let companyString:String = tom.companyName{///Compiler safely unwrap company if not nil.If nil,no unwrap. print(companyString+" Inc") //Will never executed and no crash!!! }

Y enhorabuena! ¿Hemos tratado adecuadamente con optional?

Así que los puntos de realización son

  1. Marcaremos una variable como opcional si es posible que sea nil
  2. Si deseamos utilizar esta variable en algún lugar del compilador de códigos, le recordaremos que debemos comprobar si tenemos el trato adecuado con esa variable si contiene nil .

Gracias ... Feliz Codificación