Passer options dans Swift: comme? Type, ou en tant que! Type de?

Le suivant dans Swift:

var optionalString: String?
let dict = NSDictionary()

Quelle est la différence pratique entre les deux énoncés suivants:

optionalString = dict.objectForKey("SomeKey") as? String

vs

optionalString = dict.objectForKey("SomeKey") as! String?
InformationsquelleAutor sdduursma | 2014-09-07
  1. 136

    La pratique, la différence est: est-ce

    var optionalString = dict["SomeKey"] as? String

    optionalString sera une variable de type String?. Si le type sous-jacent est autre chose qu'un String ce sans danger suffit d'attribuer nil à l'option.

    var optionalString = dict["SomeKey"] as! String?

    Cela dit, je savoir, cette chose est un String?. Ce sera également le résultat dans optionalString être de type String?, mais il va planter si le type sous-jacent, c'est autre chose.

    Le premier style est ensuite utilisé avec if let en toute sécurité déballer l'option:

    if let string = dict["SomeKey"] as? String {
    //If I get here, I know that "SomeKey" is a valid key in the dictionary, I correctly
    //identified the type as String, and the value is now unwrapped and ready to use.  In
    //this case "string" has the type "String".
    print(string)
}
    • N'est pas la première méthode toujours mieux alors? Les deux de retour d'une option de type Chaîne de caractères? Il me semble que si la deuxième méthode fait la même chose que le premier, mais peut se bloquer si le triste échec. Alors pourquoi l'utiliser à tous?
    • Oui @Sikander, le premier est toujours le mieux. Je n'aurais jamais utiliser la seconde.
    InformationsquelleAutor vacawama
  2. 12

    as? Types - signifie que le bas du procédé de coulée est facultatif. Le processus peut être réussie ou non(système retourne nil si bas de la coulée échoue).De toute façon ne va pas planter si bas de la coulée échoue.

    as! Type? - Ici le processus de baisse de la coulée doit être réussie (! indique que) . La fin de point d'interrogation indique si le résultat final peut être nul ou pas.

    Plus d'infos concernant les "!" et "?"

    Prenons 2 cas

    1. Considérer:

      let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell

      Ici, nous ne savons pas si le résultat de la baisse de la coulée de la cellule avec l'identifiant de la "Cellule" de UITableViewCell est un succès ou pas. En cas d'échec, puis il retourne nil( afin d'éviter un crash ici). Ici, nous pouvons faire en tant que donnée ci-dessous. 

      if let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell {
    //If we reached here it means the down casting was successful
}
else {
    //unsuccessful down casting
}

      Laissez-nous donc en souviens comme si c' - Si ? cela signifie que nous ne sommes pas sûr de savoir si la valeur est nulle ou non (point d'interrogation vient quand nous ne savons pas les choses).

    2. Contraste que:

      let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! UITableViewCell.

      Ici nous dire au compilateur que le bas de la coulée doit être réussie. Si elle échoue, le système se bloque. Nous donnons donc ! lorsque nous sommes sûrs que la valeur est non nulle.

    InformationsquelleAutor jishnu bala
  3. 11

    De clarifier ce que vacawama dit, voici un exemple...

    Swift 3.0:

    import UIKit
let str_value:    Any   = String("abc")!
let strOpt_value: Any?  = String("abc")!
let strOpt_nil:   Any?  = (nil as String?)
let int_value:    Any   = Int(1)
let intOpt_value: Any?  = Int(1)
let intOpt_nil:   Any?  = (nil as Int?)
//as String
//str_value     as String //Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//strOpt_value  as String //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//strOpt_nil    as String //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//int_value     as String //Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//intOpt_value  as String //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//intOpt_nil    as String //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?

//as? String
  str_value     as? String //== "abc"
  strOpt_value  as? String //== "abc"
  strOpt_nil    as? String //== nil
  int_value     as? String //== nil
  intOpt_value  as? String //== nil
  intOpt_nil    as? String //== nil

//as! String
  str_value     as! String //== "abc"
  strOpt_value  as! String //== "abc"
//strOpt_nil    as! String //Run-Time Error: unexpectedly found nil while unwrapping an Optional value.
//int_value     as! String //Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
//intOpt_value  as! String //Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
//intOpt_nil    as! String //Run-Time Error: unexpectedly found nil while unwrapping an Optional value.

