De vérifier la valeur d'une Option de Bool

Quand je veux vérifier si une Option Booléenne est vraie, cela ne fonctionne pas:

var boolean : Bool? = false
if boolean{
}

Il en résulte cette erreur:

Option de type '@IvalueBool? " ne peut pas être utilisé comme un booléen; test pour '!= nil"
au lieu de cela

Je ne veux pas vérifier pour les nuls; je veux vérifier si la valeur renvoyée est true.

Dois-je toujours faire if boolean == true si je travaille avec une Option de Bool?

Depuis Options ne sont pas conformes à BooleanType plus, ne pas le compilateur sache que je tiens à vérifier la valeur du Booléen?

  • Depuis les Booléens sont conformes à la Equatable protocole, alors vous pouvez comparer une option pour un non optionnel. Voir here
InformationsquelleAutor Moon Cat | 2014-08-27
  1. 171

    Avec, en option, des booléens, il est nécessaire de faire le chèque explicite:

    if boolean == true {
    ...
}

    Sinon, vous pouvez déballer l'option:

    if boolean! {
    ...
}

    Mais qui génère une exception d'exécution si le booléen est nil - pour éviter que:

    if boolean != nil && boolean! {
    ...
}

    Avant de bêta 5, il a été possible, mais il a été modifié comme indiqué dans les notes de version:

    Options plus implicitement true quand ils ont une valeur, et false quand ils ne sont pas, pour éviter toute confusion lors de travail avec, en option, Bool valeurs. Au lieu de cela, faire une vérification explicite contre nul avec l' == ou != les opérateurs afin de savoir si une option contient une valeur.

    Addendum: comme suggéré par @MartinR, plus compact de la variation à la 3ème option est à l'aide de la coalescence de l'opérateur:

    if boolean ?? false {
    //this code runs only if boolean == true
}

    ce qui signifie: si le booléen est pas nulle, l'expression renvoie la valeur booléenne (c'est à dire à l'aide de la déballé valeur booléenne), sinon l'expression est évaluée à false

    • La troisième option est la meilleure solution parce que c'est la meilleure façon d'exprimer l'intention de ce code. À l'aide de if let serait aussi travailler.
    • Je suis d'accord que le 3e est plus facile à lire. Probablement let n'est pas aussi bon, parce qu'il vous indique si l'option a une valeur ou pas - vous devez ajouter un si imbriquées afin de vérifier si la déballé est vrai ou pas
    • Une variante de la troisième option, à l'aide de la "nil coalescence de l'opérateur ??": if boolean ?? false { ... } .
    • Mais si je veux le nier, il commence à sembler ridicule: if !(boolean ?? true) { ... } 🙁
    • Forcé déballer un très mauvaise idée. Il doit toujours être évitée.
    • Rien de mal avec force déballer si il est utilisé correctement. La troisième solution est sûr, et de loin, le moyen le plus simple pour faire des doublures 1 pour les booléens.
    • Pour être complet, une autre option: if case .some(true) = boolean { ... }
    • Quel est le problème avec la première option? Pour moi, il semble que le meilleur moyen.
    • Le premier est juste ok pour l'utiliser de toute façon, pas besoin de penser à d'autres, si cela devient compliqué comme ça....

    InformationsquelleAutor Antonio
  2. 38

    De fixation en option

    Swift 3 & 4

    var booleanValue : Bool? = false
if let booleanValue = booleanValue, booleanValue {
    //Executes when booleanValue is not nil and true
    //A new constant "booleanValue: Bool" is defined and set
    print("bound booleanValue: '\(booleanValue)'")
}

    Swift 2.2

    var booleanValue : Bool? = false
