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

Question

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

le guide de 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)

ensuite, lors de l'attribution de l'appartement à la personne, ils utilisent un point d'exclamation pour "déballer l'instance":

john!.apartment = number73

Que signifie "ouvrir l'instance"? Pourquoi est-il nécessaire? En quoi est-ce différent de simplement faire ce qui suit:

john.apartment = number73

je suis très nouveau dans le langage Swift. Juste essayer d'obtenir les bases.

mise à jour:

La grande pièce du puzzle que je manquais (pas directement indiqué dans les réponses - au moins pas au moment de la rédaction de ce document) est que lorsque vous faites ce qui suit:

var john: Person?

cela ne signifie pas que john est de type Person et il pourrait être nul", comme je l'ai à l'origine pensée. J'ai simplement compris que Person et Person? sont des types complètement séparés. Une fois que j'ai compris cela, tous les autres ? , ! folie, et les grandes réponses ci-dessous, fait beaucoup plus de sens.

483

forced-unwrapping optional swift

demandé sur Cœur 2014-06-03 18:52:26

22 réponses

score 494 · Answer 1

Que signifie "ouvrir l'instance"? Pourquoi est-il nécessaire?

autant que je puisse le comprendre (c'est très nouveau pour moi aussi)...

le terme "enveloppé" implique que nous devrions penser à une variable optionnelle comme un cadeau, enveloppé dans du papier brillant, qui pourrait (malheureusement!) être vide .

Quand "enveloppé", la valeur d'une variable Optionnelle 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 le T de Some(T) ).

en quoi john!.apartment = number73 diffère-t-il de john.apartment = number73 ? (Paraphrasé)

Si vous écrivez le nom d'une variable Optionnelle (par exemple texte john , sans le ! ), cela se réfère à l'enum" enveloppé " (certains/Aucun), pas la valeur elle-même (T). Donc john n'est pas un exemple de Person , et il n'a pas de apartment membre:

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

la valeur réelle Person peut être déballée de différentes façons:

"déballage forcé": john! (donne la valeur Person si elle existe, erreur d'exécution si elle est nulle)
"option obligatoire": if let p = john { println(p) } (exécute le println si la valeur existe)
optionnels "chaînage": john?.learnAboutSwift() (exécute cette méthode 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 nul, et à quel point c'est probable. Cette conception linguistique oblige 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 néant cas).

mise à Jour :

le point d'exclamation est également utilisé dans la syntaxe pour déclarer"les options implicitement non emballées".

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

si elle était déclarée comme var john:Person! à la place, la variable serait une optionnelle implicitement déballée (voir la section avec cette rubrique 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 john peut être utilisé sans syntaxe supplémentaire. Mais le livre D'Apple dit:

implicitement, les options non enveloppées ne doivent pas être utilisées lorsqu'il y a une possibilité qu'une variable devienne nulle à un moment ultérieur. Toujours utiliser un type optionnel normal si vous avez besoin de vérifier une valeur nulle pendant la durée de vie d'une variable.

Update 2 :

L'article " Intéressant Swift Fonctionnalités " par Mike Ash donne de la motivation pour l'option types. Je pense qu'il est grand, clair de l'écriture.

Update 3 :

un autre article utile au sujet du implicitement non enveloppé facultatif utiliser pour le point d'exclamation: " Swift et le dernier mille " par Chris Adamson. L'article explique qu'il s'agit d'une mesure pragmatique d'Apple utilisée pour déclarer les types utilisés par leurs cadres objectifs-C qui pourraient contenir zéro. Déclarer un type comme facultatif (en utilisant ? ) ou implicitement non emballé (en utilisant ! ) est "un compromis entre sécurité et commodité". Dans les exemples donnés dans le article, Apple ont choisi de déclarer les types comme implicitement déballé, ce qui rend le code d'appel plus pratique, mais moins sûr.

peut-être Apple pourrait passer au peigne fin leurs cadres à l'avenir, en supprimant l'incertitude des paramètres implicitement déballés ("probablement jamais nul") et en les remplaçant par optionnel ("certainement pourrait être nul en particulier [avec un peu de chance, documenté!] circonstances") ou déclarations standard non facultatives ("n'est jamais nul"), sur la base comportement de leur code objectif-C.

score 119 · Answer 2

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

var john: Person?

, 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 suit:

john.apartment = number73

donc, en utilisant ! va déballer l'instruction if, et de faire courir plus vite, mais si john est nul, alors une erreur d'exécution arriver.

donc envelopper ici ne signifie pas qu'il est enveloppé de mémoire, mais il signifie qu'il est enveloppé de code, dans ce cas, il est enveloppé avec une déclaration if, et parce que Apple font une attention particulière à la performance en runtime, ils veulent vous donner un moyen de faire fonctionner votre application avec la meilleure performance possible.

mise à jour:

revenir à cette réponse après 4 ans, car j'ai obtenu les plus hautes réputations de celui-ci en Stackoverflow :) J'ai un peu mal compris le sens du déballage à ce moment-là. Maintenant, après 4 ans, je crois, le sens de déballer ici est d'étendre le code de sa forme compacte. Cela signifie également supprimer le flou autour de cet objet, car nous ne sommes pas sûrs par définition de lui est nul ou non. Tout comme la 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 déballage de code et pas de mémoire basée déballage comme en utilisant l'enum.