definicion - que es javascript

¿Por qué no hay xor lógico en JavaScript?

Question

¿Por qué no hay xor lógico en JavaScript?

Answer 1

¿Qué hay de transformar el resultado int a un bool con doble negación? No es tan bonito, pero realmente compacto.

var state1 = false,
state2 = true;
var A = state1 ^ state2; // will become 1
var B = !!(state1 ^ state2); // will become true
console.log(A);
console.log(B);

Answer 2

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

Boolean(a) !== Boolean(b)

Answer 3

En la función xor anterior, se obtendrá un resultado SIMILAR, ya que la lógica xor no es exactamente lógica xor, significa que dará como resultado "falso para valores iguales" y "verdadero para diferentes valores" con coincidencia de tipos de datos.

Esta función xor funcionará como xor real o operador lógico , significa que dará como resultado verdadero o falso de acuerdo con los valores de paso que son truey o falsy . Use de acuerdo a sus necesidades

function xor(x,y){return true==(!!x!==!!y);}
function xnor(x,y){return !xor(x,y);}

Answer 4

JavaScript rastrea su ascendencia a 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 a XOR con:

if (a != b)

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

if (!a != !b)

Eso es bastante oscuro y sin duda 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)

Answer 5

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 convertir de nuevo a booleano, por ejemplo, result = !!(op1 ^ op2) ). Pero como dijo John, es equivalente a result = (op1 != op2) , que es más claro.

Answer 6

La razón por la que no hay XOR lógico (^^) es porque a diferencia de && y || no da ninguna ventaja de la lógica perezosa. Ese es el estado de ambas expresiones a la derecha e izquierda deben ser evaluadas.

Answer 7

No hay operadores booleanos lógicos reales en Javascript (aunque ! Está bastante cerca). Un operador lógico solo tomaría true o false como operandos y solo devolvería true o false .

En Javascript && y || toma todo tipo de operandos y devuelve todo tipo de resultados divertidos (lo que sea que introduzcas en ellos).

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

En Javascript && y || tome un atajo perezoso y no evalúe el segundo operando en ciertos casos y descuide 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, evalúa b() y devuelve el resultado. Por lo tanto, el resultado devuelto es verídico si ambos resultados son verdaderos, y falso de lo contrario.

a() || b() a() || b() evalúa a() y devuelve el resultado si es verdad. De lo contrario, evalúa b() y devuelve el resultado. Por lo tanto, el resultado devuelto es falso si ambos resultados son falsos, y de otra manera.

Entonces, la idea general es evaluar primero el operando de la izquierda. 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" hubiera resultado 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 esta es la razón por la cual 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 uno puede ser devuelto. ¿Cúal? ¿El primero? ¿O el segundo? Mi intuición me dice que devuelva el primero, pero por lo general 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 verdad y el otro operando es falso, un xor debería devolver el verdadero. ¿O tal vez una matriz que contiene la verdadera, para que sea compatible con el caso anterior?

Y finalmente, ¿qué pasaría si ambos operandos son verdad? Esperarías algo falso. Pero no hay resultados falsos. Entonces la operación no debería devolver nada. Entonces quizás undefined o ... ¿una matriz vacía? Pero una matriz vacía sigue siendo cierta.

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

Answer 8

Prueba este corto y fácil de entender

function xor(x,y){return true==(x!==y);}
function xnor(x,y){return !xor(x,y);}

Esto funcionará para cualquier tipo de datos

Answer 9

Revisa:

• Lógico XOR en JavaScript

Puedes imitar algo como esto:

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

Answer 10

Sí, solo haz lo siguiente. Suponiendo que está tratando con los booleanos A y B, entonces el valor de A XOR B se puede calcular en JavaScript usando el siguiente

var xor1 = !(a === b);

La línea anterior también es equivalente a la siguiente

var xor2 = (!a !== !b);

Personalmente, prefiero xor1 ya que tengo que escribir menos caracteres. Creo que xor1 también es más rápido también. Solo está realizando dos cálculos. xor2 está realizando tres cálculos.

Explicación visual ... Lee la tabla de abajo (donde 0 significa falso y 1 representa verdadero) y compara las columnas 3 y 5.

! (A === B):

| A | B | A XOR B | A === B | !(A === B) |
------------------------------------------
| 0 | 0 | 0 | 1 | 0 |
| 0 | 1 | 1 | 0 | 1 |
| 1 | 0 | 1 | 0 | 1 |
| 1 | 1 | 0 | 1 | 0 |
------------------------------------------

Disfrutar.

Answer 11

hay ... algo así como:

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 ser expresado por otros operadores lógicos ya implementados.

podrías simplemente darte por vencido y eso es todo, puedes impresionar cualquier otra operación lógica posible de eso.

Personalmente creo que tiene razones históricas que impulsan los lenguajes de sintaxis basados ​​en c, donde, a mi entender, xor no está presente o al menos es extraordinariamente poco común.