if let booleanValue = booleanValue where booleanValue {
    //Executes when booleanValue is not nil and true
    //A new constant "booleanValue: Bool" is defined and set
    print("bound booleanValue: '\(booleanValue)'")
}

    Le code let booleanValue = booleanValue retourne false si booleanValue est nil et la if bloc n'est pas exécutée. Si booleanValue n'est pas nil, ce code définit une nouvelle variable nommée booleanValue de type Bool (au lieu d'une option, Bool?).

    La Swift 3 & 4 code booleanValue (et Swift 2.2 code where booleanValue) évalue les nouvelles booleanValue: Bool variable. Si c'est vrai, la if bloc s'exécute avec la nouvelle définition des booleanValue: Bool variable dans la portée (permettant l'option de référence de la valeur liée à nouveau dans le if bloc).

    Note: C'est une Swift convention de nom lié à la constante/variable de la même que l'option de la constante/variable comme let booleanValue = booleanValue. Cette technique est appelée variable ombrage. Vous pourriez pause de la convention et d'utiliser quelque chose comme let unwrappedBooleanValue = booleanValue, unwrappedBooleanValue. Je souligne cela pour aider à comprendre ce qui se passe. Je recommande d'utiliser la variable d'ombrage.

     

    D'Autres Approches

    Néant coalescence

    Néant coalescence est clair pour ce cas précis

    var booleanValue : Bool? = false
if booleanValue ?? false {
    //executes when booleanValue is true
    print("optional booleanValue: '\(booleanValue)'")
}

    La vérification de false n'est pas aussi claire

    var booleanValue : Bool? = false
if !(booleanValue ?? false) {
    //executes when booleanValue is false
    print("optional booleanValue: '\(booleanValue)'")
}

    Remarque: if !booleanValue ?? false ne compile pas.

     

    Force déballage en option (à éviter)

    Force d'ôter augmente les chances que quelqu'un va faire un changement dans l'avenir qui compile mais se bloque au moment de l'exécution. Donc, je voudrais éviter de quelque chose comme ceci:

    var booleanValue : Bool? = false
if booleanValue != nil && booleanValue! {
    //executes when booleanValue is true
    print("optional booleanValue: '\(booleanValue)'")
}

     

    Une Approche Générale

    Si ce débordement de pile question demande précisément comment vérifier si un Bool? est true au sein d'une if déclaration, il est utile de définir une approche générale de savoir si la vérification de vrai, faux ou la combinaison de la déballé valeur avec d'autres expressions.

    Comme l'expression devient plus compliqué, je trouve l'option liaison approche plus souple et plus facile à comprendre que les autres approches. Notez que l'option de liaison fonctionne avec n'importe quel type facultatif (Int?, String?, etc.).

    • J'ai de la difficulté à l'aide des expressions Booléennes avec une option pour les boucles while. Le néant, la coalescence de l'opérateur travaille, mais c'est salissant et sujettes à erreur. Est-il possible d'utiliser if let?
    • s'il vous plaît poster un exemple de boucle while vous vous demandez à propos.
    • À l'aide d'un tableau dans une pile, je veux faire apparaître les valeurs jusqu'à ce qu'une condition est remplie, ou si la pile est vide. Par exemple, while array.last < threshold { array.removeLast() }
    • Vous pouvez accomplir cette pile de traitement avec if, let, where en utilisant ceci: while let last = array.last where last < threshold { array.removeLast() } dans Swift 2 ou while let last = array.last, last < threshold { array.removeLast() } dans Swift 3.
    • C'est mieux, merci. Je n'étais pas au courant de while let.
    • Je n'ai pas l'obtenir. Quel est le problème avec cela? var optionalBool :Bool? = false; if (optionalBool == false){ print("is false"); } n'a pas besoin de tout déballer...
    • Depuis les Booléens sont conformes à la Equatable protocole, alors, vous pouvez comparer une option pour un non optionnel. Voir ici
    • Grande question. C'est le code de style. if optionalBool == false { ... fonctionne, mais il est incompatible avec la convention pour l'évaluation d'un non-optionnel qui est comme ce if nonOptionalBool { .... Je préfère l'approche qui correspond à la norme Swift conventions de codage, mais il ya beaucoup d'approches qui fonctionnent dans ce cas.

    InformationsquelleAutor Mobile Dan
  3. -1

    J'ai trouvé une autre solution, la surcharge d'opérateurs Booléens. Par exemple:

    public func < <T: Comparable> (left: T?, right: T) -> Bool {
    if let left = left {
        return left < right
    }
    return false
}

    Cela peut ne pas être totalement dans "l'esprit" de la langue, mais cela permet pour la sécurité déballage des options, et il est utilisable pour des instructions conditionnelles n'importe où, y compris lors de la boucle.

    • Désolé, en regardant en arrière à l'original post, il ne répond pas à cette question spécifique, mais plutôt la question que j'ai posée dans mon commentaire précédent.
    • Je serais très prudent sur l'utilisation de cette surcharge, car il peut y avoir des cas où vous ne voulez pas nul à être traités en tant que "plus grand que", d'une non-valeur nil (il peut être le résultat inverse, dans certains contextes, ou éventuellement alternative de manutention entièrement). L'utilisation normale d'ôter au lieu de cela vous oblige à aborder explicitement la façon dont vous souhaitez gérer nils dans tous les cas, si vous êtes moins susceptible de se heurter à des résultats inattendus.
    InformationsquelleAutor jbaraga