Quelle est une valeur facultative dans Swift?

De la documentation d’Apple :

Vous pouvez utiliser if et let ensemble pour travailler avec des valeurs qui pourraient être manquantes. Ces valeurs sont représentées par des options. Une valeur facultative contient une valeur ou contient une valeur nil pour indiquer que la valeur est manquante. Écrivez un point d’interrogation ( ? ) Après le type d’une valeur pour marquer la valeur comme facultative.

Pourquoi voudriez-vous utiliser une valeur facultative?

    Un optionnel dans Swift est un type pouvant contenir une valeur ou aucune valeur. Les options sont écrites en ajoutant a ? à tout type:

     var name: Ssortingng? = "Bertie" 

    Les options (ainsi que les génériques) sont l’un des concepts Swift les plus difficiles à comprendre. En raison de la façon dont ils sont écrits et utilisés, il est facile de se faire une idée fausse de ce qu’ils sont. Comparez les options ci-dessus pour créer une chaîne normale:

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

    D’après la syntaxe, une chaîne facultative ressemble beaucoup à une chaîne ordinaire. Ce n’est pas. Une chaîne facultative n’est pas une chaîne avec un paramètre “facultatif” activé. Ce n’est pas une variété spéciale de Ssortingng. Une chaîne et une chaîne facultative sont des types complètement différents.

    Voici la chose la plus importante à savoir: Une option est une sorte de conteneur. Une chaîne facultative est un conteneur pouvant contenir une chaîne. Un Int optionnel est un conteneur pouvant contenir un Int. Pensez à une option comme une sorte de colis. Avant de l’ouvrir (ou de “dérouler” dans le langage des options), vous ne saurez pas si elle contient quelque chose ou rien.

    Vous pouvez voir comment les options sont implémentées dans la bibliothèque standard Swift en tapant “Facultatif” dans n’importe quel fichier Swift et en cliquant dessus. Voici la partie importante de la définition:

     enum Optional { case none case some(Wrapped) } 

    Facultatif est juste une enum qui peut être l’un des deux cas suivants: .none ou .some . S’il s’agit de .some , il y a une valeur associée qui, dans l’exemple ci-dessus, serait la Ssortingng “Hello”. Un optionnel utilise Generics pour donner un type à la valeur associée. Le type d’une chaîne facultative n’est pas une Ssortingng , il est Optional ou plus précisément Optional .

    Tout ce que Swift fait avec les options est magique pour rendre la lecture et l’écriture du code plus fluides. Malheureusement, cela obscurcit la façon dont cela fonctionne réellement. Je passerai en revue quelques-unes des astuces plus tard.

    Note: Je parlerai beaucoup des variables facultatives, mais il est bon de créer aussi des constantes facultatives. Je marque toutes les variables avec leur type pour faciliter la compréhension des types de types en cours de création, mais vous n’êtes pas obligé de le faire dans votre propre code.


    Comment créer des options

    Pour créer une option, ajoutez un ? après le type que vous souhaitez emballer. N’importe quel type peut être facultatif, même vos propres types personnalisés. Vous ne pouvez pas avoir d’espace entre le type et le ? .

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

    Utiliser des options

    Vous pouvez comparer une option à nil pour voir si elle a une valeur:

     var name: Ssortingng? = "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") } 

    C’est un peu déroutant. Cela implique qu’une option est une chose ou une autre. C’est soit nul soit “Bob”. Ce n’est pas vrai, l’option ne se transforme pas en autre chose. La comparer au néant est une astuce pour rendre le code plus facile à lire. Si une option est égale à zéro, cela signifie simplement que l’énumération est actuellement définie sur .none .


    Seuls les optionnels peuvent être nuls

    Si vous essayez de définir une variable non facultative sur nil, vous obtenez une erreur.

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

    Une autre façon de voir les options est de compléter les variables Swift normales. Ils sont la contrepartie d’une variable dont la valeur est garantie. Swift est un langage prudent qui déteste l’ambiguïté. La plupart des variables sont définies comme non optionnelles, mais cela n’est parfois pas possible. Par exemple, imaginez un contrôleur de vue qui charge une image à partir d’un cache ou du réseau. Il peut ou non avoir cette image au moment où le contrôleur de vue est créé. Il n’y a aucun moyen de garantir la valeur de la variable image. Dans ce cas, vous devrez le rendre facultatif. Il commence comme nil et lorsque l’image est récupérée, l’option obtient une valeur.

    L’utilisation d’une option révèle l’intention du programmeur. Comparé à Objective-C, où n’importe quel object peut être nul, Swift a besoin que vous sachiez quand une valeur peut être manquante et quand elle est garantie.


    Pour utiliser un optionnel, vous le “défilez”

    Une Ssortingng facultative ne peut pas être utilisée à la place d’une Ssortingng réelle. Pour utiliser la valeur encapsulée dans une option, vous devez la déballer. La manière la plus simple de dérouler une option est d’append un ! après le nom facultatif. C’est ce qu’on appelle “déballer la force”. Il retourne la valeur dans le facultatif (comme le type d’origine) mais si l’option est nil , cela provoque un plantage à l’exécution. Avant de déballer, vous devez être sûr qu’il y a une valeur.

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

    Vérification et utilisation d’une option

    Comme vous devez toujours vérifier la présence de zéro avant de déballer et d’utiliser une option, il s’agit d’un modèle courant:

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

    Dans ce modèle, vous vérifiez qu’une valeur est présente, puis lorsque vous êtes sûr que c’est le cas, vous forcez à le déballer dans une constante temporaire à utiliser. Parce que c’est une chose si commune à faire, Swift propose un raccourci avec “if let”. Cela s’appelle “liaison facultative”.

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

    Cela crée une constante temporaire (ou une variable si vous remplacez let avec var ) dont la scope est uniquement entre les accolades if. Parce que devoir utiliser un nom comme “unwrappedMealPreference” ou “realMealPreference” est un fardeau, Swift vous permet de réutiliser le nom de la variable d’origine, en créant un nom temporaire dans la scope de la parenthèse

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

    Voici un code pour démontrer qu’une variable différente est utilisée:

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

    La liaison facultative fonctionne en vérifiant si l’option est égale à zéro. Si ce n’est pas le cas, il déballe l’option dans la constante fournie et exécute le bloc. Dans Xcode 8.3 et versions ultérieures (Swift 3.1), essayer d’imprimer une option comme celle-ci provoquera un avertissement inutile. Utilisez le debugDescription facultatif pour le faire taire:

     print("\(mealPreference.debugDescription)") 

    À quoi servent les optionnels?

    Les options ont deux cas d’utilisation:

    1. Des choses qui peuvent échouer (je m’attendais à quelque chose mais je n’ai rien eu)
    2. Des choses qui ne sont rien maintenant mais qui pourraient être quelque chose plus tard (et vice-versa)

    Quelques exemples concrets:

    • Une propriété qui peut être là ou pas, comme middleName ou spouse dans une classe de Person
    • Une méthode qui peut retourner une valeur ou rien, comme la recherche d’une correspondance dans un tableau
    • Une méthode qui peut renvoyer soit un résultat, soit une erreur et ne rien retourner, comme essayer de lire le contenu d’un fichier (qui retourne normalement les données du fichier) mais le fichier n’existe pas
    • Les propriétés de délégué, qui ne doivent pas toujours être définies et sont généralement définies après l’initialisation
    • Pour les propriétés weak dans les classes. La chose à laquelle ils font référence peut être définie à nil à tout moment
    • Une ressource importante qui pourrait devoir être libérée pour récupérer de la mémoire
    • Lorsque vous avez besoin d’un moyen de savoir quand une valeur a été définie (données non encore chargées> les données) au lieu d’utiliser une valeur Boolean dataLoaded distincte

    Les options n’existent pas dans Objective-C, mais il existe un concept équivalent qui renvoie nil. Les méthodes pouvant renvoyer un object peuvent renvoyer à la place à la place. Cela signifie “l’absence d’un object valide” et est souvent utilisé pour dire que quelque chose s’est mal passé. Il ne fonctionne qu’avec les objects Objective-C, pas avec les primitives ou les types de base (enums, structs). Objective-C avait souvent des types spécialisés pour représenter l’absence de ces valeurs ( NSNotFound qui est en réalité NSIntegerMax , kCLLocationCoordinate2DInvalid pour représenter une coordonnée non valide, -1 ou une valeur négative sont également utilisés). Le codeur doit connaître ces valeurs spéciales afin qu’elles soient documentées et apsockets pour chaque cas. Si une méthode ne peut prendre aucun paramètre, cela doit être documenté. Dans Objective-C, nil était un pointeur comme tous les objects étaient définis comme des pointeurs, mais nil indiquait une adresse spécifique (zéro). Dans Swift, nil est un littéral qui signifie l’absence d’un certain type.


    En comparant au nil

    Vous pouviez utiliser n’importe quelle option en tant que Boolean :

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

    Dans les versions plus récentes de Swift, vous devez utiliser leatherTrim != nil . Pourquoi est-ce? Le problème est qu’un Boolean peut être inclus dans une option. Si vous avez un Boolean comme celui-ci:

     var ambiguous: Boolean? = false 

    il a deux sortes de “faux”, un où il n’y a pas de valeur et un autre où il a une valeur mais la valeur est false . Swift déteste l’ambiguïté, donc maintenant vous devez toujours vérifier une option contre nil .

    Vous pourriez vous demander quel est le but d’un Boolean optionnel? Comme avec d’autres options, l’état .none pourrait indiquer que la valeur est encore inconnue. Il peut y avoir quelque chose à l’autre bout d’un appel réseau qui prend un certain temps à interroger. Les booléens facultatifs sont également appelés ” booléens à trois valeurs ”


    Astuces rapides

    Swift utilise des astuces pour permettre aux optionnels de fonctionner. Considérez ces trois lignes de code facultatif d’apparence ordinaire;

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

    Aucune de ces lignes ne doit être compilée.

    • La première ligne définit une chaîne facultative à l’aide d’un littéral Ssortingng, deux types différents. Même si c’était une Ssortingng les types sont différents
    • La deuxième ligne définit une chaîne facultative sur nil, deux types différents
    • La troisième ligne compare une chaîne optionnelle à nil, deux types différents

    Je vais passer en revue certains détails d’implémentation des options qui permettent à ces lignes de fonctionner.


    Créer une option

    En utilisant ? créer un facultatif est le sucre syntaxique, activé par le compilateur Swift. Si vous voulez le faire longtemps, vous pouvez créer une option comme celle-ci:

     var name: Optional = Optional("Bob") 

    Cela appelle le premier initialiseur de la fonction, public init(_ some: Wrapped) , qui déduit le type associé à l’option du type utilisé entre parenthèses.

    Le moyen encore plus long de créer et de définir une option:

     var serialNumber:Ssortingng? = Optional.none serialNumber = Optional.some("1234") print("\(serialNumber.debugDescription)") 

    Définir une option à nil

    Vous pouvez créer une option sans valeur initiale ou en créer une avec la valeur initiale de nil (les deux ont le même résultat).

     var name: Ssortingng? var name: Ssortingng? = nil 

    Autoriser les optionnels à égalité nil est activé par le protocole ExpressibleByNilLiteral (précédemment nommé NilLiteralConvertible ). L’option est créée avec le deuxième initialiseur de Optional , public init(nilLiteral: ()) . Les documents disent que vous ne devriez pas utiliser ExpressibleByNilLiteral pour autre chose que des options, car cela changerait le sens de nil dans votre code, mais il est possible de le faire:

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

    Le même protocole vous permet de définir une option déjà créée à nil . Bien que ce ne soit pas recommandé, vous pouvez utiliser l’initialiseur littéral nil directement:

     var name: Optional = Optional(nilLiteral: ()) 

    Comparer un optionnel à nil

    Les options définissent deux opérateurs spéciaux “==” et “! =”, Que vous pouvez voir dans la définition Optional . Le premier == vous permet de vérifier si une option est égale à zéro. Deux options différentes définies sur .none seront toujours égales si les types associés sont identiques. Lorsque vous comparez à zéro, en arrière-plan, Swift crée une option du même type associé, définie sur .none, puis l’utilise pour la comparaison.

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

    Le second opérateur == vous permet de comparer deux options. Les deux doivent être du même type et ce type doit être conforme à Equatable (le protocole qui permet de comparer les choses avec l’opérateur “==” normal). Swift (probablement) déballe les deux valeurs et les compare directement. Il gère également le cas où l’un des options ou les deux sont .none . Notez la distinction entre comparer au littéral nil .

    De plus, il vous permet de comparer n’importe Equatable type Equatable à un emballage optionnel de ce type:

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

    Dans les coulisses, Swift encapsule le non-optionnel comme option avant la comparaison. Cela fonctionne aussi avec les littéraux ( if 23 == numberFromSsortingng { )

    J’ai dit qu’il y avait deux opérateurs == , mais il y a en fait un tiers qui vous permet de mettre à nil le côté gauche de la comparaison.

     if nil == name { ... } 

    Options de dénomination

    Il n’y a pas de convention Swift pour nommer les types optionnels différemment des types non optionnels. Les gens évitent d’append quelque chose au nom pour montrer que c’est une option (comme “optionalMiddleName”, ou “possibleNumberAsSsortingng”) et que la déclaration montre que c’est un type facultatif. Cela devient difficile quand vous voulez nommer quelque chose pour conserver la valeur d’un optionnel. Le nom “middleName” implique que c’est un type Ssortingng, donc lorsque vous en extrayez la valeur Ssortingng, vous pouvez souvent vous retrouver avec des noms comme “actualMiddleName” ou “unwrappedMiddleName” ou “realMiddleName”. Utilisez la liaison facultative et réutilisez le nom de la variable pour contourner ce problème.


    La définition officielle

    De “The Basics” dans le langage de programmation rapide :

    Swift introduit également des types optionnels, qui gèrent l’absence de valeur. Les optionnels disent soit “il y a une valeur, et c’est égal à x” ou “il n’y a pas de valeur du tout”. Les options sont similaires à l’utilisation de nil avec des pointeurs dans Objective-C, mais elles fonctionnent pour tout type, pas seulement pour les classes. Les options sont plus sûres et plus expressives que les pointeurs nuls d’Objective-C et sont au cœur de nombreuses fonctionnalités les plus puissantes de Swift.

    Les options sont un exemple du fait que Swift est un langage de type sécurisé. Swift vous aide à comprendre les types de valeurs avec lesquelles votre code peut fonctionner. Si une partie de votre code attend une chaîne, la sécurité de type vous empêche de la transmettre par erreur. Cela vous permet de détecter et de corriger les erreurs le plus tôt possible dans le processus de développement.


    Pour finir, voici un poème de 1899 sur les optionnels:

    Hier sur l’escalier
    J’ai rencontré un homme qui n’était pas là
    Il n’était plus là aujourd’hui
    Je souhaite, je souhaite qu’il s’en aille
    Antigonish


    Davantage de ressources:

    • Le guide de programmation Swift
    • Options dans Swift (Medium)
    • Session 402 de la WWDC “Introduction à Swift” (commence vers 14h15)
    • Plus de trucs et astuces optionnels

    Prenons l’exemple d’une NSError , si aucune erreur n’est renvoyée, vous voudrez la rendre facultative pour renvoyer Nil. Il n’y a aucun intérêt à lui atsortingbuer une valeur s’il n’y a pas d’erreur.

     var error: NSError? = nil 

    Cela vous permet également d’avoir une valeur par défaut. Donc, vous pouvez définir une méthode une valeur par défaut si la fonction n’est rien passé

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

    Vous ne pouvez pas avoir une variable qui pointe sur nil dans Swift – il n’y a pas de pointeurs et pas de pointeurs NULL. Mais dans une API, vous voulez souvent pouvoir indiquer un type de valeur spécifique ou un manque de valeur – par exemple, ma fenêtre a-t-elle un délégué, et si oui, qui est-ce? Les options sont le moyen sûr et sécurisé de Swift de le faire.

    J’ai fait une brève réponse, qui résume l’essentiel de ce qui précède, pour nettoyer l’incertitude qui était dans ma tête en tant que débutant:

    Contrairement à Objective-C, aucune variable ne peut contenir nil dans Swift, de sorte que le type de variable optionnel a été ajouté (variables suffixées par “?”):

      var aSsortingng = nil //error 

    La grande différence est que les variables facultatives ne stockent pas directement les valeurs (comme le feraient les variables Obj-C normales): elles contiennent deux états : ” a une valeur ” ou ” a nil “:

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

    Cela étant, vous pouvez vérifier ces variables dans différentes situations:

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

    En utilisant le “!” suffixe, vous pouvez également accéder aux valeurs qui les entourent, uniquement si celles-ci existent . (c.-à-d. qu’il n’est pas nul ):

     let aSsortingng: Ssortingng? = "Hello, World!" // var anotherSsortingng: Ssortingng = aSsortingng //error var anotherSsortingng: Ssortingng = aSsortingng! println(anotherSsortingng) //it will print "Hello, World!" 

    C’est pourquoi vous devez utiliser “?” et “!” et ne pas les utiliser tous par défaut. (c’était ma plus grande confusion)

    Je suis également d’accord avec la réponse ci-dessus: Le type facultatif ne peut pas être utilisé comme un booléen .

    Dans l’objective C, les variables sans valeur étaient égales à «nil» (il était également possible d’utiliser les valeurs «nil» identiques à 0 et à false), il était donc possible d’utiliser des variables dans des instructions conditionnelles (les variables ayant les mêmes valeurs que TRUE). ‘et ceux sans valeur étaient égaux à’ FALSE ‘).

    Swift fournit la sécurité de type en fournissant une «valeur facultative». C’est-à-dire qu’il évite les erreurs résultant de l’affectation de variables de types différents.

    Donc, dans Swift, seuls les booléens peuvent être fournis sur les instructions conditionnelles.

     var hw = "Hello World" 

    Ici, même si “hw” est une chaîne, elle ne peut pas être utilisée dans une instruction if comme dans l’objective C.

     //This is an error if hw {..} 

    Pour cela il faut créer comme,

     var nhw : Ssortingng? = "Hello World" //This is correct if nhw {..} 

    La valeur facultative vous permet de montrer l’absence de valeur. Un peu comme NULL dans SQL ou NSNull dans Objective-C. Je suppose que ce sera une amélioration car vous pouvez l’utiliser même pour les types “primitifs”.

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

    Extrait de: Apple Inc. «Le langage de programmation rapide». IBooks. https://itun.es/gb/jEUH0.l

    Une option signifie que Swift n’est pas tout à fait sûr si la valeur correspond au type: par exemple, Int? signifie que Swift n’est pas tout à fait sûr que le numéro soit un Int.

    Pour le supprimer, vous pouvez utiliser trois méthodes.

    1) Si vous êtes absolument certain du type, vous pouvez utiliser un point d’exclamation pour le forcer, comme ceci:

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

    Si vous forcez de dérouler une option et que celle-ci est égale à zéro, vous pouvez rencontrer cette erreur:

    entrer la description de l'image ici

    Ce n’est pas nécessairement sûr, alors voici une méthode qui pourrait empêcher les plantage au cas où vous ne seriez pas certain du type et de la valeur:

    Les méthodes 2 et 3 protègent contre ce problème.

    2) Le facultatif non emballé implicitement

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

    Notez que le type non compressé est maintenant Int , plutôt que Int? .

    3) le relevé de garde

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

    De là, vous pouvez aller de l’avant et utiliser la variable non emballée. Assurez-vous seulement de forcer le dépliage (avec un!), Si vous êtes sûr du type de la variable.

    Bonne chance pour votre projet!

    Permet d’expérimenter avec le terrain de jeu ci-dessous. J’espère que vous comprendrez ce qui est facultatif et la raison de son utilisation.

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

    Lorsque j’ai commencé à apprendre Swift il était très difficile de comprendre pourquoi optionnel .

    Permet de penser de cette façon. Considérons une classe Person qui a deux name propriété et company .

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

    Laisse maintenant créer quelques objects 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 

    Mais nous ne pouvons pas passer Nil à name

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

    Maintenant, parlons de pourquoi nous utilisons optional? . Considérons une situation où nous voulons append Inc après le nom de l’entreprise comme apple sera apple Inc Nous devons append Inc après le nom de la société et imprimer.

     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. 

    Maintenant, étudions pourquoi la mise en place facultative.

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

    Permet de remplacer bob avec tom

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

    Et félicitations! nous avons correctement traiter avec optional?

    Les points de réalisation sont donc

    1. Nous allons marquer une variable comme facultative si elle peut être nil
    2. Si nous voulons utiliser cette variable quelque part dans le compilateur de code, nous vous rappellerons que nous devons vérifier si nous avons bien affaire avec cette variable si elle contient nil .

    Merci … Heureux de coder

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

    Le chaînage facultatif est un processus permettant d’interroger et d’appeler des propriétés, des méthodes et des indices sur une option pouvant être actuellement nulle. Si l’option contient une valeur, la propriété, la méthode ou l’appel en indice réussit; Si l’option est nulle, la propriété, la méthode ou l’appel en indice renvoie nil. Plusieurs requêtes peuvent être chaînées ensemble et la chaîne entière échoue normalement si un lien de la chaîne est nul.

    Pour mieux comprendre, lisez le lien ci-dessus.

    Bien…

    ? (Facultatif) indique que votre variable peut contenir une valeur nulle pendant que ! (unwrapper) indique que votre variable doit avoir une mémoire (ou une valeur) lorsqu’elle est utilisée (a essayé d’en obtenir une valeur) à l’exécution.

    La principale différence est que le chaînage facultatif échoue normalement lorsque l’option est nulle, tandis que le désenveloppement forcé déclenche une erreur d’exécution lorsque l’option est nulle.

    Pour refléter le fait que le chaînage facultatif peut être appelé sur une valeur nulle, le résultat d’un appel de chaînage facultatif est toujours une valeur facultative, même si la propriété, la méthode ou l’indice que vous interrogez renvoie une valeur non optionnelle. Vous pouvez utiliser cette valeur de retour facultative pour vérifier si l’appel de chaînage facultatif a réussi (l’option facultative renvoyée contient une valeur) ou n’a pas réussi en raison d’une valeur nulle dans la chaîne (la valeur facultative renvoyée est nil).

    Plus précisément, le résultat d’un appel de chaînage facultatif est du même type que la valeur de retour attendue, mais est inclus dans une option. Une propriété qui retourne normalement un Int retournera un Int? lorsque vous y accédez par chaînage facultatif.

     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 sortinged 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 comstack time error 

    Voici un didacticiel de base détaillé par Apple Developer Committee: Chaînage facultatif

    Voici une déclaration facultative équivalente dans Swift:

     var middleName: Ssortingng? 

    Cette déclaration crée une variable nommée middleName de type Ssortingng. Le point d’interrogation (?) Après le type de variable Ssortingng indique que la variable middleName peut contenir une valeur pouvant être une chaîne ou une valeur nulle. Quiconque regarde ce code sait immédiatement que middleName peut être nul. C’est auto-documenté!

    Si vous ne spécifiez pas de valeur initiale pour une constante ou une variable facultative (comme indiqué ci-dessus), la valeur est automatiquement définie sur zéro pour vous. Si vous préférez, vous pouvez définir explicitement la valeur initiale à nil:

     var middleName: Ssortingng? = nil 

    pour plus de détails pour facultatif lire ci-dessous lien

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