Des doubles points d'exclamation ?

Question

Duplicata possible :
Qu'est-ce que le ! !! (pas pas) en JavaScript ?
Que signifie l'opérateur ! ! (double point d'exclamation) en JavaScript ?

Je déboguais un code et je suis tombé sur ça :

var foo.bar = 0; // this is actually passed from another function, adding it for context

function(foo)
    var someVar = !!foo.bar;
    if(foo.bar){
      // ..stuff happens
    }
    else{
      // .. something else happens
    }
}

Ok, ma question est : quel est l'intérêt de ! !? Tout ce que cela fait est de rendre le 0 === faux. A. Y a-t-il un avantage à utiliser cette méthode par rapport à boolean(foo.bar) ?

B. foo.bar peut être évalué dans un if tel quel car 0 === false déjà, alors pourquoi passer par la conversion ? (someVar n'est pas réutilisé ailleurs)

Je suis juste un peu curieux...

Merci d'avance !

Answer 1

Cela convertit une valeur en un booléen et assure un type booléen .

"foo"      =    "foo"
!"foo"     =    false
!!"foo"    =    true

Si foo.bar est transmise, alors il se peut que ce ne soit pas 0, mais une autre valeur fantaisiste. Voir la table de vérité suivante :

Table de vérité pour javascript

''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t\r\n" ==   0             // true

Source : Doug Crockford

Javascript est également très bizarre lorsqu'il s'agit de valeurs NaN. Et c'est le seul cas auquel je peux penser de but en blanc où ! ! se comporterait différemment de ===.

NaN   ===  NaN     //false
!!NaN === !!NaN    //true

// !!NaN is false

Answer 2

Je pense que la réponse est qu'il n'y a pas vraiment d'intérêt. Nous pouvons spéculer sur la façon dont cela s'est produit :

• peut-être qu'une version antérieure de la fonction utilisait someVar dans de multiples endroits, ou d'une manière qui a réellement bénéficié d'avoir true ou false donc c'était plus logique.
• peut-être que la personne qui a écrit la fonction est tellement habituée à utiliser !! à convertir en true / false qu'il n'a même pas remarqué que ce n'était pas nécessaire ici.
• peut-être que la personne qui a écrit la fonction estime que chaque calcul (dans ce cas, la conversion booléenne) devrait recevoir un nom significatif en assignant une variable à son résultat.
• peut-être, étant donné que la conversion booléenne en JavaScript est étonnamment sujette à des erreurs (en ce sens que, par exemple, la conversion booléenne en JavaScript n'est pas toujours possible). new Boolean(false) est une valeur vraie), la personne qui a écrit la fonction estime que cela devrait toujours être fait explicitement plutôt qu'implicitement - même si l'effet est le même - juste pour attirer l'attention sur ce point d'erreur potentiel.
  • ceci, bien sûr, présuppose que la personne qui a écrit la fonction pense à !! comme une conversion booléenne "explicite". Techniquement, ce n'est pas le cas - elle utilise la même conversion booléenne implicite que celle utilisée par if mais si vous êtes habitué à cet idiome, cela revient à une conversion explicite.

mais à mon avis subjectif, aucune de ces raisons n'est très bonne !

Answer 3

Comme indiqué ci-dessus, il force un objet de type booléen. Vous pouvez le constater par vous-même :

(function typecheck() {
  var a = "a";
  var b = !a;
  var c = !!a;

  alert("var a = " + typeof(a) + "\n" +
        "var b = " + typeof(b) + "\n" +
        "var c = " + typeof(c));
})();

Si vous effectuez simplement des comparaisons, la conversion vous évite simplement une coercition de type par la suite.

Pour votre information, les valeurs suivantes sont forcées à FALSE en JavaScript :

• faux
• 0
• ""
• null
• indéfini