10 KiB
| title | localeTitle |
|---|---|
| Comparison Operators | Операторы сравнения |
JavaScript имеет как строгие, так и типовые преобразования .
-
Строгое сравнение (например, ===) справедливо только в том случае, если операнды одного типа.
-
Более часто используемое абстрактное сравнение (например, ==) преобразует операнды в один и тот же тип перед проведением сравнения.
-
Для реляционных абстрактных сравнений (например, <=) операнды сначала преобразуются в примитивы, а затем к тому же типу перед сравнением.
-
Строки сравниваются на основе стандартного лексикографического упорядочения, используя значения Unicode.
Особенности сравнения:
-
Две строки строго равны, если они имеют одну и ту же последовательность символов, одну и ту же длину и одинаковые символы в соответствующих позициях.
-
Два числа строго равны, если они численно равны (имеют одинаковое числовое значение). NaN не равно никому, включая NaN. Положительные и отрицательные нули равны друг другу.
-
Два булевых операнда строго равны, если оба они истинны или оба ложны.
-
Два разных объекта никогда не равны ни для строгих, ни для абстрактных сравнений.
-
Выражение, сравнивающее объекты, истинно, только если операнды ссылаются на один и тот же объект.
-
Null и Undefined Types строго равны себе и абстрактно равны друг другу.
Операторы равенства
Равенство (==)
Оператор равенства преобразует операнды, если они не одного типа , а затем применяет строгое сравнение. Если оба операнда являются объектами , тогда JavaScript сравнивает внутренние ссылки, равные, когда операнды относятся к одному и тому же объекту в памяти.
Синтаксис
x == y
Примеры
1 == 1 // true
"1" == 1 // true
1 == '1' // true
0 == false // true
0 == null // false
0 == undefined // false
null == undefined // true
Неравенство (! =)
Оператор неравенства возвращает true, если операнды не равны. Если два операнда не одного типа , JavaScript пытается преобразовать операнды в соответствующий тип для сравнения. Если оба операнда являются объектами , тогда JavaScript сравнивает внутренние ссылки, которые не равны, когда операнды относятся к различным объектам в памяти.
Синтаксис
x != y
Примеры
1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false
Идентичность / строгое равенство (===)
Оператор identity возвращает true, если операнды строго равны без преобразования типа .
Синтаксис
x === y
Примеры
3 === 3 // true
3 === '3' // false
Нетождественное / строгое неравенство (! ==)
Оператор, не являющийся идентификатором, возвращает true, если операнды не равны и / или не того же типа .
Синтаксис
x !== y
Примеры
3 !== '3' // true
4 !== 3 // true
Операторы отношения
Больше, чем оператор (>)
Оператор больше, чем оператор, возвращает true, если левый операнд больше, чем правый операнд.
Синтаксис
x > y
Примеры
4 > 3 // true
Оператор больше или равно (> =)
Оператор большего или равного возвращает true, если левый операнд больше или равен правильному операнду.
Синтаксис
x >= y
Примеры
4 >= 3 // true
3 >= 3 // true
Меньше оператора (<)
Оператор меньше, чем оператор, возвращает true, если левый операнд меньше, чем правый операнд.
Синтаксис
x < y
Примеры
3 < 4 // true
Меньший или равный оператор (<=)
Оператор меньше или равно возвращает true, если левый операнд меньше или равен правильному операнду.
Синтаксис
x <= y
Примеры
3 <= 4 // true
Дополнительную информацию вы можете найти в MDN .
Сравнение нулевых и неопределенных
Когда мы сравниваем null и undefined, мы видим другое поведение. Позволяет проверять различные сценарии с помощью примеров
Пример - строгая проверка равенства (===)
console.log (null === undefined); // O / P - false
Otuput является ложным, и это правильно, потому что мы знаем, что «null» и «undefined» - разные типы.
Пример - проверка не строгого равенства (==)
console.log (null == undefined); // O / P: - true
Как? Это связано с тем, что существует специальное правило для «null» и «undefined». В связи с этим они равны в случае нестрогой проверки (==), но не равны никакому другому значению.
Если мы используем операторы сравнения, такие как <,>, <=,> = и т. Д., «Null» и «undefined» преобразуются в число, и в таких случаях «null» станет 0, а «undefined» будет NaN. Давайте рассмотрим некоторые из этих примеров.
Пример - сравните значение null с 0 (ноль)
console.log (null> 0); // O / P - false console.log (null> = 0); // O / P - true console.log (null == 0); // O / P - false
Странный? В соответствии с первым утверждением null не больше 0, а из второго оператора null является либо большим, либо равным 0. Таким образом, если мы математически мыслим и сравниваем оба утверждения, то получится, что значение null равно 0. Но , согласно третьему утверждению это неверно. Зачем?
Причина в том, что «сравнение» и «проверка равенства» работают по-разному. Для сравнения, «null / undefined» сначала преобразуется в число, поэтому в первых двух случаях «null» становится 0 и, следовательно, case1) (null> 0) -> false и case2) (null> = 0) -> true. Но при проверке равенства (==) «null / undefined» работает без какого-либо преобразования и, как объяснялось выше (специальное правило), проверка равенства «null / undefined» равна только друг другу и не равна никому другому. Следовательно (null == 0) -> false.
Пример - сравнение undefined с 0 (ноль)
console.log (undefined> 0); // O / P - false console.log (undefined> = 0); // O / P - false console.log (undefined == 0); // O / P - false
Здесь мы тестируем те же случаи, что и мы, для null, но результат опять же отличается. Зачем?
Причины следующие. В первых двух случаях мы сравниваем undefined с 0 и, как упоминалось выше, в сравнении undefined преобразуется в NaN. NaN - особое значение, которое всегда возвращает false по сравнению с любым числом, и поэтому мы получили false как результат в первых двух случаях. Для третьего утверждения причина та же, что и для «null». В проверке равенства «null / undefined» равны только друг другу и не равны ни одному другому. Следовательно (undefined == 0) -> false.