Операторы сравнения JavaScript: полное руководство

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

Базовый синтаксис операторов сравнения

Существует несколько типов операторов сравнения в JavaScript:

• Операторы равенства: ==, ===
• Операторы неравенства: !=, !==
• Операторы сравнения: >, <, >=, <=

Эти операторы позволяют сравнивать значения переменных и выражений в коде. Например:

let x = 5; let y = 10; x > y; // false x == 5; // true 

Операторы сравнения часто используются в условных конструкциях и циклах:

if (x > 10) { // код, который выполнится если х больше 10 } while (i < 10) { // код в цикле, пока i меньше 10 } 

Приоритет операторов сравнения выше, чем операторов присваивания, но ниже чем арифметических операторов. Поэтому выражения вида x = y > 5 будут вычисляться как (x = y) > 5.

Логические операторы для комбинирования условий

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

• Оператор И (&&) - возвращает true если оба выражения истинны
• Оператор ИЛИ (||) - возвращает true если хотя бы одно выражение истинно
• Отрицание с помощью оператора НЕ (!) - инвертирует булево значение

Эти операторы позволяют комбинировать простые условия в сложные логические выражения:

if (x > 5 && y < 10) { // и х больше 5, и у меньше 10 } if (x == 5 || y == 10) { // х равен 5 или у равен 10 } 

Приоритет у операторов такой же как в математике: сначала НЕ, потом И, потом ИЛИ. Например:

!x || y && z

будет интерпретироваться как (!x) || (y && z)

Особенности оператора равенства ==

Оператор равенства == в JavaScript обладает интересным поведением. В отличие от строгого равенства ===, обычный оператор равенства выполняет неявное преобразование типов перед сравнением.

Например, следующие выражения истинны:

"1" == 1 0 == false null == undefined [] == false 

Это связано с тем, что строка "1" преобразуется к числу 1, 0 и false к булевым значениям, а null и undefined к одному специальному значению.

Согласно спецификации JavaScript, оператор преобразует значения по следующим правилам перед сравнением:

Такое поведение иногда приводит к неочевидным результатам:

'' == 0 // false '0' == 0 // true [] == '' // true [] == 0 // true [1] == 1 // true ['1'] == 1 // true 

Поэтому при использовании оператора == надо быть очень внимательным и помнить о возможном неявном преобразовании.

Оператор равенства == удобен, но может дать неожиданные результаты из-за преобразования типов. Для строгого сравнения значений без преобразований лучше использовать оператор ===

Строгое равенство === и глубокое сравнение объектов

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

Например:

0 === false // false, разные типы undefined === null // false, строго не равны '1' === 1 // false, нет преобразования строки к числу [] === 0 // false, разные типы 

Также оператор === имеет специальное поведение для некоторых значений:

• Отрицательный ноль -0 считается равным положительному нулю +0
• Значение NaN не равно ничему, даже самому себе
• Значения null и undefined строго равны друг другу и ничему больше

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

Для глубокого сравнения объектов по значению (а не по ссылке) можно использовать функцию _.isEqual() из библиотеки lodash или написать собственную реализацию рекурсивного сравнения.

Поэтому рекомендуется по возможности избегать оператора == и использовать строгое сравнение === для предсказуемого поведения при сравнении значений и объектов в JavaScript.

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

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

Во-первых, это различие между целыми (integer) и дробными числами (float). Целые числа сравниваются как математические целые значения, а для дробных чисел используется стандарт сравнения чисел с плавающей точкой IEEE 754.

Во-вторых, положительный ноль +0 и отрицательный -0 считаются равными при сравнении == и неравными при строгом сравнении ===.

 1 / +Infinity // +0 1 / -Infinity // -0 +0 === -0 // true +0 == -0 // true +0 > -0 // false 

Также существует специальное числовое значение NaN (Not a Number), которое возникает в результате некорректных математических операций. Оно не равно никакому числу, даже самому себе:

NaN === NaN // false NaN == NaN // false 

Поэтому при сравнении чисел стоит явно проверять на NaN отдельным условием с помощью функции Number.isNaN() или глобальной isNaN().

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

Например, оператор ИЛИ || может выступать в качестве оператора условного присваивания значения по умолчанию:

let x = a || b; // присвоить х значение а, если а истинно, иначе значение b 

А оператор И && позволяет записывать условия в тернарном виде без использования тернарного оператора:

showMessage && alert(message); // сначала проверить условие showMessage, потом вызвать alert 

javascript: оператор равенства

Часто начинающие JavaScript-разработчики задают вопрос: "Какой оператор равенства лучше использовать - == или ===?"

Короткий ответ такой: для сравнения примитивных типов значений (числа, строки, булевы значения) лучше использовать оператор строгого равенства ===. А для специальных случаев приведения типов подходит ==.

Подробнее:

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

Поэтому старайтесь по умолчанию использовать оператор ===. А оператор равенства == применяйте только в редких случаях, когда требуется именно приведение типов.

javascript для начинающих: примеры

Рассмотрим несколько простых примеров использования операторов сравнения на JavaScript, полезных для начинающих.

Проверка, что переменная definied и не равна null:

let x = 5; if (x !== null && x !== undefined) { // переменная x определена и инициализирована } 

Проверка, что значение в диапазоне от 0 до 100:

let n = Math.random() * 100; if (n >= 0 && n <= 100) { // диапазон значений 0..100 } 

Цравнение строк без учета регистра:

let language = 'JavaScript'; if (language.toLowerCase() === 'javascript') { alert('Верно!'); } 

Сравнение через оператор switch в js javascript

В JavaScript оператор switch тоже может использоваться для сравнения значений.

Например:

let x = 2; switch(x) { case 1: // код для x == 1 break; case 2: // код для x == 2 break; default: // код по умолчанию } 

Здесь переменная x последовательно сравнивается со значениями вариантов case с помощью строгого равенства. Как только находится совпадение, выполняется соответствующий код.

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