TL; DR answer

Avec de très rares exceptions près , cette règle d'or:

éviter l'utilisation de !

Déclarer la variable en option ( ? ), pas implicitement déballé options (IUO) ( ! )

en d'autres termes, plutôt utiliser:

var nameOfDaughter: String?

au lieu de:

var nameOfDaughter: String!

Déballer variable en option à l'aide de if let ou guard let

soit variable unwrap comme ceci:

if let nameOfDaughter = nameOfDaughter {
    print("My daughters name is: \(nameOfDaughter)")
}

ou comme ceci:

guard let nameOfDaughter = nameOfDaughter else { return }
print("My daughters name is: \(nameOfDaughter)")

cette réponse se voulait concise, pour une compréhension complète, lire la réponse acceptée

Cette question revient TOUT LE TEMPS . C'est l'une des premières choses avec lesquelles les nouveaux développeurs Swift se battent.

Contexte:

Swift utilise le concept d ' "optionnel" pour traiter des valeurs qui pourraient contenir une valeur, ou non. Dans D'autres langues comme C, vous pouvez stocker une valeur de 0 dans une variable pour indiquer qu'elle ne contient aucune valeur. Cependant, si 0 est une valeur valide? Alors vous pourriez utiliser -1. Si -1 est une valeur valide? Et ainsi de suite.

les options Swift vous permettent de configurer une variable de n'importe quel type pour contenir soit une valeur valide, soit aucune valeur.

vous mettez un point d'interrogation après le type lorsque vous déclarez une variable moyenne (type x, ou aucune valeur).

Une option est en fait un conteneur qui contient une variable d'un type donné, ou rien.

une option doit être "déballée" afin de récupérer la valeur à l'intérieur.

Le "!"l'opérateur est une force de "déballer" de l'opérateur. Il dit: "faites-moi confiance. Je sais ce que je fais. Je vous garantis que lorsque ce code sera activé, la variable ne contiendra pas zéro."Si vous vous trompez, vous vous écrasez.

à Moins que vous vraiment faire savez ce que vous faites, évitez de le "!"force l'opérateur de déballage. C'est probablement la plus grande source d'accidents pour les programmeurs Swift débutants.

comment traiter avec les optionnels:

il y a beaucoup d'autres façons de traiter les options qui sont plus sécuritaires. Voici quelques (liste non exhaustive)

vous pouvez utiliser" optional binding "ou" if let "pour dire" si cette option contient une valeur, enregistrez cette valeur dans une nouvelle variable non-optionnelle. Si l'option Ne contient pas de valeur, sautez le corps de cette instruction if".

voici un exemple de reliure optionnelle avec notre foo optionnelle:

if let newFoo = foo //If let is called optional binding. {
  print("foo is not nil")
} else {
  print("foo is nil")
}

notez que la variable que vous définissez lorsque vous utilisez la présentation facultative n'existe que dans le corps de l'instruction if.

alternativement, vous pouvez utiliser une instruction guard, qui vous permet de quitter votre fonction si la variable est nulle:

func aFunc(foo: Int?) {
  guard let newFoo = input else { return }
  //For the rest of the function newFoo is a non-optional var
}

les déclarations de garde ont été ajoutées dans Swift 2. Guard vous permet de préserver le "chemin d'or" à travers votre code, et d'éviter les niveaux sans cesse croissants d'ifs imbriqués qui en résultent parfois de l'aide "si laisser" de fixation en option.

il y a aussi une construction appelée"néant opérateur de coalescence". Il prend la forme "optional_var ?? replacement_val". Il retourne une variable non-optionnelle avec le même type que les données contenues dans l'optionnel. Si l'option contient zéro, il renvoie la valeur de l'expression après le "??" symbole.

donc vous pouvez utiliser le code comme ceci:

let newFoo = foo ?? "nil" // "??" is the nil coalescing operator
print("foo = \(newFoo)")

vous pouvez également utiliser try / catch ou la manipulation d'erreur de garde, mais généralement l'une des autres techniques ci-dessus est plus propre.

EDIT:

un autre gotcha, un peu plus subtil avec des optionnels, est "implicitement non enveloppé optionnels. Lorsque nous déclarons foo, nous pourrions dire:

