¿Por qué no hay un XOR lógico?

¿Por qué no hay lógica? XOR en JavaScript?

JavaScript rastrea su ascendencia hasta C, y C no tiene un operador XOR lógico. Principalmente porque no es útil. Bitwise XOR es extremadamente útil, pero en todos mis años de programación nunca he necesitado un XOR lógico.

Si tiene dos variables booleanas, puede imitar XOR con:

if (a != b)

Con dos variables arbitrarias podrías usar ! para forzarlos a valores booleanos y luego usar el mismo truco:

if (!a != !b)

Sin embargo, eso es bastante oscuro y ciertamente merecería un comentario. De hecho, incluso podría usar el operador XOR bit a bit en este punto, aunque esto sería demasiado inteligente para mi gusto:

if (!a ^ !b)

Javascript tiene un operador XOR bit a bit: ^

var nb = 5^9 // = 12

Puede usarlo con booleanos y dará el resultado como 0 o 1 (que puede volver a convertir a booleanos, por ejemplo result = !!(op1 ^ op2)). Pero como dijo John, es equivalente a result = (op1 != op2)que es más claro.

El XOR de dos booleanos es simplemente si son diferentes, por lo tanto:

Boolean(a) !== Boolean(b)

No hay operadores booleanos lógicos reales en Javascript (aunque ! se acerca bastante). Un operador lógico sólo tomaría true o false como operandos y solo devolverían true o false.

En Javascript && y || tome todo tipo de operandos y devuelva todo tipo de resultados divertidos (lo que sea que los alimente).

Además, un operador lógico siempre debe tener en cuenta los valores de ambos operandos.

En Javascript && y || tomar un atajo perezoso y hacer no evaluar el segundo operando en ciertos casos y, por lo tanto, despreciar sus efectos secundarios. Este comportamiento es imposible de recrear con un xor lógico.

a() && b() evalúa a() y devuelve el resultado si es falso. De lo contrario, se evalúa b() y devuelve el resultado. Por lo tanto, el resultado devuelto es verdadero si ambos resultados son verdaderos y falso en caso contrario.

a() || b() evalúa a() y devuelve el resultado si es veraz. De lo contrario, se evalúa b() y devuelve el resultado. Por lo tanto, el resultado devuelto es falso si ambos resultados son falsos y verdadero en caso contrario.

Entonces, la idea general es evaluar primero el operando izquierdo. El operando correcto solo se evalúa si es necesario. Y el último valor es el resultado. Este resultado puede ser cualquier cosa. Objetos, números, cadenas… ¡lo que sea!

Esto hace posible escribir cosas como

image = image || new Image(); // default to a new Image

o

src = image && image.src; // only read out src if we have an image

Pero el valor de verdad de este resultado también se puede usar para decidir si un operador lógico “real” habría devuelto verdadero o falso.

Esto hace posible escribir cosas como

if (typeof image.hasAttribute === 'function' && image.hasAttribute('src')) {

o

if (image.hasAttribute('alt') || image.hasAttribute('title')) {

Pero un operador xor “lógico” (^^) siempre tendría que evaluar ambos operandos. Esto lo hace diferente a los otros operadores “lógicos” que evalúan el segundo operando solo si es necesario. Creo que es por eso que no hay xor “lógico” en Javascript, para evitar confusiones.

Entonces, ¿qué debería pasar si ambos operandos son falsos? Ambos podrían ser devueltos. Pero solo se puede devolver uno. ¿Cuál? ¿El primero? ¿O el segundo? Mi intuición me dice que devuelva el primer pero generalmente los operadores “lógicos” evalúan de izquierda a derecha y devuelven el último valor evaluado. ¿O tal vez una matriz que contiene ambos valores?

Y si un operando es verdadero y el otro falso, un xor debe devolver el verdadero. ¿O tal vez una matriz que contenga la verdadera, para que sea compatible con el caso anterior?

Y finalmente, ¿qué debería pasar si ambos operandos son verdaderos? Esperarías algo falso. Pero no hay resultados falsos. Entonces la operación no debería devolver nada. Así que tal vez undefined o .. una matriz vacía? Pero una matriz vacía sigue siendo verdadera.

Tomando el enfoque de matriz, terminaría con condiciones como if ((a ^^ b).length !== 1) {. Muy confuso.

Convierta los valores en forma booleana y luego tome XOR bit a bit:

Boolean(a) ^ Boolean(b) // === 0 | 1

Tenga en cuenta que el resultado de esta expresión es un número y no un booleano.

Bitwise XOR también funciona con valores no booleanos, pero recuerde que este es un bit a bit operador, y no uno lógico. Es posible que el uso de non-bools no salga como esperaba:

(5 ^ 3) === 6 // true

Convierta a booleano y luego realice xor como –

!!a ^ !!b

hay… una especie de:

if( foo ? !bar : bar ) {
  ...
}

o más fácil de leer:

if( ( foo && !bar ) || ( !foo && bar ) ) {
  ...
}

¿por qué? No sé.

porque los desarrolladores de javascript pensaron que sería innecesario ya que puede expresarse mediante otros operadores lógicos ya implementados.

también podría haber ido con nand y eso es todo, puede impresionar a todas las demás operaciones lógicas posibles a partir de eso.

Personalmente, creo que tiene razones históricas que conducen desde lenguajes de sintaxis basados ​​en c, donde, según mi conocimiento, xor no está presente o al menos es extremadamente poco común.