Que signifie un point d'exclamation dans le langage Swift ?

Question

Le guide du langage de programmation Swift a l'exemple suivant :

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)

Puis, lorsqu'ils attribuent l'appartement à la personne, ils utilisent un point d'exclamation pour "déballer l'instance" :

john!.apartment = number73

Que signifie "déballer l'instance" ? Pourquoi est-ce nécessaire ? Quelle est la différence avec les actions suivantes :

john.apartment = number73

Je suis très novice dans le langage Swift. J'essaie juste de me familiariser avec les bases.

UPDATE :
La grande pièce du puzzle qui me manquait (et qui n'est pas directement indiquée dans les réponses - du moins pas au moment où j'écris ces lignes) est que lorsque vous faites ce qui suit.. :

var john: Person?

cela ne veut PAS dire que " john est de type Person et il pourrait être nul", comme je le pensais initialement. Je comprenais simplement mal que Person y Person? sont des types complètement distincts. Une fois que j'ai compris ça, toutes les autres choses ? , ! la folie, et les excellentes réponses ci-dessous, ont eu beaucoup plus de sens.

Answer 1

Que signifie "déballer l'instance" ? Pourquoi est-ce nécessaire ?

D'après ce que je sais (c'est tout nouveau pour moi aussi)...

Le terme "enveloppé" implique que nous devrions considérez une variable facultative comme un cadeau, emballé dans un papier brillant, qui pourrait (malheureusement !) être vide. .

Lorsqu'elle est "enveloppée", la valeur d'une variable facultative est un enum avec deux valeurs possibles (un peu comme un booléen). Cet enum décrit si la variable contient une valeur ( Some(T) ), ou non ( None ).

S'il y a une valeur, on peut l'obtenir en "déballant" la variable (en obtenant l'élément T de Some(T) ).

Comment john!.apartment = number73 différent de john.apartment = number73 ? (Paraphrasé)

Si vous écrivez le nom d'une variable facultative (par exemple texte john sans le ! ), cela fait référence à l'enum "enveloppé" (Some/None), et non à la valeur elle-même (T). Ainsi, john n'est pas une instance de Person et il n'y a pas de apartment membre :

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

L'actuel Person peut être déballée de différentes manières :

• "déballage forcé" : john! (donne le Person si elle existe, erreur d'exécution si elle est nulle)
• "liaison facultative" : if let p = john { println(p) } (exécute le println si la valeur existe)
• "chaînage optionnel" : john?.learnAboutSwift() (exécute cette méthode inventée si la valeur existe)

Je suppose que vous choisissez l'une de ces façons de déballer, en fonction de ce qui devrait se passer dans le cas nil, et de la probabilité que cela soit le cas. Cette conception du langage force le cas nil à être traité explicitement, ce qui, je suppose, améliore la sécurité par rapport à Obj-C (où il est facile d'oublier de traiter le cas nil).

Mise à jour :

Le point d'exclamation est également utilisé dans la syntaxe de déclaration des "optionnels implicitement non enveloppés".

Dans les exemples présentés jusqu'à présent, le john a été déclarée comme var john:Person? et c'est une option. Si vous voulez connaître la valeur réelle de cette variable, vous devez la déballer en utilisant l'une des trois méthodes ci-dessus.

S'il était déclaré comme var john:Person! Au lieu de cela, la variable serait un Implicitly Unwrapped Optional (voir la section portant ce titre dans le livre d'Apple). Il n'est pas nécessaire de déballer ce type de variable lors de l'accès à la valeur, et la variable john peuvent être utilisés sans syntaxe supplémentaire. Mais le livre d'Apple dit :

Les optionnels implicitement déballés ne doivent pas être utilisés lorsqu'il est possible qu'une variable devienne nulle ultérieurement. Utilisez toujours un type d'option normal si vous devez vérifier la présence d'une valeur nulle pendant la durée de vie d'une variable.

Mise à jour 2 :

L'article " Fonctionnalités intéressantes de Swift " par Mike Ash donne une certaine motivation pour les types optionnels. Je pense qu'il s'agit d'un excellent article, rédigé de manière claire.

