Операторы сравнения и логические

В этой главе:

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

  • Логические операторы

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

Оператор

Операция

A

N

Типы значений

==

!=

===

!==

<, <=, >, >=

<, <=, >, >=

Проверка равенства (эквивалентности)

Проверка неравенства

Проверка строгого равенства (идентичности)

Проверка неидентичности

Сравнение числовых значений

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

L

L

L

L

L

L

2

2

2

2

2

2

любое, любое→булево

любое, любое→булево

любое, любое→булево

любое, любое→булево

число, число→булево

строка, строка→булево

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

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

Оператор идентичности производит сравнение значений операндов без преобразования типов руководствуясь следующими правилами:

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

  • Если оба значения являются null или undefined, они идентичны.

  • Если оба значения являются true или false, они идентичны.

  • Если одно или оба значения являются NaN, они не идентичны.

  • Если оба значения являются числами с одним и тем же значением, они идентичны. 0 и -0 идентичны.

  • Если оба значения являются строками и содержат одни и те же 16-битные последовательности, они идентичны. Если строки отличаются длиной или содержимым, они не идентичны. Если две строки выглядят одинаково, но содержат различные последовательности 16-битных значений, они не идентичны.

  • Если оба значения ссылаются на один и тот же объект, массив или функцию, то они идентичны. Если они ссылаются на различные объекты (массивы или функции) они не идентичны.

1
2
3
4
5
6
7
8
9
10
11
12
13
var x = {x: 2};
var y = x;
'7' === 7               // false - разные типы данных
null === null           // true
undefined === undefined // true
true === true           // true
false === false         // true
NaN === NaN             // false
(2 + 2) === 4           // true - два одинаковых числа
0 === -0                // true
'строка' === 'Строка'   // false - первые символы строки разные
{x: 2} === {x: 2}       // false
x === y                 // true - ссылаются на один объект

Оператор эквивалентности использует менее строгие правила, чем оператор идентичности. Если два значения имеют одинаковый тип, они проверяются на идентичность как было описано выше. Если значения операндов имеют разные типы, оператор == выполняет неявное преобразование типов и затем пытается выполнить сравнение:

  • Если одно значение null, а другое undefined, то они равны.

  • Если одно значение является числом, а другое - строкой, то строка преобразуется в число и выполняется сравнение с преобразованным значением.

  • Если один из операндов имеет значение true, оно преобразуется в число 1, если значение false - в число 0.

  • Если объект сравнивается с числом или строкой, он преобразуется используя методы valueOf или toString к примитивному значению - строке или числу. Если преобразовать объект не удаётся - генерируется ошибка выполнения.

1
2
3
4
5
6
7
null == undefined       // true
"123" == 123            // true
true == "1"             // true
false == 0              // true
(4+2) == 6              // true
"my car" == "my car"    // true
4 == 5                  // false

Операторы неравенства (!=) и неидентичности (!==) выполняют проверки, в точности противоположные операторам == и ===. Например, оператор неравенства != возвращает false, если два значения равны друг другу в том смысле, в каком они считаются равными оператором ==, и true впротивном случае.

1
2
3
4
5
6
4 != 3                  // true
"my car" != "My car"    // true
"4" != 4                // false
"4" !== 4               // true
NaN != NaN              // true
{x: 2} !== {x: 2}       // true

Оператор меньше (<) возвращает true, если значение левого операнда меньше, чем значение правого операнда, в противном случае он возвращает false:

1
2
3
4
var x = 5 < 6;
var y = 5 < 4;
document.write("x: " + x + "<br>");
document.write("y: " + y);

Оператор больше (>) возвращает true, если значение левого операнда больше, чем значение правого операнда, в противном случае он возвращает false:

1
2
3
4
var x = 5 > 3;
var y = 5 > 6;
document.write("x: " + x + "<br>");
document.write("y: " + y);

Оператор меньше или равно (<=) возвращает true, если значение левого операнда меньше или равно значению правого операнда, в противном случае он возвращает false:

1
2
3
4
var x = 5 <= 5;
var y = 5 <= 4;
document.write("x: " + x + "<br>");
document.write("y: " + y);

