Мы знаем множество операторов сравнения из математики.
В JavaScript они записываются так:
Больше/меньше: a > b , a < b .
Больше/меньше или равно: a >= b , a <= b .
Равно: a == b , обратите внимание, что двойной знак равенства == означает проверку равенства, а одинарный a = b означает присваивание.
Не равно: в математике используется обозначение ≠ , но в JavaScript оно записывается как a != b .
В этой статье мы узнаем больше о различных типах сравнений, о том, как их выполняет JavaScript, включая важные особенности.
В конце вы найдете хороший рецепт, как избежать проблем, связанных с «особенностями JavaScript».
Все операторы сравнения возвращают логическое значение:
true – означает «да», «правильный» или «истина».
false – означает «нет», «неправда» или «не правда».
Например:
предупреждение (2 > 1); // правда (правильно) предупреждение (2 == 1); // ложь (неверно) предупреждение( 2 != 1 ); // правда (правильно)
Результат сравнения можно присвоить переменной, как и любому значению:
пусть результат = 5 > 4; // присваиваем результат сравнения оповещение (результат); // истинный
Чтобы узнать, больше ли строка другой, JavaScript использует так называемый «словарный» или «лексикографический» порядок.
Другими словами, строки сравниваются побуквенно.
Например:
Предупреждение('Z' > 'A'); // истинный
alert('Свечение' > 'Ликование'); // истинный
alert('Пчела' > 'Быть'); // истинныйАлгоритм сравнения двух строк прост:
Сравните первый символ обеих строк.
Если первый символ первой строки больше (или меньше), чем символ другой строки, то первая строка больше (или меньше), чем вторая. Мы закончили.
В противном случае, если первые символы обеих строк одинаковы, сравните вторые символы таким же образом.
Повторяйте до конца любой строки.
Если обе строки имеют одинаковую длину, то они равны. В противном случае более длинная строка будет больше.
В первом примере выше сравнение 'Z' > 'A' приводит к результату на первом этапе.
Второе сравнение 'Glow' и 'Glee' требует большего количества шагов, поскольку строки сравниваются посимвольно:
G — то же самое, что и G
l то же самое, что и l .
o больше, чем e . Остановитесь здесь. Первая строка больше.
Не настоящий словарь, а порядок Unicode
Приведенный выше алгоритм сравнения примерно эквивалентен тому, который используется в словарях или телефонных книгах, но это не совсем то же самое.
Например, дело имеет значение. Заглавная буква "A" не равна строчной "a" . Какой из них больше? Маленькая буква "a" . Почему? Потому что символ нижнего регистра имеет больший индекс во внутренней таблице кодировки, которую использует JavaScript (Unicode). Мы вернемся к конкретным деталям и последствиям этого в главе «Строки».
При сравнении значений разных типов JavaScript преобразует значения в числа.
Например:
предупреждение( '2' > 1); // правда, строка '2' становится числом 2
предупреждение ('01' == 1); // правда, строка '01' становится числом 1 Для логических значений true становится 1 , а false становится 0 .
Например:
предупреждение (истина == 1); // истинный предупреждение (ложь == 0); // истинный
Забавное последствие
Возможно, что одновременно:
Два значения равны.
Одно из них true как логическое значение, а другое false как логическое значение.
Например:
пусть а = 0; Предупреждение(логическое значение(а)); // ЛОЖЬ пусть б = «0»; предупреждение(логическое значение(б)); // истинный оповещение (а == б); // истинный!
С точки зрения JavaScript, этот результат вполне нормальный. Проверка равенства преобразует значения с помощью числового преобразования (следовательно, "0" становится 0 ), тогда как явное Boolean преобразование использует другой набор правил.
Обычная проверка на равенство == имеет проблему. Он не может отличить 0 от false :
предупреждение (0 == ложь); // истинный
То же самое происходит и с пустой строкой:
Предупреждение( '' == Ложь); // истинный
Это происходит потому, что операнды разных типов преобразуются в числа оператором равенства == . Пустая строка, как и false , становится нулем.
Что делать, если мы хотим отличить 0 от false ?
Оператор строгого равенства === проверяет равенство без преобразования типа.
Другими словами, если a и b имеют разные типы, то a === b немедленно возвращает false без попытки их преобразования.
Давайте попробуем:
предупреждение (0 === ложь); // false, потому что типы разные
Существует также оператор «строгого неравенства» !== аналогичный != .
Оператор строгого равенства писать немного дольше, но он делает очевидным, что происходит, и оставляет меньше места для ошибок.
При сравнении null или undefined с другими значениями наблюдается неинтуитивное поведение.
Для проверки строгого равенства ===
Эти значения различны, поскольку каждое из них относится к разным типам.
оповещение (ноль === не определено); // ЛОЖЬ
Для нестрогой проверки ==
Есть особое правило. Эти двое — «сладкая парочка»: они равны друг другу (в смысле == ), но не какому-либо другому значению.
Оповещение (ноль == неопределенное); // истинный
Для математических вычислений и других сравнений < > <= >=
null/undefined преобразуются в числа: null становится 0 , а undefined становится NaN .
Теперь давайте посмотрим на некоторые забавные вещи, которые происходят, когда мы применяем эти правила. И, что еще важнее, как не попасть с ними в ловушку.
Давайте сравним null с нулем:
предупреждение (ноль > 0); // (1) ложь оповещение (ноль == 0); // (2) ложь предупреждение (ноль >= 0); // (3) правда
Математически это странно. Последний результат гласит, что « null больше или равен нулю», поэтому в одном из приведенных выше сравнений оно должно быть true , но оба они ложны.
Причина в том, что проверка равенства == и сравнения > < >= <= работают по-разному. Сравнения преобразуют null в число, рассматривая его как 0 . Вот почему (3) null >= 0 является истиной, а (1) null > 0 является ложным.
С другой стороны, проверка равенства == для undefined и null определяется так, что без каких-либо преобразований они равны друг другу и не равны ничему другому. Вот почему (2) null == 0 является ложным.
Значение undefined не следует сравнивать с другими значениями:
предупреждение (не определено > 0); // ложь (1) предупреждение (не определено <0); // ложь (2) оповещение (не определено == 0); // ложь (3)
Почему он так не любит ноль? Всегда ложь!
Мы получаем такие результаты, потому что:
Сравнения (1) и (2) возвращают false , поскольку undefined преобразуется в NaN , а NaN — это специальное числовое значение, которое возвращает значение false для всех сравнений.
Проверка на равенство (3) возвращает false поскольку undefined равно только null , undefined и никакому другому значению.
Почему мы рассмотрели эти примеры? Стоит ли нам постоянно помнить об этих особенностях? Ну, не совсем. На самом деле, эти хитрые вещи со временем станут привычными, но есть надежный способ избежать с ними проблем:
Относитесь к любому сравнению с undefined/null за исключением строгого равенства === с исключительной осторожностью.
Не используйте сравнения >= > < <= с переменной, которая может быть null/undefined , если вы действительно не уверены в том, что делаете. Если переменная может иметь эти значения, проверьте их отдельно.
Операторы сравнения возвращают логическое значение.
Строки сравниваются побуквенно в «словарном» порядке.
При сравнении значений разных типов они преобразуются в числа (за исключением строгой проверки на равенство).
Значения null и undefined равны == друг другу и не равны никакому другому значению.
Будьте осторожны при использовании сравнений типа > или < с переменными, которые иногда могут быть null/undefined . Хорошей идеей является проверка наличия значений null/undefined отдельно.
важность: 5
Каков будет результат этих выражений?
5 > 4 «яблоко» > «ананас» «2» > «12» не определено == ноль не определено === ноль ноль == "n0n" ноль === +"n0n"
5 > 4 → верно «яблоко» > «ананас» → ложь «2» > «12» → верно неопределенное == ноль → правда не определено === ноль → ложь ноль == "n0n" → ложь ноль === +"n0n" → ложь
Некоторые из причин:
Очевидно, правда.
Сравнение словарей, следовательно, ложное. "a" меньше "p" .
Опять же, сравнение словаря: первый символ "2" больше первого символа "1" .
Значения null и undefined равны только друг другу.
Строгое равенство является строгим. Разные типы с обеих сторон приводят к ложному.
Как и в (4) , null равно только undefined .
Строгое равенство разных типов.