Mise à jour 3 :

Un autre article utile sur le facultatif implicitement déballé utiliser pour le point d'exclamation : " Swift et le dernier kilomètre "par Chris Adamson. L'article explique qu'il s'agit d'une mesure pragmatique utilisée par Apple pour déclarer les types utilisés par ses frameworks Objective-C qui peuvent contenir nil. Déclarer un type comme optionnel (en utilisant ? ) ou implicitement déballée (en utilisant ! ) est "un compromis entre la sécurité et la commodité". Dans les exemples donnés dans l'article, Apple a choisi de déclarer les types comme implicitement unwrapped, ce qui rend le code d'appel plus pratique, mais moins sûr.

Peut-être qu'Apple pourrait passer au peigne fin ses frameworks à l'avenir, en supprimant l'incertitude des paramètres implicitement déballés ("probablement jamais nil") et en les remplaçant par des déclarations optionnelles ("certainement pourrait être nil dans des circonstances particulières [espérons-le, documentées !]") ou standard non-optionnelles ("n'est jamais nil"), sur la base du comportement exact de leur code Objective-C.

Answer 2

Voici ce que je pense être la différence :

var john: Person?

signifie que john peut être nul

john?.apartment = number73

Le compilateur interprétera cette ligne comme :

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

Alors que

john!.apartment = number73

Le compilateur interprétera cette ligne comme simplement :

john.apartment = number73

Par conséquent, en utilisant ! déroulera l'instruction if, et la rendra plus rapide, mais si john est nil, une erreur d'exécution se produira.

Donc, "envelopper" ne signifie pas qu'il s'agit d'une enveloppe de mémoire, mais qu'il s'agit d'une enveloppe de code. Dans ce cas, il s'agit d'une enveloppe avec une instruction "if", et comme Apple accorde une grande attention aux performances d'exécution, elle veut vous donner un moyen de faire fonctionner votre application avec les meilleures performances possibles.

Mise à jour :

Je reviens à cette réponse après 4 ans, car elle m'a valu les plus grandes réputations sur Stackoverflow :) J'ai un peu mal compris la signification du déballage à l'époque. Maintenant, après 4 ans, je crois que le sens du déballage est d'étendre le code à partir de sa forme compacte originale. Il s'agit également de supprimer le flou autour de cet objet, car nous ne sommes pas sûrs par définition qu'il soit nil ou non. Tout comme le réponse d'Ashley ci-dessus pensez-y comme à un cadeau qui ne pourrait rien contenir. Mais je pense toujours que le déballage est un déballage de code et non un déballage basé sur la mémoire comme l'utilisation d'un enum.

Answer 3

TL;DR

Que signifie un point d'exclamation dans le langage Swift ?

Le point d'exclamation dit effectivement "Je sais que cette option a définitivement une valeur ; veuillez l'utiliser". C'est ce qu'on appelle le déballage forcé de la valeur de l'option :

Exemple

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

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

Answer 4

Si john était une var optionnelle (déclarée ainsi)

var john: Person?

alors il serait possible que john n'ait aucune valeur (en langage ObjC, valeur nulle).

Le point d'exclamation dit essentiellement au compilateur "Je sais que ceci a une valeur, vous n'avez pas besoin de le tester". Si vous ne voulez pas l'utiliser, vous pouvez le tester de manière conditionnelle :

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

L'intérieur de celui-ci ne sera évalué que si john a une valeur.

Answer 5

john est un élément facultatif var et il peut contenir un nil valeur. Pour s'assurer que la valeur n'est pas nulle, utilisez une balise ! à la fin de la var nom.

De la documentation

"Une fois que vous êtes sûr que l'option contient bien une valeur, vous pouvez accéder à sa valeur sous-jacente en ajoutant un point d'exclamation ( !) à la fin du nom de l'option. Le point d'exclamation dit effectivement : "Je sais que cette option a définitivement une valeur ; veuillez l'utiliser".

Une autre façon de vérifier une valeur non nulle est (unwrapping optionnel)

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