Оператор больше или равно (>=) возвращает true, если значение левого операнда больше или равно значению правого операнда, в противном случае он возвращает false:

1
2
3
4
var x = 5 >= 3;
var y = 5 >= 6;
document.write("x: " + x + "<br>");
document.write("y: " + y);

При сравнении строк, буквы в нижнем регистре всегда больше, чем буквы в верхнем регистре. Цифра находящаяся в строке, при сравнении всегда меньше буквенного символа в любом регистре.

1
2
"a" > "Z"  // true
"9" < "a"  // true

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

1
"строка" > "стрОка"  // true

Логические операторы

Оператор

Операция

A

N

Типы значений

&&

||

!

Логическое И

Логическое ИЛИ

Логическое НЕ (инверсия)

L

L

R

2

2

1

любое, любое→любое

любое, любое→любое

любое→булево

Логические операторы, как правило, используются с булевыми значениями и возвращают булево значение. Однако, в JavaScript операторы && и || возвращают не булево значение, а значение одного из операндов.

Оператор логическое И (&&) выполняет операцию И над двумя операндами. Его работа начинается с вычисления значения левого операнда. Если левый операнд имеет значение, которое может быть преобразовано в false - возвращается значение левого операнда, при этом значение правого операнда вычисляться не будет:

1
2
3
4
var y = 1;
var x = 0 && ++y;  // ++y не будет вычисляться
document.write("x: " + x + "<br>");
document.write("y: " + y);

Если левый операнд имеет значение, которое может быть преобразовано в true, оператор && вычисляет значение правого операнда, и возвращает значение правого операнда.

1
2
3
4
var x = 1 && 2;
var y = 1 && 0;
document.write(x + "<br>");  // 2
document.write(y);           // 0

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

1
2
3
4
5
var x = y = 1;
if (x == 1 && y == 1)
  alert("Привет!");
else
  alert("Ещё увидимся!");

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

Оператор логическое ИЛИ (||) выполняет операцию ИЛИ над двумя операндами. Его работа начинается с вычисления значения левого операнда. Если левый операнд имеет значение, которое может быть преобразовано в true - возвращается значение левого операнда, при этом значение правого операнда вычисляться не будет:

1
2
3
4
var y = 1;
var x = 1 || ++y;  // ++y не будет вычисляться
document.write("x: " + x + "<br>");
document.write("y: " + y);

Если левый операнд имеет значение, которое может быть преобразовано в false, оператор || вычисляет значение правого операнда, и возвращает значение правого операнда.

1
2
3
4
var x = 0 || 2;
var y = null || 0;
document.write(x + "<br>");  // 2
document.write(y);           // 0

Характерное использование этого оператора заключается в том, что он выбирает первое "истинное" значение из предложенного множества альтернатив:

1
var max = x || y || 3;

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

1
2
3
4
5
var a = 3, b = 0;
if(a == 3 || b > 4)
  alert("Привет!");
else
  alert("Ещё увидимся!");

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

Хотя операторы && и || могут быть использованы для возвращения небулевых значений, они всё же логические, так как возвращаемые значения могут быть приведены к булевому типу.

Оператор логическое НЕ (!) является унарным оператором. Он используется для инверсии логического значения своего операнда. Перед тем, как инвертировать логическое значение своего операнда, оператор НЕ преобразует (если необходимо) текущее значение своего операнда в булево значение. Например, если переменная "x" имеет значение true или любое другое значение, которое может быть преобразовано в true, то выражение !x вернёт значение false. Если переменная "x" имеет значение false, то выражение !x вернёт значение true:

1
2
3
var x = 1, y;
document.write(!x + "<br>");  // false
document.write(!y);           // true

Так как оператор НЕ преобразует текущее значение своего операнда в булево значение, а затем инвертирует его в противоположное, то применив его дважды к операнду, можно преобразовать любое значение в его логический эквивалент:

1
2
3
var x = 1, y;
document.write(!!x + "<br>");  // true
document.write(!!y);           // false

Оператор НЕ можно так же использовать для инверсии значения возвращаемого сложным выражением, например:

1

2

var p = 1, q = 2;
document.write(!(p > q));  // true