¿Cuál es la diferencia entre & y && en JavaScript?

Código de ejemplo:

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

Parece que && es un "y" lógico que siempre me da el segundo valor si ambos son verdaderos.

Pero que es &?

(Por cierto, && parece ser "y" en Python; & parece ser & en Python).

& es bit a bit Y

Este operador espera dos números y devuelve un número. En caso de que no sean números, se convierten en números.

¿Como funciona? Wikipedia tiene una respuesta: https://en.wikipedia.org/wiki/Bitwise_operation#AND

Nota: En Javascript, se desaconseja el uso de este operador , ya que no hay un tipo de datos entero, solo un punto flotante. Por lo tanto, los flotantes se convierten en números enteros antes de cada operación, lo que la hace lenta. Además, no tiene un uso real en aplicaciones web típicas y produce código ilegible.

Regla general: evitar. No lo use. Rara vez tiene lugar en un código JS fácil de mantener y leer.

&& es lógico Y

Espera dos argumentos y devuelve:

• Primer término que se evalúa como falso
• Último término de lo contrario (si todos son verdaderos)

Aquí hay unos ejemplos:

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 solo lo usa en booleano, este es exactamente el operador AND de la lógica matemática.

&& encadenamiento de operadores

La razón por la que este operador se define como anteriormente es el encadenamiento de operadores. Puede encadenar este operador y seguir manteniendo las reglas anteriores.

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

&& cortocircuito

Como puede verse en la definición, tan pronto como descubra que un término es falso, no debe preocuparse por los siguientes términos. Javascript incluso lleva esto un poco más allá, los términos ni siquiera se evalúan. A esto se le llama cortocircuito.

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

Esta declaración no alerta nada y falsese devuelve. Por lo tanto, puede usar el &&operador como un reemplazo más corto de una declaración if. Estos son equivalentes:

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

Casi todos los compresores JS usan este truco para ahorrar 2 bytes.

&es el bit a bit "y". Esto significa que si tiene dos números convertidos a binarios, el resultado es un número que tiene el 1dígito en las posiciones donde tienen ambos números 1.

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

Para determinar si dos valores booleanos juntos son verdaderos o falsos, si desea verificar ambos (como la validación en la página web), puede usar el &operador. &es AND bit a bit.

Con el &&operador, una vez que encuentra que el primer valor es falso, finalizará la evaluación y no comprobará el segundo valor.

Con todas las ideas elevadas y detalladas en todo momento, en su mayoría se han perdido la verdad de que hay una evaluación condicional en la que SOLO el single & funcionará. La respuesta práctica del lego que resolvió mi cabeza golpeando una cadena de instrucciones IF de MULTIPLE encadenado && cada! == a una condición estaba causando FALLO y necesitaba usar legítimamente el sencillo &. Agradezco a Jake Wayne (y Russ) por su respuesta injustamente rechazada que acertó dado que donde hay más de un && that! == ya ha cesado su evaluación y no procede más después de que se encuentra la primera evaluación == !. Con &&, cree que su trabajo está hecho después de que la primera evaluación muestre! == [eg. falso]. Mi código fallido era

IF ((sessionStorage.myLable !== "LableStringA") && (sessionStorage.myLable !== "LableStringB") && (sessionStorage.myLableZ !== "LableStringA") && (sessionStorage.myLableZ !== "LableStringB")) { ...)

Aquí, sustituyendo y usando correctamente un & por el &&, era prácticamente en el mundo real y técnicamente la respuesta correcta. Gracias de nuevo a Jake Wayne (y Russ) por la información y comprensión del código.