var foo: String!

dans ce cas foo est toujours optionnel, mais vous n'avez pas à le déballer pour le référencer. Cela signifie que chaque fois que vous essayez de faire référence à toto, vous planter si c'est nul.

Alors ce code:

var foo: String!


let upperFoo = foo.capitalizedString

s'écrasera sur une référence à la propriété capitalizedString de foo, même si nous ne déballons pas foo. l'empreinte semble fine, mais elle ne l'est pas.

ainsi, vous voulez être vraiment prudent avec les options implicitement déballées. (et peut-être même les éviter complètement jusqu'à ce que vous avez une solide compréhension des optionnels.)

ligne de fond: lorsque vous apprenez Swift pour la première fois, prétendre le "!"le caractère n'est pas partie de la langue. Il est probable que vous aurez des problèmes.

tout d'Abord, vous devez savoir ce qu'est une valeur Facultative. Vous pouvez faire un pas vers le Launage de programmation Swift

pour plus de détails.

Deuxièmement, vous devez savoir que la valeur optionnelle a deux statuts. L'une est la valeur totale, et l'autre est la valeur nulle. Donc, avant d'implémenter une valeur optionnelle, vous devriez vérifier dans quel état elle est.

Vous pouvez utiliser if let ... ou guard let ... else et ainsi de suite.

Une autre façon, si vous ne voulez pas vérifier son état avant votre implémentation, vous pouvez aussi utiliser var buildingName = buildingName ?? "buildingName" à la place.

puisque les réponses ci-dessus explique clairement comment jouer en toute sécurité avec des options. Je vais essayer d'expliquer quelles Options sont vraiment rapide.

une autre façon de déclarer une variable optionnelle est

var i : Optional<Int>

Et en Option type est rien mais une énumération avec les deux cas, j'.e

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

donc attribuer un zéro à notre variable "i". Nous pouvons le faire var i = Optional<Int>.none ou pour affecter une valeur, nous passeront une certaine valeur var i = Optional<Int>.some(28)

selon swift, "Zéro" est l'absence de valeur. Et pour créer une instance initialisée avec nil nous devons nous conformer à un protocole appelé ExpressibleByNilLiteral et grand si vous l'avez deviné, seulement Optionals se conformer à ExpressibleByNilLiteral et se conformer à d'autres types est découragé.

ExpressibleByNilLiteral a une seule méthode appelée init(nilLiteral:) qui initialise un instacé avec zéro. Vous souvent coutume d'appeler cette méthode et selon la documentation swift, il est déconseillé d'appeler cet initialiseur directement car le compilateur l'appelle chaque fois que vous initialisez un type optionnel avec nil littéral.

même moi doit envelopper (sans jeu de mots) ma tête autour des optionnels: D Heureux Swfting Tous .

j'ai eu cette erreur Une fois quand j'ai essayé de définir mes valeurs de sortie de la méthode prepare for segue comme suit:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // This line pops up the error
            destination.nameLabel.text = item.name
        }
    }
}

puis j'ai découvert que je ne peux pas régler les valeurs des sorties du contrôleur de destination parce que le contrôleur n'a pas encore été chargé ou initialisé.

donc je l'ai résolu de cette façon:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // Created this method in the destination Controller to update its outlets after it's being initialized and loaded
            destination.updateView(itemData:  item)
        }
    }
}

Contrôleur De Destination:

// This variable to hold the data received to update the Label text after the VIEW DID LOAD
var name = ""

// Outlets
@IBOutlet weak var nameLabel: UILabel!

override func viewDidLoad() {
    super.viewDidLoad()

    // Do any additional setup after loading the view.
    nameLabel.text = name
}

func updateView(itemDate: ObjectModel) {
    name = itemDate.name
}

j'espère que cette réponse aide n'importe qui là-bas avec le même problème que j'ai trouvé la réponse marquée est une grande ressource pour la compréhension des optionnels et la façon dont ils fonctionnent, mais n'a pas abordé la question elle-même directement.

fondamentalement, vous avez essayé d'utiliser une valeur nulle dans les endroits où Swift n'autorise que les valeurs non nulles, en" dupant " le compilateur pour qu'il pense qu'il y a une valeur nulle, permettant ainsi à votre application de compiler.

