+ !! opérateur dans une instruction if

Question

J'ai relu le code d'une angularjs usine afin de mieux comprendre comment il fonctionne. Le code contient un if déclaration que je ne comprends pas tout.

Dans un plnkr de démonstration, l'auteur écrit ceci:

if ((+!!config.template) + (+!!config.templateUrl) !== 1) {
  throw new Error('Expected modal to have exactly one of either `template` or `templateUrl`');
}

Il est légèrement différent dans le dépôt github:

if (!(!config.template ^ !config.templateUrl)) {
  throw new Error('Expected modal to have exactly one of either `template` or `templateUrl`');
}

De toute évidence, par le message d'erreur c'est de vérifier pour voir si l'un des deux existe. Je ne suis pas sûr de savoir comment il en vient à la conclusion. Je n'ai pas été en mesure de trouver toute l'information sur l' ^ ou +!

Ma question est: Comment cela s'déclaration de travaux? (^ ou +! ou +!! plus précisément)

Answer 1

!! convertit une valeur booléenne (true ou false). + puis convertit la valeur booléenne pour un certain nombre, soit 1 pour true ou 0 pour faux.

> +true
1
> +false
0

Personnellement je trouve ça plus clair d'écrire quelque chose de ce genre, lorsqu'il s'agit de deux booléens:

if (!config.template == !config.templateUrl) {
  throw ...
}

Code de la clarté et de la lisibilité être damné, apparemment.

Answer 2

+!! utilise la conversion implicite de jeter une valeur 0 ou 1 en fonction de sa valeur booléenne

Pour la plupart, c'est de vérifier l'existence. Par exemple, une chaîne vide est fausse (!!"" === false), et donc n'est pas défini, et un certain nombre d'autres. Ceux sont les deux principaux si

"Falsey" conversions

+!!""        ===   0
+!!false     ===   0
+!!0         ===   0
+!!undefined ===   0
+!!null      ===   0
+!!NaN       ===   0

"Truthy" conversions

+!!1         ===   1
+!!true      ===   1
+!!"Foo"     ===   1
+!!3.14      ===   1
+!![]        ===   1
+!!{}        ===   1

si ((+!!config.modèle) + (+!!config.templateUrl) !== 1)

J'espère que c'est fait plus de sens à ce point. L'objet config a deux propriétés que nous examinons. .template et .templateUrl. Le cast implicite à un 0 ou 1 à l'aide de +!! va être ajoutée, puis de les comparer pour s'assurer qu'il n'est pas 1 (ce qui signifie qu'il est soit 0 ou 2) - les propriétés peuvent soit être allumé ou éteint, mais pas différent.

La table de vérité ici est comme suit:

template    templateUrl    (+!!) + (+!!)     !==1
"foo"       "foo"              1 + 1         true
undefined   undefined          0 + 0         true
undefined   ""                 0 + 0         true
""          undefined          0 + 0         true
12          ""                 1 + 0         false
""          12                 0 + 1         false
undefined   "foo"              0 + 1         false
""          "foo"              0 + 1         false
"foo"       ""                 1 + 0         false
"foo"       undefined          1 + 0         false

Un beaucoup plus simple méthode pour tout cela aurait été d'utiliser l'implicite conversion booléenne

if (!config.template === !config.templateUrl)

Answer 3

C'est une horrible lisibilité façon d'écrire la valeur booléenne d'une variable, puis de le convertir à l'aide de unaire de conversion pour donner un 0/1 nombre de résultats.

Considérer:

+!!true; //this converts true to false, then to true again, and true is 1 when converted
+!!0; //converts 0 (falsy) to true, then false, and then the numeric 0

Techniquement parlant !! n'est pas son propre opérateur, c'est juste le PAS (!) de l'opérateur à deux reprises.

Unaire de conversion: ECMA spec doc unaire, plus les tentatives de conversion d'un entier. Number() serait également valable conversion.

Answer 4

Pendant ce temps, ^ est l'opérateur XOR au niveau du bit.

Avec des nombres inférieurs à 2, ^ fonctionnera comme un booléen OU ( || ) si vous considérez 0 = false et 1 = true .

Answer 5

! est pas l'opérateur logique. C'est un opérateur unaire qui convertit son opérande booléen et puis il nie. !! est juste que l'opérateur à deux reprises, la seconde ! annule la négation, de sorte que le résultat final est juste la conversion en une valeur de type boolean.

+ est unaire plus de l'opérateur, qui convertit l'opérande de nombre. Dans le cas d'une valeur booléenne false devient 0, et le vrai devient 1.

Donc, +!!(expression) évalue 1 si l'expression est truthy et 0 si l'expression est falsy.