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

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

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

» » Сообщение:

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

Оператор Операция Ассоциативность О Типы значений
==
!=
===
!==
<, <=, >, >=
<, <=, >, >=
Проверка равенства
Проверка неравенства
Проверка строгого равенства (идентичности)
Проверка неидентичности
Сравнение числовых значений
Сравнение строковых значений
слева направо
слева направо
слева направо
слева направо
слева направо
слева направо
2
2
2
2
2
2
любое, любое → булево
любое, любое → булево
любое, любое → булево
любое, любое → булево
число, число → булево
строка, строка → булево

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

Простые типы сравниваются по значению.
Это значит, что два значения считаются одинаковыми, если они являются одним и тем же значением.

Ссылочные типы (объекты, массивы и функции) в JavaScript сравниваются по ссылке, а не по значению.
Это значит, что объект равен только сам себе и не равен никакому другому объекту, даже если они будут иметь одинаковые наборы свойств с одинаковыми значениями.

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

  • Если два значения имеют различные типы, они не идентичны.
  • Если оба значения являются null или undefined, они идентичны.
  • Если оба значения являются true или false, они идентичны.
  • Если одно или оба значения являются NaN, они не идентичны.
  • Если оба значения являются числами с одним и тем же значением, они идентичны. 0 и -0 идентичны.
  • Если оба значения являются строками и содержат одни и те же 16-битные последовательности, они идентичны. Если строки отличаются длиной или содержимым, они не идентичны. Если две строки выглядят одинаково, но содержат различные последовательности 16-битных значений, они не идентичны.
  • Если оба операнда ссылаются на один и тот же объект, массив или функцию, то они идентичны. Если они ссылаются на различные объекты (массивы или функции) они не идентичны.
script Код: Выделить всё Развернуть
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.
  • Если объект сравнивается с числом или строкой, оператор преобразует его к примитивному значению. Если преобразовать объект не удаётся - генерируется ошибка выполнения.
script Код: Выделить всё Развернуть
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 в противном случае.

script Код: Выделить всё Развернуть
4 != 3                  // true
"my car" != "My car"    // true
"4" != 4                // false
"4" !== 4               // true
NaN != NaN              // true
{x: 2} !== {x: 2}       // true

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

script Код: Выделить всё Развернуть
var x = 5 < 6;
var y = 5 < 4;
document.write("x: " + x + "<br>");
document.write("y: " + y);

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

script Код: Выделить всё Развернуть
var x = 5 > 3;
var y = 5 > 6;
document.write("x: " + x + "<br>");
document.write("y: " + y);

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

script Код: Выделить всё Развернуть
var x = 5 <= 5;
var y = 5 <= 4;
document.write("x: " + x + "<br>");
document.write("y: " + y);

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

script Код: Выделить всё Развернуть
var x = 5 >= 3;
var y = 5 >= 6;
document.write("x: " + x + "<br>");
document.write("y: " + y);
При сравнении строк, буквы в нижнем регистре всегда "больше", чем буквы в верхнем регистре.
Цифра находящаяся в строке, при сравнении всегда "меньше" буквенного символа в любом регистре.

Обычно, буква расположенная в алфавитном порядке раньше "меньше", чем буква расположенная в алфавитном порядке после неё:

script Код: Выделить всё Развернуть
"a" > "Z"  // true
"9" < "a"  // true
"a" < "b"  // true

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

script Код: Выделить всё Развернуть
"строка" > "стрОка"  // true

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

Оператор Операция Ассоциативность О Типы значений
&&
||
!
Логическое И
Логическое ИЛИ
Логическое НЕ (инверсия)
слева направо
слева направо
справа налево
2
2
1
любое, любое→любое
любое, любое→любое
любое→булево

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

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

script Код: Выделить всё Развернуть
var y = 1;
var x = 0 && ++y;  // ++y не будет вычисляться
document.write("x: " + x + "<br>");
document.write("y: " + y);

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

script Код: Выделить всё Развернуть
var x = 1 && 2;
var y = 1 && 0;
document.write(x + "<br>");  // 2
document.write(y);           // 0

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

script Код: Выделить всё Развернуть
var x = y = 1;
if (x == 1 && y == 1)
  alert("Привет!");
else
  alert("Ещё увидимся!");

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

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

script Код: Выделить всё Развернуть
var y = 1;
var x = 1 || ++y;  // ++y не будет вычисляться
document.write("x: " + x + "<br>");
document.write("y: " + y);

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

script Код: Выделить всё Развернуть
var x = 0 || 2;
var y = null || 0;
document.write(x + "<br>");  // 2
document.write(y);           // 0

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

script Код: Выделить всё Развернуть
var max = x || y || 3;

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

script Код: Выделить всё Развернуть
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:

script Код: Выделить всё Развернуть
var x = 1, y;
document.write(!x + "<br>");  // false
document.write(!y);           // true

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

script Код: Выделить всё Развернуть
var x = 1, y;
document.write(!!x + "<br>");  // true
document.write(!!y);           // false

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

script Код: Выделить всё Развернуть
var p = 1, q = 2;
document.write(!(p > q));  // true
операторы, равенство, идентичность, неравенство, неидентичность, логические операторы, инверсия



Похожие темыКомментарии ПросмотрыПоследнее сообщение
0463JavaScript методы alert, document.w...
Сообщение от: Admin
078Вывод страницы на печать, версия дл...
Сообщение от: likbezz
0560Замена прямых кавычек на “ёлочки”. ...
Сообщение от: Admin
0929Обход child nodes - потомков элемен...
Сообщение от: Admin
02350Дженнифер Нидерст Роббинс. HTML5, C...
Сообщение от: Admin