Операторы Сравнения

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

Оператор больше (a > b) возвращает true, если левый операнд больше правого.

Синтаксис:

a > b

Пример использования оператора больше:

Javascript Greater than operator

console.log(7 > 4); // true

Оператор меньше (a < b) возвращает true, если левый операнд меньше правого.

Синтаксис:

a < b

Пример использования оператора меньше:

Javascript less than operator

console.log(4 < 7); // true

Оператор больше или равно (a >= b) возвращает true, если левый операнд больше или равен правому.

Синтаксис:

a >= b

Пример использования оператора больше или равно:

jJvascript Greater than or equal operator

console.log(7 >= 4); // true console.log(4 >= 4); // true

Оператор меньше или равно (a <= b) возвращает true, если левый операнд меньше или равен правому.

Синтаксис:

a <= b

Пример использования оператора меньше или равно:

Javascript less than or equal operator

console.log(4 <= 7); // true console.log(4 <= 4); // true

Оператор равенства (a == b) преобразует операнды, если они не одного типа, затем применяет строгое сравнение. Если оба операнда являются объектами, JavaScript сравнивает внутренние ссылки, которые равны, когда операнды ссылаются на один и тот же объект в памяти.

Синтаксис:

a == b

Пример использования оператора равенства:

Javascript equality operator

console.log(1 == 1); // true console.log("2" == 2); // true console.log(3 == '3'); // true console.log(0 == false); // true console.log(0 == null); // false console.log(0 == undefined); // false console.log(null == undefined); // true

Если операнды не равны, то оператор неравенства (!=) возвращает true. Когда два операнда не одного типа, JavaScript пытается преобразовать операнды к подходящему типу для сравнения.

Если оба операнда являются объектами, JavaScript сравнивает ссылки, которые не равны, когда операнды ссылаются на разные объекты в памяти.

Синтаксис:

a != b

Пример использования оператора неравенства:

Javascript inequality operator

console.log(1 != 2) ; // true console.log(2 != "2"); // false console.log(3 != '3' ); // false console.log(1 != true); // false console.log(0 != false); // false

Boolean является результатом

Сравнение, как и все другие операции, возвращает значение. В этом случае это boolean.

true - это «да», «верно» или «правда»;
false - это «нет», «не так» или «не правда».

Comparison operator in javascript

console.log( 3 > 1 ); // true (correct) console.log( 3 == 1 ); // false (wrong) console.log( 3 != 1 ); // true (correct)

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

Comparison operator javascript

let result = 7 > 4; // the result of the comparison console.log ( result ); // true

Сравнение строк

JavaScript использует «словарный» или «лексикографический» порядок для сравнения строк. Другими словами, строки сравниваются посимвольно.

Пример сравнения строк:

The string comparison in javascript

console.log( 'Z' > 'A' ); // true console.log( 'Want' > 'Walk' ); // true console.log( 'Too' > 'To' ); // true

В примерах сравнение 'Z' > 'A' дает результат на первом шаге, в то время как строки "Want" и "Walk" сравниваются посимвольно:

W такое же как W.
a такое же как a.
n больше чем l.

Сравнение разных типов

Для сравнения значений разных типов, JavaScript преобразует значения в числа.

The comparison of different types in javascript

console.log( '3' > 1 ); // true, string '3' becomes a number 3 console.log( '02' == 2 ); // true, string '02' becomes a number 2

Для булевых значений, true становится 1, false становится 0.

Comparison of different types in javascript

console.log( true == 1 ); // true console.log( false == 0 ); // true

Строгое равенство

Обычная проверка равенства == имеет проблему: она не может отличить 0 от false:

The regular equality == in javascript

console.log( 0 == false ); // true

Мы сталкиваемся с той же проблемой при пустой строке:

The regular equality == in javascript

console.log( '' == false ); // true

Сравнение с null и undefined

Неинтуитивное поведение проявляется, когда null или undefined сравниваются с другими значениями. Для строгой проверки равенства ===. Эти значения различаются, так как каждое из них является разным типом.

The strict equality === in javascript

console.log( null === undefined ); // false

Для нестрогой проверки ==

Эти два значения образуют «сладкую пару», то есть они равны друг другу.

The regular equality == in javascript

console.log( null == undefined ); // true

Разница между == и ===

JavaScript имеет два визуально похожих, но очень разных способа проверки равенства:

== (Оператор двойного равенства): оператор равенства или абстрактного сравнения

=== (Оператор тройного равенства): оператор тождественности или строгого сравнения

Вот различия между == и ===:

перед показом сравнения == преобразует значения переменных одного типа;
=== не производит никакого преобразования типов и возвращает true только в том случае, если значения и типы идентичны для двух сравниваемых переменных.

== and === equality in javascript

var val1 = 13; var val2 = 13; console.log(val1 == val2); // true console.log(val1 === val2); // also true

Для математических и других сравнений < > <= >=

Null/undefined преобразуются в числа, здесь null становится 0, undefined становится NaN.

Мы представляем вам некоторые забавные вещи, которые происходят, когда мы применяем эти правила. А также, как не попасть в ловушку с ними.

Странный результат: null против 0

Пример сравнения null с нулем:

Compare null with a zero in javascript

console.log( null > 0 ); // (1) false console.log( null == 0 ); // (2) false console.log( null >= 0 ); // (3) true

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

Основная причина в том, что проверка на равенство == и сравнения > < >= <= работают по-разному: сравнения преобразуют null в число, рассматривая его как 0. Поэтому (3) null >= 0 истинно, а (1) null > 0 ложно.

Но с другой стороны, проверка на равенство == для undefined и null определена без каких-либо преобразований. Они равны друг другу и не равны ничему другому, поэтому (2) null == 0 ложно.

Несопоставимый undefined

Мы не можем сравнивать значение undefined с другими значениями:

Compare the value with undefined in javascript

console.log( undefined > 0 ); // false (1) console.log( undefined < 0 ); // false (2) console.log( undefined == 0 ); // false (3)

Причины, по которым мы получаем эти результаты, следующие:

Сравнения (1) и (2) возвращают false, так как undefined преобразуется в NaN, что является особым числовым значением, которое возвращает false для всех сравнений.
Проверка на равенство (3) возвращает false, так как здесь undefined равно только null, undefined и ни одному другому значению.

Время Викторины: Проверьте Свои Навыки!

отовы проверить свои знания? Погрузитесь в наши интерактивные викторины для более глубокого понимания и веселого способа закрепить знания.