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

В 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 имеют тип Object, а не String. Такие объекты используются редко, так что следующий код может вас сильно удивить.
// Истина, так как оба операнда имеют тип String
'foo' === 'foo'

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

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

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

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

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

Спецификация Статус Комментарий
ECMAScript 1st Edition (ECMA-262) Стандарт Появление в спецификации. Выполняется в JavaScript 1.0
ECMAScript 3rd Edition (ECMA-262) Стандарт Добавлены операторы === и !==. Выполняется в JavaScript 1.3
ECMAScript 5.1 (ECMA-262) Стандарт Определено в нескольких секциях спецификации: Относительные операторыОператоры равенства
ECMAScript 2015 (6th Edition, ECMA-262) Стандарт Определено в нескольких секциях спецификации: Относительные операторыОператоры равенства
ECMAScript 2017 Draft (ECMA-262) Черновик Определено в нескольких секциях спецификации: Относительные операторыОператоры равенства

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

  Chrome Firefox (Gecko) Internet Explorer Opera Safari
Базовая поддержка (Да) (Да) (Да) (Да)

(Да)

  Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Базовая поддержка (Да) (Да) (Да) (Да) (Да) (Да)


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

Метки документа и участники

 Внесли вклад в эту страницу: BychekRU, nbaksalyar, CatWhoCode
 Обновлялась последний раз: BychekRU,