web-dev-qa-db-fra.com

Quelle est la différence entre & et && en JavaScript?

Quelle est la différence entre & et && en JavaScript?

Exemple de code:

var first  = 123;
var second = false;
var third  = 456;
var fourth = "abc";
var fifth  = true;
alert(first & second); // 0
alert(first & third);  // 72
alert(first & fourth); // 0
alert(first & fifth);  // 1

alert(first && second); // false
alert(first && third);  // 456
alert(first && fourth); // abc
alert(first && fifth);  // true

Il semble que && soit un "et" logique qui me donne toujours la deuxième valeur si les deux sont vrais.

Mais comment ça &?

(Soit dit en passant, && semble être "et" en Python; & semble être & en Python.)

javascriptbitwise-operatorslogical-operators
62
Martin Thoma

& est au niveau du bit ET

Cet opérateur attend deux nombres et répète un nombre . Dans le cas où ils sont pas des nombres, ils sont convertis en nombres.

Comment ça marche? Wikipedia a une réponse: https://en.wikipedia.org/wiki/Bitwise_operation#AND

Remarque: En Javascript, l'utilisation de cet opérateur est déconseillée , car il n'y a pas de type de données entier, juste une virgule flottante. Ainsi, les flottants sont convertis en entiers avant chaque opération, ce qui le rend lent. De plus, il n'a aucune utilité réelle dans les applications Web classiques et produit du code illisible.

Règle générale: à éviter. Ne l'utilisez pas. Il a rarement sa place dans un code JS maintenable et lisible.

&& est logique ET

Il attend deux arguments et renvoie:

  • Premier terme qui s'évalue à faux
  • Dernier terme sinon (si tous sont vrais-y)

Voici quelques exemples:

0 && false          0 (both are false-y, but 0 is the first)
true && false       false (second one is false-y)
true && true        true (both are true-y)
true && 20          20 (both are true-y)

Si vous ne l'utilisez que sur Boolean, c'est exactement l'opérateur AND de la logique mathématique.

&& chaînage opérateur

La raison pour laquelle cet opérateur est défini comme ci-dessus est le chaînage des opérateurs. Vous êtes capable de chaîner cet opérateur tout en respectant les règles ci-dessus.

true && 20 && 0 && 100          0 (it is the first false-y)
10 && 20 && true && 100         100 (last one, since all are true-y)

&& court-circuit

Comme on peut le voir dans la définition, dès que vous trouvez qu'un terme est faux-y, vous n'avez pas à vous soucier des termes suivants. Javascript va même plus loin, les termes ne sont même pas évalués. C'est ce qu'on appelle un court-circuit.

true && false && alert("I am quiet!")

Cette instruction n'alerte rien et false est retourné. Par conséquent, vous pouvez utiliser le && opérateur comme remplacement plus court d'une instruction if. Ce sont équivalents:

if (user.isLoggedIn()) alert("Hello!")
user.isLoggedIn() && alert("Hello!")

Presque tous les compresseurs JS utilisent cette astuce pour économiser 2 octets.

114
Rok Kralj

& est le "et" au niveau du bit. Cela signifie que si vous avez deux nombres convertis en binaire, le résultat est un nombre qui a le 1 chiffre aux positions où les deux nombres ont 1.

  100011  //35
& 111001  //57
---------
  100001  //35 & 57 == 33
21
duri

Avec toutes les idées élevées et détaillées tout au long, la réponse pratique du profane qui a résolu ma tête en battant sur une chaîne d'instructions IF de quatre chaînées && provoquant FAILURE à faire le travail d'évaluation à portée de main en tant que IF ((sessionStorage.myLable! == "LableStringA" ) && (sessionStorage.myLable! == "LableStringB") && (sessionStorage.myLableZ! == "LableStringA") && (sessionStorage.myLableZ! == "LableStringB")) {...) était PRATIQUEMENT résolu dans le monde réel avec la solution de -4 voix basse (maintenant affichée juste en dessous) en utilisant simplement un simple & au lieu de && Merci Jake Wayne (et Russ). Remarque, en testant mon exemple! = A également fonctionné s'il est utilisé à la place du préféré! ==

0
GladHeart