Est-ce une bonne pratique d'utiliser l'opérateur xor pour les contrôles booléens ?

Question

J'aime personnellement le exclusif ou , ^ Il s'agit d'un opérateur qui a du sens 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 des débutants), et parfois des commentaires sur le fait qu'il ne devrait être utilisé que pour les opérations de type bit à bit.

Je suis curieux de savoir quelles sont les meilleures pratiques en matière d'utilisation de l'outil d'évaluation de la qualité de l'eau. ^ opérateur.

Answer 1

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 de xor dans ce contexte était que l'un des termes ( term1 dans l'exemple ci-dessous) pourrait prendre non pas deux mais trois valeurs : undefined , true o false tandis que l'autre ( term2 ) pourrait être true o false . J'aurais dû ajouter un chèque supplémentaire pour la undefined mais avec xor, ce qui suit était suffisant puisque le xor force le premier terme à être d'abord évalué en tant que booléen, permettant ainsi à undefined sont traités comme false :

    if (term1 ^ term2) { ...

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

@ Martin : Je pense que c'est un bon argument pour ce que vous avez déjà dit :

Si vous avez besoin de le commenter, alors vous êtes probablement mieux de le remplacer par la version la plus verbeuse et ne pas que les gens ne se posent pas la question en question en premier lieu.

Answer 2

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

IMHO ce code pourrait être simplifié :

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

Answer 3

En gardant à l'esprit la clarté du code, je pense 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 mettre en œuvre un masque flag toggle comportement :

flags = flags ^ MASK;

Ce site L'article de Vipan Singla explique le cas d'utilisation plus en détail.

Si vous devez utiliser le XOR par bit comme dans votre exemple, expliquez pourquoi vous l'utilisez, car il est probable que même un public connaissant bien le bit doit s'arrêter pour comprendre pourquoi vous l'utilisez.

Answer 4

Personnellement, je préfère l'expression "boolean1 ^ boolean2" en raison de son caractère succinct.

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

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

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 ostensiblement étranger, ce qui en soi est soumis à l'examen des meilleures pratiques, mais elle permet d'éviter l'expression verbeuse (et laide) "(boolean1 && !boolean2) || (boolean2 && !boolean1)" !

Answer 5

Si le modèle d'utilisation le justifie, pourquoi pas ? Si votre équipe ne reconnaît pas tout de suite l'opérateur, avec le temps, elle pourrait le faire. Les humains apprennent de nouveaux mots tout le temps. Pourquoi pas en programmation ?

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

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