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

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

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

let r1 = 20 > 10; // true 
let r2 = 20 < 10; // false 
let r3 = 10 == 10; // true

И принимает два значения. Если типы значений несопоставимы, оператор преобразует их в значения сопоставимых типов в соответствии с определенными правилами.

Сравнение чисел

Если значения являются числами, операторы сравнения выполняют числовое сравнение. Например:

let a = 10, b = 20; 
console.log(a >= b); // false 
console.log(a == 10); // true

Этот пример прост. Переменная a равна 10, b равна 20. Выражение a >= b expression возвращает false, а выражение a == 10 expression возвращает true.

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

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

let name1 = 'alice', name2 = 'bob'; 
let result = name1 < name2; 
console.log(result); // true 
console.log(name1 == 'alice'); // true

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

let f1 = 'apple', f2 = 'Banana'; 
let result = f2 < f1; 
console.log(result); // true

В этом примере f2 меньше, чем f1, потому что буква B имеет код символа 66, а буква a имеет код символа 97.

Чтобы исправить это, вам необходимо:

• Сначала преобразуйте строки в общий формат, либо строчные, либо прописные.
• Во-вторых, сравните преобразованные значения

Пример:

let f1 = 'apple', f2 = 'Banana'; 
let result = f2.toLowerCase() < f1.toLowerCase(); 
console.log(result); // false

Обратите внимание, что toLowerCase() — это метод объекта String, который преобразует строку в нижний регистр.

Сравнение числа со значением другого типа

Если одно значение является числом, а другое — нет, оператор сравнения преобразует нечисловое значение в число и сравнит их численно. Например:

console.log(10 < '20'); // true

В этом примере преобразуем строку '20' в число 20 и сравнивает с числом 10.

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

В этом примере оператор сравнения преобразует строку '10' в число 10 и сравнивает их численно.

Как сравнить объект с не-объектом

Если значение является объектом, вызывается метод valueOf() этого объекта, чтобы вернуть значение для сравнения. Если у объекта нет метода valueOf(), вместо него вызывается метод toString(). Например:

let apple = { valueOf: function() { return 10; }, }; 
let orange = { toString: function() { return '20'; }, }; 
console.log(apple > 10); // false 
console.log(orange == 20); // true

В этом первом сравнении объект apple имеет метод valueOf(), который возвращает 10. Поэтому оператор использует для сравнения число 10.

Во втором, сначала вызывает метод valueOf(). Однако у orange объекта нет метода valueOf(). Поэтому JavaScript вызывает метод toString(), чтобы получить возвращаемое значение 20 для сравнения.

Логическое значение с другим значением

Если значение является логическим значением, JavaScript преобразует его в число и сравнивает преобразованное значение с другим значением; true преобразуется в 1, а false преобразуется в 0. Например:

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

В дополнение к приведенным выше правилам, операторы равенства ( == ) и не равенства ( != ) также имеют следующие правила.

null и undefined

В JavaScript null равно undefined. Это означает, что следующее выражение возвращает true.

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

NaN с другими значениями

Если какое-либо значение равно NaN, то оператор равенства( == ) возвращает false.

console.log(NaN == 1); // false

Даже:

console.log(NaN == NaN); // false

Оператор не-равно ( != ) возвращает true при сравнении NaN с другим значением:

console.log(NaN != 1); // true

А также:

console.log(NaN != NaN); // true

Строгое равенство ( === ) и не строгое равенство ( !== )

Помимо приведенных выше операторов, JavaScript предоставляет операторы строгого равенства ( === ) и не строгого равенства ( !== ).

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

console.log("10" == 10); // true
console.log("10" === 10); // false

В первом случае, поскольку мы используем оператор равенства, JavaScript преобразует строку в число и выполняет сравнение.

Однако во втором действии мы используем оператор строгого равенства ( === ), JavaScript не преобразует строку, поэтому результат будет false.