//as String?
//str_value     as String? //Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//strOpt_value  as String? //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//strOpt_nil    as String? //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//int_value     as String? //Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//intOpt_value  as String? //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//intOpt_nil    as String? //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?

//as? String?
//str_value     as? String? //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  strOpt_value  as? String? //== "abc"
  strOpt_nil    as? String? //== nil
//int_value     as? String? //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  intOpt_value  as? String? //== nil
  intOpt_nil    as? String? //== nil

//as! String?
//str_value     as! String? //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  strOpt_value  as! String? //== "abc"
  strOpt_nil    as! String? //== nil
//int_value     as! String? //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
//intOpt_value  as! String? //Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
  intOpt_nil    as! String? //== nil

//let _ = ... as String
//if let _ = str_value    as String { true } //Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_value as String { true } //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_nil   as String { true } //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = int_value    as String { true } //Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_value as String { true } //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_nil   as String { true } //Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?

//let _ = ... as? String
if let _ = str_value    as? String { true } //true
if let _ = strOpt_value as? String { true } //true
if let _ = strOpt_nil   as? String { true } //false
if let _ = int_value    as? String { true } //false
if let _ = intOpt_value as? String { true } //false
if let _ = intOpt_nil   as? String { true } //false

//let _ = ... as! String
//if let _ = str_value    as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = strOpt_value as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = strOpt_nil   as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = int_value    as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = intOpt_value as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = intOpt_nil   as! String { true } //Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'

//let _ = ... as String?
//if let _ = str_value    as String? { true } //Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//if let _ = strOpt_value as String? { true } //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_nil   as String? { true } //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = int_value    as String? { true } //Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//if let _ = intOpt_value as String? { true } //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_nil   as String? { true } //Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?

//let _ = ... as? String?
//if let _ = str_value    as? String? { true } //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = strOpt_value as? String? { true } //true
  if let _ = strOpt_nil   as? String? { true } //true
//if let _ = int_value    as? String? { true } //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = intOpt_value as? String? { true } //false
  if let _ = intOpt_nil   as? String? { true } //true

//let _ = ... as! String?
//if let _ = str_value    as! String? { true } //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = strOpt_value as! String? { true } //true
  if let _ = strOpt_nil   as! String? { true } //false
//if let _ = int_value    as! String? { true } //Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
//if let _ = intOpt_value as! String? { true } //Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
  if let _ = intOpt_nil   as! String? { true } // false

    Swift 2.0:

    import UIKit
let str:    AnyObject   = String("abc")
let strOpt: AnyObject?  = String("abc")
let strNil: AnyObject?  = (nil as String?)
let int:    AnyObject   = Int(1)
let intOpt: AnyObject?  = Int(1)
let intNil: AnyObject?  = (nil as Int?)
str    as? String //== "abc"
strOpt as? String //== "abc"
strNil as? String //== nil
int    as? String //== nil
intOpt as? String //== nil
intNil as? String //== nil

