Est-ce une bonne pratique d'utiliser l'opérateur xor pour les vérifications booléennes? [fermé]

Personnellement , je aime l' exclusivité ou , ^, l' opérateur quand il est logique dans le contexte des contrôles booléens en raison de sa concision. Je préfère de loin écrire

if (boolean1 ^ boolean2)
{
  //do it
}

que

if((boolean1 && !boolean2) || (boolean2 && !boolean1))
{
  //do it
}

mais je reçois souvent des regards confus de la part d'autres développeurs Java expérimentés (pas seulement les débutants), et parfois des commentaires sur la façon dont il ne devrait être utilisé que pour des opérations au niveau du bit.

Je suis curieux de connaître les meilleures pratiques concernant l'utilisation de l' ^opérateur.

Vous pouvez simplement utiliser à la !=place.

Je pense que vous avez répondu à votre propre question - si vous obtenez des regards étranges de la part des gens, il est probablement plus sûr d'opter pour l'option la plus explicite.

Si vous avez besoin de le commenter, vous feriez probablement mieux de le remplacer par la version plus verbeuse et de ne pas obliger les gens à poser la question en premier lieu.

Je trouve que j'ai beaucoup de conversations similaires. D'une part, vous disposez d'une méthode compacte et efficace pour atteindre votre objectif. D'un autre côté, vous avez quelque chose que le reste de votre équipe pourrait ne pas comprendre, ce qui compliquera la maintenance à l'avenir.

Ma règle générale est de demander si la technique utilisée est quelque chose qu'il est raisonnable de s'attendre à ce que les programmeurs en général sachent. Dans ce cas, je pense qu'il est raisonnable de s'attendre à ce que les programmeurs sachent comment utiliser les opérateurs booléens, donc utiliser xor dans une instruction if est correct.

Comme exemple de quelque chose qui ne serait pas correct, prenez l'astuce d'utiliser xor pour échanger deux variables sans utiliser de variable temporaire. C'est une astuce que je ne m'attendrais pas à ce que tout le monde soit familier, donc cela ne passerait pas l'examen du code.

Je pense que ce serait bien si vous le commentiez, par exemple // ^ == XOR.

Vous pouvez toujours simplement l'envelopper dans une fonction pour lui donner un nom détaillé:

public static boolean XOR(boolean A, boolean B) {
    return A ^ B;
}

Mais, il me semble que ce ne serait pas difficile pour quiconque ne savait pas à quoi sert l'opérateur ^ de Google très rapidement. Ce ne sera pas difficile à retenir après la première fois. Puisque vous avez demandé d'autres utilisations, il est courant d'utiliser le XOR pour le masquage de bits.

Vous pouvez également utiliser XOR pour permuter les valeurs de deux variables sans utiliser de troisième variable temporaire .

// Swap the values in A and B
A ^= B;
B ^= A;
A ^= B;

Voici une question Stackoverflow liée à l'échange XOR .

J'ai récemment utilisé un xor dans un projet JavaScript au travail et j'ai fini par ajouter 7 lignes de commentaires pour expliquer ce qui se passait. La justification de l' utilisation XOR dans ce contexte est que l' un des termes ( term1dans l'exemple ci - dessous) pourrait prendre pas deux , mais trois valeurs: undefined, trueou falsealors que l'autre ( term2) pourrait être trueou false. J'aurais dû ajouter une vérification supplémentaire pour les undefinedcas mais avec xor, ce qui suit était suffisant car le xor force le premier terme à être d'abord évalué comme un booléen, laissant undefinedêtre traité comme false:

if (term1 ^ term2) { ...

C'était, à la fin, un peu exagéré, mais je voulais quand même le garder là-dedans, comme une sorte d'oeuf de Pâques.

if((boolean1 && !boolean2) || (boolean2 && !boolean1)) 
{ 
  //do it 
} 

IMHO ce code pourrait être simplifié:

if(boolean1 != boolean2) 
{ 
  //do it 
} 

En gardant à l'esprit la clarté du code, mon opinion est que l'utilisation de XOR dans les contrôles booléens n'est pas une utilisation typique de l'opérateur binaire XOR. D'après mon expérience, le XOR bit à bit en Java est généralement utilisé pour implémenter un flag togglecomportement de masque :

flags = flags ^ MASK;

Cet article de Vipan Singla explique le cas d'utilisation plus en détail.

Si vous avez besoin d'utiliser le XOR au niveau du bit comme dans votre exemple, expliquez pourquoi vous l'utilisez, car il est probable que même un public alphabétisé au niveau du bit s'arrête dans ses pistes pour comprendre pourquoi vous l'utilisez.

Personnellement, je préfère l'expression "boolean1 ^ boolean2" en raison de sa concision.

Si j'étais dans votre situation (travaillant en équipe), je trouverais un compromis en encapsulant la logique "boolean1 ^ boolean2" dans une fonction avec un nom descriptif tel que "isDifferent (boolean1, boolean2)".

Par exemple, au lieu d'utiliser "boolean1 ^ boolean2", vous appelleriez "isDifferent (boolean1, boolean2)" comme ceci:

if (isDifferent(boolean1, boolean2))
{
  //do it
}

Votre fonction "isDifferent (boolean1, boolean2)" ressemblerait à ceci:

private boolean isDifferent(boolean1, boolean2)
{
    return boolean1 ^ boolean2;
}

Bien sûr, cette solution implique l'utilisation d'un appel de fonction apparemment étranger, qui en soi est soumis à l'examen des meilleures pratiques, mais elle évite l'expression verbeuse (et moche) "(boolean1 &&! Boolean2) || (boolean2 &&! Boolean1) "!

Si le modèle d'utilisation le justifie, pourquoi pas? Bien que votre équipe ne reconnaisse pas immédiatement l'opérateur, elle le pourrait avec le temps. Les humains apprennent tout le temps de nouveaux mots. Pourquoi pas en programmation?

La seule mise en garde que je pourrais dire est que "^" n'a pas la sémantique de court-circuit de votre deuxième vérification booléenne. Si vous avez vraiment besoin de la sémantique des courts-circuits, une méthode util statique fonctionne également.

public static boolean xor(boolean a, boolean b) {
    return (a && !b) || (b && !a);
}

! = est OK pour comparer deux variables. Cela ne fonctionne pas, cependant, avec de multiples comparaisons.

En tant qu'opérateur au niveau du bit, xor est beaucoup plus rapide que tout autre moyen de le remplacer. Donc, pour les calculs de performances critiques et évolutifs, xor est impératif.

Mon opinion personnelle subjective: Il est absolument interdit, pour quelque raison que ce soit, d'utiliser l'égalité (== ou! =) Pour les booléens. Son utilisation montre un manque d'éthique et de principes fondamentaux de la programmation. Quiconque vous jette un regard confus sur ^ devrait être renvoyé aux bases de l'algèbre booléenne (j'ai été tenté d'écrire "aux rivières de la croyance" ici :)).

str.contains("!=") ^ str.startsWith("not(")

me va mieux que

str.contains("!=") != str.startsWith("not(")