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

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

На этой странице рассматриваются операторы отношения (<, >, <=, >=), различие между нестрогим (==) и строгим (===) равенством, влияние приведения типов на результат, а также крайние случаи с null, undefined, NaN и Object.is. Полный список операторов JavaScript см. в разделе Операторы JavaScript; для объединения сравнений см. Логические операторы.

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

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

• == (нестрогое равенство)
• === (строгое равенство)
• != (нестрогое неравенство)
• !== (строгое неравенство)
• > (больше)
• < (меньше)
• >= (больше или равно)
• <= (меньше или равно)

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

Нестрогое и строгое сравнение

Главное решение при сравнении значений — разрешать ли JavaScript преобразовывать типы автоматически. Нестрогое равенство (==) сначала приводит операнды к общему типу; строгое равенство (===) — нет.

Нестрогое равенство (==)

Пояснение: Здесь 1 и "1" кажутся разными (одно — число, другое — string), но == приводит оба значения к одному типу перед сравнением. Именно поэтому они считаются равными. Точные правила приведения описаны в разделе преобразование типов.

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

Пояснение: В этом случае 1 и "1" не считаются равными, поскольку === проверяет точное совпадение значения и типа. Здесь типы различаются.

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

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

Пояснение: 1 и "2" различаются. != также приводит типы перед сравнением, но поскольку значения после приведения оказываются разными, возвращается true.

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

Пояснение: Здесь !== обнаруживает различие значений, поскольку проверяет без приведения типа. Так как типы (число и string) различаются, возвращается true.

Операторы отношения

Пояснение: Эти примеры демонстрируют базовые сравнения:

• x < y истинно, потому что 5 меньше 10.
• x > y ложно, потому что 5 не больше 10.
• x <= 5 истинно, потому что 5 равно 5.
• y >= 11 ложно, потому что 10 не больше и не равно 11.

Замечание о сравнении строк: Когда < и > применяются к строкам, JavaScript сравнивает их лексикографически (по значению Unicode). Например, 'b' > 'a' равно true, но '10' < '2' тоже true, потому что сравнение происходит посимвольно.

Практическое применение операторов сравнения

Функции сортировки

Пояснение: Этот код сортирует числа по возрастанию. Функция sort сравнивает каждую пару чисел, располагая их от наименьшего к наибольшему.

Условная логика

Пояснение: Этот код проверяет, равно ли age 18 или больше. Если да — выводится "You are an adult." Если нет — "You are not an adult."

Странное поведение JavaScript

JavaScript иногда демонстрирует неожиданное поведение при сравнении нестандартных типов данных:

Пояснение:

• [] == 0: Пустой array считается равным нулю, потому что при преобразовании array в число получается 0.
• [] == ![]: Это выглядит очень странно, но вот что происходит: ![] преобразует array в boolean (который равен true, поскольку array являются истинными значениями), а затем инвертирует его до false. При сравнении [] с false оба приводятся к числам (0 и 0), поэтому они считаются «равными».

Рассмотрим больше примеров нестандартного поведения JavaScript в сравнениях и других операциях.

Сравнение массивов и объектов

Нестрогие проверки равенства в JavaScript могут давать неожиданные результаты при сравнении array и object из-за особенностей их преобразования и сопоставления.

Пояснение:

• [] == [] и {} == {}: Несмотря на то что обе стороны сравнения выглядят одинаково, они являются разными экземплярами в памяти. JavaScript проверяет равенство object и array по адресу в памяти, а не по содержимому.
• [] == ![]: Этот случай подчиняется тем же правилам приведения, что описаны в предыдущем разделе.

Null и undefined

Сравнение null и undefined при нестрогом равенстве тоже демонстрирует нестандартное поведение, однако у них есть некоторые общие черты в JavaScript.

Пояснение:

• null == undefined: JavaScript считает null и undefined нестрого равными — это исключение из правил нестрогого равенства.
• null === undefined: Поскольку типы разные, строгое равенство возвращает false.
• null == 0, null > 0 и null >= 0: При операторах отношения null приводится к 0, поэтому null >= 0 превращается в 0 >= 0, что равно true. Однако null == 0 и null > 0 остаются false, потому что null приводится к 0 только в контексте операторов отношения, но не при нестрогом равенстве.

Сравнение boolean и не-boolean значений

Сравнение значений типа boolean с не-boolean значениями при помощи нестрогого равенства может давать неинтуитивные результаты из-за приведения типов к числам.

Пояснение:

• true == 1 и false == 0: В JavaScript true преобразуется в 1, а false — в 0, поэтому эти сравнения возвращают true.
• true == 2: Поскольку true преобразуется в 1, оно не равно 2.
• true == "1" и false == "0": Строки преобразуются в числа, совпадающие с теми, в которые преобразуются true и false.

Сравнение NaN

NaN («Not a Number») — единственное значение в JavaScript, которое не равно самому себе. Любое сравнение с NaN, включая NaN === NaN, возвращает false. Используйте Number.isNaN() (или Object.is) для его проверки.

Пояснение: Поскольку NaN не равен ничему (включая самого себя), его невозможно обнаружить с помощью == или ===. Надёжным способом проверки является Number.isNaN().

Использование Object.is для сравнений

Для тех, кому нужна точная проверка, особенно в крайних случаях — таких как NaN и +0 против -0, — JavaScript предоставляет Object.is.

Пояснение:

• Object.is(NaN, NaN): В отличие от операторов равенства, Object.is корректно определяет два значения NaN как одинаковые.
• Object.is(+0, -0): Object.is различает положительный и отрицательный ноль, чего операторы равенства не делают.
• Object.is(false, false): Демонстрирует точное равенство без приведения типов, возвращая true для идентичных примитивных значений.

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

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

Сводка неожиданных результатов

Запомните эти неожиданные результаты. Большинство из них исчезают при использовании === и !==:

Выражение	Результат	Причина
0 == ''	true	Оба приводятся к числу 0
0 == '0'	true	String '0' приводится к 0
'' == '0'	false	Непустая и пустая строки, числовое приведение не происходит
null == undefined	true	Специальное правило нестрогого равенства
null >= 0	true	Операторы отношения приводят null к 0
null == 0	false	Нестрогое равенство не приводит null к 0
NaN === NaN	false	NaN никогда не равен ничему
[] == ![]	true	![] равно false, затем оба приводятся к 0
Object.is(NaN, NaN)	true	Object.is считает NaN равным самому себе
Object.is(+0, -0)	false	Object.is различает знаковые нули

Практическое правило: ==/=== и !=/!== сравнивают на (не)равенство, тогда как <, >, <=, >= являются операторами отношения и приводят операнды к числам (или сравнивают строки лексикографически). Операторы отношения имеют более высокий приоритет, чем операторы равенства, поэтому a < b == c вычисляется как (a < b) == c.

Лучшие практики

• Предпочитайте строгие операторы: Используйте === и !==, чтобы избежать ошибок из-за автоматического преобразования типов.
• Понятные условия: Делайте условия чёткими и понятными, особенно когда они включают сравнения.
• Проверяйте крайние случаи: Всегда проверяйте крайние случаи в сравнениях, особенно при обработке пользовательских данных или переменных типов данных.

Заключение

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

Практика