str    as! String? //Compile-Time Error: Cannot downcast from 'AnyObject' to a more optional type 'String?'
strOpt as! String? //== "abc"
strNil as! String? //== nil
int    as! String? //Compile-Time Error: Cannot downcast from 'AnyObject' to a more optional type 'String?'
intOpt as! String? //Run-Time Error: Could not cast value of type '__NSCFNumber' to 'NSString'
intNil as! String? // == nil
    • +1 pour ton exemple, mais pouvez-vous m'expliquer avec l'exemple même de l'utiliser comme! au lieu de comme? alors que de passer comme cellule = tableView.dequeueReusableCellWithIdentifier("Cellule") comme! UITableViewCell..je suppose que? a été suffisamment pourquoi était-il besoin de tant que!
    • laissez-cellule = tableView.dequeueReusableCellWithIdentifier("Cellule") comme? UITableViewCell. - ici nous ne savons pas si le résultat de la baisse de la coulée de la cellule avec l'identifiant de la "Cellule" de UITableViewCell est nill ou pas. Si nill ensuite, il retourne nill( afin d'éviter un crash ici).
    • intéressant, intNil as! String? // ==nil ne pas causer un accident!!!???, comme Option<Int>.Aucun est différent de l'Option<String>.Aucun
    • pourquoi avez-vous abattu as? à String? Pourquoi ne pas vous abattu à String? ? Pourquoi n'avez-vous pas abattu as! à String?
    • Tenter de faire cette aire de jeu en Swift 3, mais vous devez utiliser les Any au lieu de AnyObject
    InformationsquelleAutor Senseful
  4. 8

    Ils sont deux formes différentes de de Passer en Swift.

    (as?), qui est connu pour être la Conditionnelle, renvoie une valeur optionnelle de type que vous essayez d'baissés pour.

    Vous pouvez l'utiliser lorsque vous n'êtes pas sûr si les humbles va réussir.
    Cette forme de l'opérateur retourne toujours une valeur facultative, et
    la valeur sera nulle si les humbles n'était pas possible. Cela permet
    vous recherchez un succès abattu.

    (as!), qui est connu pour être la Forcé Forme, les tentatives de la baissés et la force déballe le résultat comme une simple action composé.

    Vous devriez l'utiliser SEULEMENT lorsque vous êtes sûr que les humbles seront
    toujours réussir. Cette forme de l'opérateur sera le déclencheur d'une d'exécution
    erreur     si vous essayez de abattu d'un mauvais type de classe.

    Pour plus de détails, veuillez consulter La Conversion De Type section de la documentation d'Apple.

    InformationsquelleAutor Scott Zhu
  5. 7
    • as utilisé pour upcasting et le type coulée de ponté type
    • as? utilisé pour la sécurité de la coulée, de retour néant en cas d'échec de la
    • as! utilisé pour forcer le casting, crash en cas d'échec de

    Remarque:

    • as! ne pouvez pas jeter raw type facultatif

    Exemples:

    let rawString: AnyObject = "I love swift"
let optionalString: AnyObject? = "we love swift"
let nilString: AnyObject? = (nil as String?)
let rawInt: AnyObject = Int(3)
let optionalInt: AnyObject? = Int(3)
let nilInt: AnyObject? = (nil as Int?)

    Exemple

    var age: Int? = nil
var height: Int? = 180

    Par l'ajout d'un ? immédiatement après le type de données que vous dire au compilateur que la variable peut contenir un nombre ou pas. Neat! Notez qu'il n'est pas vraiment à définir en Option constantes – vous pouvez définir leur valeur qu'une seule fois et, par conséquent, vous seriez en mesure de dire si leur valeur est nulle ou pas.

    Quand on doit utiliser "?" et quand "!"

    disons que nous avons UIKit base simple application.
    nous avons un peu de code dans notre point de vue, contrôleur et veut présenter un nouveau point de vue contrôleur sur le dessus de cela.
    et nous avons besoin de décider de pousser le nouveau point de vue sur l'écran au moyen de la manette de navigation.

    Comme nous le savons tous ViewController exemple, a une propriété manette de navigation.
    Si vous êtes à la construction d'une manette de navigation application basée sur cette propriété de votre application maître-vue-contrôleur est réglé automatiquement et vous pouvez l'utiliser pour pousser ou de pop affichage des contrôleurs. Si vous utilisez un seul modèle de projet d'application – il n'y aura pas une manette de navigation créé automatiquement pour vous, de sorte que votre application par défaut de-vue-contrôleur n'aura pas tout ce qui est stocké dans le navigationController propriété.

    Je suis sûr que vous avez déjà deviné que c'est exactement le cas pour une Option de type de données. Si vous cochez UIViewController, vous verrez que la propriété est définie comme:

    var navigationController: UINavigationController? { get }

    Donc, revenons à notre cas d'utilisation. Si vous savez pour un fait que votre vue-contrôleur aura toujours une manette de navigation, vous pouvez aller de l'avant et de la force de déballer:

    controller.navigationController!.pushViewController(myViewController, animated: true)

    Lorsque vous mettez un ! derrière le nom de la propriété vous dire au compilateur je ne se soucie pas que cette propriété est facultative, je sais que quand ce code s'exécute, il y aura toujours une valeur magasin afin de traiter cette Option comme un normal type de données. Bien n'est-ce pas agréable? Qu'arriverait-il si il n'y a pas une manette de navigation à votre vue-contrôleur? Si vous avez une suggestion qu'il sera toujours une valeur stockée dans navigationController était le problème? Votre application va se planter. Simple et moche que ça.

    Ainsi, l'utilisation du ! seulement si vous êtes 101% sûr que ce est sûr.

    Diriez-vous si vous n'êtes pas sûr qu'il y aura toujours une manette de navigation? Vous pouvez ensuite utiliser ? au lieu d'un !:

    controller.navigationController?.pushViewController(myViewController, animated: true)

    Ce que l' ? derrière le nom de la propriété indique au compilateur est je ne sais pas si cette propriété contient zéro ou une valeur, donc: si elle a une valeur de l'utiliser, et oterwise il suffit de considérer l'ensemble de l'expression du néant. Effectivement l' ? vous permet d'utiliser cette propriété dans le cas où il y a une manette de navigation. Aucun, si des contrôles de toute nature ou de coulées de toute sorte. Cette syntaxe est parfaite si vous n'avez pas de soins si vous avez une manette de navigation ou pas, et qui veulent faire quelque chose seulement si il existe.

    Grand merci à Fantageek

    InformationsquelleAutor swiftBoy
  6. 3

    Peut-être cet exemple de code pour aider quelqu'un en connaît le principe:

    var dict = [Int:Any]()
