Является ли хорошей практикой использование оператора xor для логических проверок? [закрыто]

Я лично , как исключающие или , ^, оператор , когда это имеет смысл в контексте логических проверок из - за свою лаконичность. Я предпочитаю писать

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

чем

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

но меня часто смущают взгляды других опытных разработчиков Java (не только новичков), а иногда и комментарии о том, как его следует использовать только для побитовых операций.

Мне любопытно, что касается лучших практик использования ^оператора.

Вы можете просто использовать !=вместо этого.

Я думаю, что вы ответили на свой собственный вопрос - если вы получаете странные взгляды от людей, возможно, безопаснее пойти с более явным вариантом.

Если вам нужно это прокомментировать, то вам, вероятно, лучше заменить его более подробной версией и не заставлять людей задавать вопрос в первую очередь.

Я нахожу, что у меня много подобных разговоров. С одной стороны, у вас есть компактный, эффективный метод достижения вашей цели. С другой стороны, у вас есть кое-что, что остальная часть вашей команды может не понять, что затруднит его сохранение в будущем.

Мое общее правило - спрашивать, является ли используемая методика разумной для программистов. В этом случае я думаю, что разумно ожидать, что программисты будут знать, как использовать логические операторы, поэтому использование xor в операторе if - это нормально.

В качестве примера чего-то, что не было бы хорошо, возьмите хитрость использования xor для замены двух переменных без использования временной переменной. Это хитрость, с которой я не ожидал бы, что все будут знакомы, поэтому она не прошла бы проверку кода.

Я думаю, что было бы хорошо, если бы вы это прокомментировали, например // ^ == XOR.

Вы всегда можете просто обернуть его в функцию, чтобы дать ему подробное имя:

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

Но мне кажется, что для любого, кто не знал, что оператор ^ для Google, это было бы не сложно, это действительно быстро. Это не будет трудно вспомнить после первого раза. Поскольку вы запрашивали другие варианты использования, для использования битовой маскировки обычно используется XOR.

Вы также можете использовать XOR для замены значений в двух переменных без использования третьей временной переменной .

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

Вот вопрос Stackoverflow, связанный с заменой XOR .

Недавно я использовал xor в проекте JavaScript на работе и добавил 7 строк комментариев, чтобы объяснить, что происходит. Обоснование использования XOR в этом контексте было то , что одним из условий ( term1в приведенном ниже примере) может взять на себя не два , а три значения: undefined, trueили в falseто время как другие ( term2) может быть trueили false. Я должен был бы добавить дополнительную проверку для undefinedслучаев, но с xor, следующего было достаточно, поскольку xor заставляет первый член сначала быть оценен как логическое значение, позволяя undefinedобрабатываться как false:

if (term1 ^ term2) { ...

В конце концов, это было немного излишним, но я все равно хотел оставить его там, как пасхальное яйцо.

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

ИМХО этот код можно упростить:

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

Учитывая ясность кода, я считаю, что использование XOR в логических проверках не является типичным использованием побитового оператора XOR. Из моего опыта побитовый XOR в Java обычно используется для реализации flag toggleповедения маски :

flags = flags ^ MASK;

Эта статья Випана Сингла объясняет случай использования более подробно.

Если вам нужно использовать побитовый XOR, как в вашем примере, прокомментируйте, почему вы его используете, поскольку, вероятно, потребуется даже побитовая грамотная аудитория, чтобы остановиться, чтобы понять, почему вы ее используете.

Я лично предпочитаю выражение "boolean1 ^ boolean2" из-за его краткости.

Если бы я был в вашей ситуации (работая в команде), я бы пошел на компромисс, заключив логику «boolean1 ^ boolean2» в функцию с описательным именем, таким как «isDifferent (boolean1, boolean2)».

Например, вместо использования «boolean1 ^ boolean2», вы бы назвали «isDifferent (boolean1, boolean2)» следующим образом:

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

Ваша функция isDifferent (boolean1, boolean2) будет выглядеть так:

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

Конечно, это решение влечет за собой использование якобы постороннего вызова функции, который сам по себе подлежит проверке Best Practices, но он избегает многословного (и уродливого) выражения "(boolean1 &&! Boolean2) || (boolean2 &&! Boolean1) «!

Если модель использования оправдывает это, почему бы и нет? Хотя ваша команда не сразу узнает оператора, со временем они могут. Люди постоянно учат новые слова. Почему не в программировании?

Единственное предостережение, которое я могу заявить, это то, что у «^» нет семантики короткого замыкания вашей второй логической проверки. Если вам действительно нужна семантика короткого замыкания, тогда работает статический метод util.

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

! = можно сравнить две переменные. Это не работает, однако, с несколькими сравнениями.

Как побитовый оператор, xor намного быстрее, чем любой другой способ его замены. Поэтому для критичных к производительности и масштабируемых вычислений xor является обязательным условием.

Мое субъективное личное мнение: категорически запрещается использовать равенство (== или! =) Для логических значений. Его использование показывает отсутствие базовой этики и основ программирования. Любой, кто дает вам запутанные взгляды на ^, должен быть возвращен к основам булевой алгебры (у меня было искушение написать «рекам веры» здесь :)).

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

выглядит лучше для меня, чем

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