Упорядочение аргументов String.equals()

Ответ 1

Билл Пью задал этот вопрос в Devoxx 2011. Подавляющее большинство людей пошли за формой "xyz".equals(str). Я с Биллом, теперь предпочитаю str.equals("xyz").

Основополагающим для традиции Java является то, что мы находим ошибки как можно раньше. NPE исключительно распространены. Мы хотим как можно скорее направить эти нули.

Если вы ожидаете ссылку, возможно, null, то я не особо возражаю против обратной записи. Приятно быть явным и понятным, что может быть null с отдельной проверкой null, но обратный порядок должен быть хорошо понят и достаточно дифференцировать код из нормального случая, когда null запрещено.

Работа с безопасностью, некоторые ошибки, допускающие недопустимость допуска, - это уязвимости.

Ответ 2

Условия Йоды (т.е. помещение константы перед переменной при сравнении) можно считать плохой практикой, поскольку она делает код кода менее понятным. В этом конкретном случае, однако, я бы сказал, что использование условия Yoda делает код более понятным, так как вам не нужно ставить перед ним лишнюю проверку.

Ответ 3

Перейдите по следующей ссылке, чтобы понять, что подразумевается под Условия Yoda | Обозначения

Его не "плохой стиль кодирования" - его различный способ кодирования.

Йода может быть полезен для отслеживания опечаток на некоторых языках, я считаю, что -1 не заслуживал честности, но это мое личное мнение.

Но Йода может быть плохим, как объясняется в этой длинной, но очень интересной статье.

Конец дня, есть сторонники в пользу и против этого рода нотации.

Ответ 4

Ну, это зависит. Если в вашей программе слово "слово" никогда не должно быть нулевым, word.equals( "s" ) может быть действительно лучше. Если по какой-то неясной причине "слово" станет нулевым, вы получите NullPointerException. Думаю об этом. Если вы получаете исключение, вы знаете, что что-то пошло не так, и вы можете быстрее найти ошибку и исправить ее. Если программа продолжит работать беззвучно и приведет к неправильным результатам, будет сложнее обнаружить проблему. На самом деле, вы можете не заметить, что проблема существует вообще.

Все зависит.

Ответ 5

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

• Строки редко являются нулевыми (и вы не должны создавать API-интерфейсы, где они есть, потому что люди этого не ожидают)
• Кажется странным поставить значение, которое вы сравниваете с первым
• Однозначность стиля кода важна, потому что этот путь является исключением, вы должны делать это только в том случае, если все в вашей команде это делают.

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

Ответ 6

TL; DR; Это определенно плохой стиль кодирования NOT: D

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

int test = 0;
if ( test ){ /* do something */

но это не разрешено в Java, поэтому вы не сталкиваетесь с такими проблемами, как забывание "=", например.

if ( test = 2 ){ /* do something */

вместо test == 2

• компилятор не позволит вам это сделать. Таким образом, состояние йоды может показаться неестественным для тех, кому это не нужно было заботиться (потому что он/она не использовал какой-либо другой язык, кроме Java).

Это определенно НЕ плохой стиль кодирования, это просто не очень часто, чтобы увидеть Java-код, используя его

Ответ 7

Условие yoda - это где oup поставить литерал перед переменной.

word.equals( "s" ) читается как "word equals s"

"s".equals(word), который человек читает как "s равно слова"

Наши мозги лучше читают первый пример и код более ясный.

единственная причина, по которой imho использовать условия yoda - это предотвратить присвоение как в случае "if (42 = i)" вместо "if (42 == i)"

Ответ 8

Существует особый случай, когда я объяснил, что я не видел защищенного или атакованного в любом из ответов, поэтому я добавлю его для справки. Это стиль:

 if(0 < x && x <= max) {

A Yoda условно, потому что константа (0) находится перед переменной (x). Аргументом против условностей Yoda является то, что затрудняет читаемость. Сравните этот пример с функционально эквивалентным

 if(x <= max && x > 0) {

Вы действительно думаете, что вариант, отличный от Yoda, более читабельен? Я этого не делаю.

Для удобства чтения при использовании упорядочивающих реляционных операторов (<, lt; =, > , > =), я предпочитаю стиль этих эвристик:

• Использовать согласованные отношения упорядочения: > согласуется s > =, но не с < или < =; < согласуется с < =.
• Предпочитают < и <= to > и > =, поскольку по умолчанию это восходящий порядок.
• Поместите условия, которые налагают нижнюю границу переменной перед условиями, которые налагают верхнюю границу, если использовать < и < =. Делайте обратное, если используете > и > =.

Это очень часто приводит к тому, что Yoda является условным для нижней границы.

Ответ 9

Можно утверждать, что вы должны (unit-) проверить свой код достаточно, чтобы быть уверенным, что нули не идут туда, где они не должны. Это должно устранить необходимость условий йоды.

Ответ 10

Вы можете написать

if (word != null && (word.equals("s") || word.equals("y")))

вместо

if ("s".equals(word) || "y".equals(word))

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