Est-il de toute façon à mettre en œuvre XOR en javascript

Question

Je suis en train de mettre en œuvre XOR dans le code javascript de la façon suivante:

   // XOR validation
   if ((isEmptyString(firstStr) && !isEmptyString(secondStr)) ||
    (!isEmptyString(firstStr) && isEmptyString(secondStr))
   {
    alert(SOME_VALIDATION_MSG);
    return;
   }

Est-il une meilleure façon de le faire en javascript?

Merci.

Answer 1

Comme d'autres l'ont souligné, la logique XOR est la même que la non-égalité pour les booléens, de sorte que vous pouvez le faire:

  // XOR validation
  if( isEmptyString(firstStr) != isEmptyString(secondStr) )
    {
      alert(SOME_VALIDATION_MSG);
      return;
    }

Answer 2

Je fais semblant que vous êtes à la recherche pour un opérateur logique XOR, que javascript a déjà un bit à bit d'un (^) :)

J'ai l'habitude d'utiliser un simple opérateur ternaire (une des rares fois où j'utilise un):

if ((isEmptyString(firstStr) ? !isEmptyString(secondStr) 
                             : isEmptyString(secondStr))) {
alert(SOME_VALIDATION_MSG);
    return;
}

Edit:

de travail sur l' @Jeff boulette de viande Yang solution

if ((!isEmptyString(firstStr) ^ !isEmptyString(secondStr))) {
  alert(SOME_VALIDATION_MSG);
  return;
}

vous nier les valeurs afin de les transformer en des booléens et ensuite appliquer l'opérateur xor au niveau du bit. Peut-être qu'il n'est pas si facile à gérer que la première solution (ou peut-être que je suis trop habitué à la première)

Answer 3

Vous êtes en train de faire un XOR de valeurs booléennes qui est facile à modèle dans un XOR au niveau du bit (qui Javascript a):

var a = isEmptyString(firstStr) ? 1 : 0;
var b = isEmptyString(secondStr) ? 1 : 0;

if(a ^ b) { ... }

http://www.howtocreate.co.uk/xor.html

Answer 4

Vous pouvez utiliser l'opérateur XOR au niveau du bit (^) directement:

if (isEmptyString(firstStr) ^ isEmptyString(secondStr)) {
  // ...
}

Il va travailler pour votre exemple, depuis le booléen true et false des valeurs sont converties en 1 et 0 parce que les opérateurs au niveau du bit travailler avec des nombres entiers de 32 bits.

Cette expression renvoie aussi 0 ou 1, et que la valeur va être contraint de revenir à Booléen par l' if déclaration.

Vous devez être conscient du type de contrainte qui se produit avec l'approche ci-dessus, si vous êtes à la recherche pour un bon rendement, je ne vous recommanderais pas de travailler avec les opérateurs au niveau du bit, vous pouvez également en faire une fonction simple de le faire en utilisant seulement les opérateurs logiques Booléens:

function xor(x, y) {
  return (x || y) && !(x && y);
}


if (xor(isEmptyString(firstStr), isEmptyString(secondStr))) {
  // ...
}

Answer 5

Plus facile méthode:

if ((x+y) % 2) {
    //statement
}

en supposant bien sûr que les deux variables sont vraies valeurs booléennes, qui est, 1 ou 0.

• Si x === y vous obtiendrez un nombre pair, donc XOR sera 0.
• Et si x !== y ensuite, vous aurez un nombre impair, donc XOR sera 1 :)

---

Une deuxième option, si vous remarquez que l' x != y évalue comme un XOR, puis tout ce que vous devez faire est de

if (x != y) {
    //statement
}

Qui va simplement évaluer, de nouveau, comme un XOR. (J'aime beaucoup mieux)

Bien sûr, une bonne idée serait de mettre en place cela dans une fonction, mais c'est votre seul choix.

Espérons que l'une des deux méthodes d'aider quelqu'un! Je marque cette réponse wiki de la communauté, de sorte qu'il peut être amélioré.