Il y a plusieurs scénarios qui conduisent à ce genre d'erreur fatale:

1. un wraps forcé:

   let user = someVariable!
   

   si someVariable est nul, alors vous aurez un accident. En faisant une force unwrap vous avez déplacé le nil vérifier la responsabilité du compilateur pour vous, essentiellement en faisant un déroulage forcé que vous garantissez au compilateur que vous n'aurez jamais des valeurs nul là-bas. Et devine ce qui arrivera si ça arrive?

   Solution

   ? L'utilisation de fixation en option (aka si-let), ne la variable de traitement, là:

   if user = someVariable {
       // do your stuff
   }
   

2. moulages forcés:

   let myRectangle = someShape as! Rectangle
   

   ici par moulage de force vous dites le compilateur à no plus d'inquiétude, car vous aurez toujours une instance Rectangle là. Et tant que titulaire, vous n'avez pas à vous inquiéter. Les problèmes commencent lorsque vous ou vos collègues du projet commencez à faire circuler des valeurs non rectangulaires.

   Solution

   ? L'utilisation de fixation en option (aka si-let), ne la variable de traitement, là:

   if let myRectangle = someShape as? Rectangle {
       // yay, I have a rectangle
   }
   

3. implicitement optionnelles non emballées. Supposons que vous avez la définition de classe suivante:

   class User {
       var name: String!
   
       init() {
           name = "none yet"
       }
   
       func nicerName() {
           return "Mr/Ms " + name
       }
   }
   

   maintenant, si personne ne rate la propriété name en la mettant à nil , alors cela fonctionne comme prévu, cependant si User est initialisé à partir d'un JSON qui manque de la touche name , alors vous obtenez l'erreur fatale en essayant d'utiliser la propriété.

   Solution

   ? Ne les utilisez pas :) sauf si vous êtes sûr à 102% que le bien aura toujours une valeur non nulle au moment où il doit être utilisé. Cependant, dans la plupart des cas la convertir en optionnel ou non-optionnel fonctionnera. En le rendant non-optionnel, le compilateur vous aidera aussi en indiquant les chemins de code que vous avez manqués en donnant une valeur à cette propriété

4. sans lien les points de vente. C'est un cas particulier du scénario 3. En gros, tu as une classe chargée de XIB que tu veux utiliser.

   class SignInViewController: UIViewController {
   
       @IBOutlet var emailTextField: UITextField!
   }
   

   maintenant si vous avez manqué la connexion de la prise à partir de l'éditeur XIB, puis l'application sera crash dès que vous voulez utiliser la prise. La Solution? Assurez-vous que toutes les prises sont reliés. Ou utilisez l'opérateur ? sur eux: emailTextField?.text = "my@email.com" . Ou déclarer la sortie optionnel, mais dans ce cas, le compilateur va vous forcer à déballer tout le code.

5. valeurs provenant de L'Objectif-C, et qui n'ont pas d'annotations de nullité. Supposons que nous ayons la classe D'objectif C suivante:

   @interface User: NSObject
   @property NSString *name;
   @end
   

   maintenant si aucune annotation de nullité n'est spécifiée (soit explicitement ou via NS_ASSUME_NONNULL_BEGIN / NS_ASSUME_NONNULL_END ), alors la propriété name sera importée dans Swift comme String! (une option IUO - implicitement déballée). Dès qu'un code swift souhaitez utiliser la valeur, il va se planter, en nul cas.

   Solution

   ? Ajoutez des annotations de nullité à votre code objectif-C. Attention cependant, le compilateur objectif-C est un peu permissif quand il s'agit de nullabilité, vous pourriez vous retrouver avec des valeurs nulles, même si vous les avez explicitement marquées comme nonnull .

erreur fatale: de façon inattendue trouvé nulle, tandis que d'ôter une valeur Facultative

il est dit que vous utilisez la variable dont la valeur n'est pas initialisée ou fixée à zéro.

e. g

var tempVar: String?
print(tempVar!)

tempVar n'est pas initialisé donc l'application se bloque dans ce cas donc vous devez utiliser

print(tempVar ?? "") 

consultez Facultatif Chaîne pour plus de détails information