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

В JavaScript имеются как строгие сравнения, так и сравнения с преобразованием типа операндов. Строгие сравнения (к примеру, ===) истинны только в том случае, если типы сравниваемых значений являются одинаковыми (к примеру: string-string, number-number). Однако, чаще используются сравнения с преобразованием типов (к примеру, ==). Такой тип сравнения, перед тем как непосредственно выполнить сравнение, приводит операнды к одному типу. В случае же, абстрактного реляционного сравнения, операнды сперва преобразуются в примитивы, затем приводятся к одному типу, и только после этого сравниваются.

Строки сравниваются на основе стандартного лексикографического упорядочения, используя значения Unicode.

Особенности сравнений:

• Две строки строго равны только в том случае, если они имеют одинаковую длину, и те же символы в одинаковой последовательности и соответствующих позициях.
• Два числа строго равны в том случае, если они численно равны. NaN не равно ничему, в том числе и NaN. Нули с положительным и отрицательным знаком равны.
• Два логических значения (boolean) равны только в том случае, если они оба истинны (true) или ложны (false).
• Два различных объекта никогда не равны как в строгих, так и в абстрактных сравнениях.
• Сравнение объекта истинно лишь в том случае, если оба операнда ссылаются на один и тот же объект в памяти.
• Виды null и undefined равны себе как в строгом сравнении, так и в абстрактном.

При использовании сравнения с преобразованием типов, следует быть крайне осторожным, так как это может привести к непредвиденным проблемам, связанным с особенностями конвертации различных типов (см. параграф "Использование операторов равенства").

Операторы равенства

Равно (==)

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

Синтаксис

x == y

Примеры

 1  ==  1      // истина
"1" ==  1      // истина
 1  == '1'     // истина
 3  ==  5      // ложь
 0  == false   // истина
"foo" == "bar" // ложь

Не равно (!=)

Оператор не равно возвращает true в том случае, если операнды не равны.Он аналогичен оператору равенства, перед сравнением приводит операнды к одному типу. В случае если оба операнда являются объектами,  JavaScript сравнивает внутренние ссылки, которые не равны в том случае, если относятся к разным объектам в памяти.

Синтаксис

x != y

Примеры

1 !=   2       // истина
1 !=  "1"      // ложь
1 !=  '1'      // ложь
1 !=  true     // ложь
0 !=  false    // ложь
"foo" != "bar" // истина

Строго равно (===)

Оператор возвращает истинну в том случае, если операнды строго равны (см. выше). В отличие от оператора равно, данный оператор не приводит операнды к одному типу.

Синтаксис

x === y

Примеры

3 === 3   // истина
3 === '3' // ложь
'foo' === 'foo' // истина

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

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

Синтаксис

x !== y

Примеры

3 !== '3' // истина
4 !== 3   // истина

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

Больше (>)

Оператор больше возвращает истину в том случае, если значение левого операнда больше, чем правого.

Синтаксис

x > y

Примеры

4 > 3 // истина
1 > 5 // ложь

Больше или равно (>=)

Оператор больше или равно, возвращает истину в том случае, если значение операнда слева больше или равно значению операнда справа.

Синтаксис

 x >= y

Примеры

4 >= 3 // истина
3 >= 3 // истина

Меньше(<)

Оператор меньше, возвращает истину в том случае, если значение операнда слева меньше, чем значение операнда справа.

Синтаксис

 x < y

Примеры

3 < 4 // истина
5 < 2 // ложь

Меньше или равно (<=)

Оператор меньше или равно, возвращает истину в том случае, если значение операнда слева меньше, или равно значению операнда справа.

Синтаксис

 x <= y

Примеры

3 <= 4 // истина
3 <= 3 // истина

Использование операторов равенства

Стандартные операции равенства с преобразованием типов (== и !=) используют Абстрактный Алгоритм Эквивалентного Сравнения для сравнения двух операндов. Если у операндов различные типы, то JavaScript пытается привести их к одному типу, перед тем как сравнивать их. К примеру, в выражении 5 == '5', строка справа конвертируется в число, и только потом сравнивается.

Операторы строгого равентсва (=== и !==) используют Строгий Алгоритм Эквивалентного Сравнения, и предназначены для сравнения операндов одного типа. Если операнды имеют разные типы, то результат операции сравнения всегда будет ложью. К примеру, выражение 5 !== '5' будет истинным.

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

Когда происходит преобразование типов (т.е в случаях использования нестрогого сравнения), JavaScript преобразует типы String, Number, Boolean и Object, следующим образом:

• При сравнении числа (Number) и строки (String), JavaScript пытается преобразовать числовой литерал строки в число. Затем полученное число округляется до ближайшего возможного значения типа Number.
• Если один из операндов является логическим (Boolean), то он преобразуется в значение типа (Number). Если значение логического операнда равняется истине (true), то значение этого операнда преобразуется в 1. Иначе - в 0 (ложь / false).
• Если объект сравнивается с числом или строкой, JavaScript пытается получить значение по умолчанию для данного объекта. Полученное значение преобразуется в примитив, посредством методов valueOf() и toString(). Если преобразовать объект не удается, генерируется ошибка времени выполнения.
• Обратите внимание на то, что объект преобразуется в примитив, если, и только если, второй операнд является примитивом. В ином случае, операнды сравниваются как объекты, соответственно, операция сравнения вернет истину в том случае, если внутренние ссылки обоих объектов ссылаются на один и тот же объект в памяти.

// Истина, так как оба операнда имеют тип String
'foo' === 'foo'

var a = new String('foo');
var b = new String('foo');

// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
a == b 

// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
a === b 

// Истина, так как объект a (String) будет преобразован в строку 'foo', перед сопоставлением
a == 'foo' 

Спецификации

Поддержка браузерами

Смотрите также

• Object.is()
• Операторы сравнения и одинаковость