dict[1] = 15
let x = dict[1] as? String
print(x) //nil because dict[1] is an Int

dict[2] = "Yo"
let z = dict[2] as! String?
print(z) //optional("Yo")
let zz = dict[1] as! String //crashes because a forced downcast fails

let m = dict[3] as! String?
print(m) // nil. the forced downcast succeeds, but dict[3] has no value
    • Aussi, laissez-z2 = dict[2]! Chaîne // "Yo" (non facultatif)
    InformationsquelleAutor smileBot
  7. 0

    Le premier est un "conditionnel cast" (voir sous "type de casting opérateurs" dans la documentation que j'ai mis en lien). Si le sort réussit, la valeur de l'expression est enveloppé dans une option et est retourné, sinon, la valeur retournée est nul.

    La seconde signifie que optionalString pourrait être un objet de type string ou il pourrait être nul.

    Plus d'informations trouvées dans cette question.

    InformationsquelleAutor Michael Dautermann
  8. 0

    Il peut être plus facile de se rappeler le modèle de ces opérateurs rapide comme: ! implique "cela pourrait piège", alors que ? indique "ce pourrait être nul."

    se référer à:
    https://developer.apple.com/swift/blog/?id=23

    InformationsquelleAutor Zgpeace
  9. -1

    Je suis novice de Swift et de l'écriture de cet exemple pour essayer d'expliquer ce que je comprends sur 'options'. Si je me trompe merci de me corriger.

    Grâce.

    class Optional {
var lName:AnyObject! = "1"
var lastName:String!
}
let obj = Optional()
print(obj.lName)
print(obj.lName!)
obj.lastName = obj.lName as? String
print(obj.lastName)

    (1) : obj.lastName = obj.lName as! String

    vs

    (2) : obj.lastName = obj.lName as? String

    Réponse : (1) Ici, le programmeur est damm assurer que “obj.lName” contient la chaîne de type objet. Donc, juste donner de la valeur à “obj.lastName”.

    Maintenant, si le programmeur est correct signifie "obj.lName" est de type string (chaîne de l'objet, alors pas de problème. "obj.lastName" sera réglé à la même valeur.

    Mais si le programmeur est de mauvais moyens "obj.lName" est pas de type chaîne de caractères de l'objet c'est à dire qu'il contient un autre type d'objet comme "NSNumber" etc. Puis CRASH (Erreur d'Exécution).

    (2) - Programmeur n'est pas sûr que “obj.lName” contient la chaîne de type objet ou tout autre type d'objet. Afin de définir cette valeur à “obj.lastName” si elle est de type chaîne.

    Maintenant, si le programmeur est correct signifie “obj.lName” est de type string (chaîne de l'objet, alors pas de problème. “obj.lastName” sera réglé à la même valeur.

    Mais si le programmeur est de mauvais moyens obj.lName est pas de type chaîne de caractères de l'objet c'est à dire qu'il contient un autre type d'objet comme "NSNumber" etc. Puis “obj.lastName” sera mis à la valeur nil. Donc, Pas De Plantage (Heureux:)

    InformationsquelleAutor iPhoneBuddy