Javascript больше или равно

Многие операторы сравнения известны нам из математики:

  • Больше/меньше: a > b , a .
  • Больше/меньше или равно: a >= b , a .
  • Равно: a == b . Обратите внимание, для сравнения используется двойной знак равенства = . Один знак равенства a = b означал бы присваивание.
  • Не равно. В математике обозначается символом ≠ . В JavaScript записывается как знак равенства с предшествующим ему восклицательным знаком: a != b .

Результат сравнения имеет логический тип

Операторы сравнения, как и другие операторы, возвращают значение. Это значение имеет логический тип.

  • true – означает «да», «верно», «истина».
  • false – означает «нет», «неверно», «ложь».

Результат сравнения можно присвоить переменной, как и любое значение:

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

Чтобы определить, что одна строка больше другой, JavaScript использует «алфавитный» или «лексикографический» порядок.

Другими словами, строки сравниваются посимвольно.

Алгоритм сравнения двух строк довольно прост:

  1. Сначала сравниваются первые символы строк.
  2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй.
  3. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
  4. Сравнение продолжается, пока не закончится одна из строк.
  5. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.

В примерах выше сравнение ‘Я’ > ‘А’ завершится на первом шаге, тогда как строки "Кот" и "Код" будут сравниваться посимвольно:

  1. К равна К .
  2. о равна о .
  3. т больше чем д . На этом сравнение заканчивается. Первая строка больше.

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

Например, в JavaScript имеет значение регистр символов. Заглавная буква "A" не равна строчной "a" . Какая же из них больше? Строчная "a" . Почему? Потому что строчные буквы имеют больший код во внутренней таблице кодирования, которую использует JavaScript (Unicode). Мы ещё поговорим о внутреннем представлении строк и его влиянии в главе Строки.

Сравнение разных типов

При сравнении значений разных типов JavaScript приводит каждое из них к числу.

Логическое значение true становится 1 , а false – 0 .

Возможна следующая ситуация:

  • Два значения равны.
  • Одно из них true как логическое значение, другое – false .

С точки зрения JavaScript, результат ожидаем. Равенство преобразует значения, используя числовое преобразование, поэтому "0" становится 0 . В то время как явное преобразование с помощью Boolean использует другой набор правил.

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

Использование обычного сравнения == может вызывать проблемы. Например, оно не отличает 0 от false :

Та же проблема с пустой строкой:

Это происходит из-за того, что операнды разных типов преобразуются оператором == к числу. В итоге, и пустая строка, и false становятся нулём.

Читайте также:  Типовые и нетиповые конфигурации 1с

Как же тогда отличать 0 от false ?

Оператор строгого равенства === проверяет равенство без приведения типов.

Другими словами, если a и b имеют разные типы, то проверка a === b немедленно возвращает false без попытки их преобразования.

Ещё есть оператор строгого неравенства !== , аналогичный != .

Оператор строгого равенства дольше писать, но он делает код более очевидным и оставляет меньше мест для ошибок.

Сравнение с null и undefined

Поведение null и undefined при сравнении с другими значениями – особое:

При строгом равенстве ===

Эти значения различны, так как различны их типы.

Эти значения равны друг другу и не равны никаким другим значениям. Это специальное правило языка.

Значения null/undefined преобразуются к числам: null становится 0 , а undefined – NaN .

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

Странный результат сравнения null и 0

Сравним null с нулём:

С точки зрения математики это странно. Результат последнего сравнения говорит о том, что " null больше или равно нулю", тогда результат одного из сравнений выше должен быть true , но они оба ложны.

Причина в том, что нестрогое равенство и сравнения > = работают по-разному. Сравнения преобразуют null в число, рассматривая его как 0 . Поэтому выражение (3) null >= 0 истинно, а null > 0 ложно.

С другой стороны, для нестрогого равенства == значений undefined и null действует особое правило: эти значения ни к чему не приводятся, они равны друг другу и не равны ничему другому. Поэтому (2) null == 0 ложно.

Несравнимое значение undefined

Значение undefined несравнимо с другими значениями:

Почему же сравнение undefined с нулём всегда ложно?

На это есть следующие причины:

  • Сравнения (1) и (2) возвращают false , потому что undefined преобразуется в NaN , а NaN – это специальное числовое значение, которое возвращает false при любых сравнениях.
  • Нестрогое равенство (3) возвращает false , потому что undefined равно только null и ничему больше.

Как избежать проблем

Зачем мы рассмотрели все эти примеры? Должны ли мы постоянно помнить обо всех этих особенностях? Не обязательно. Со временем все они станут вам знакомы, но можно избежать проблем, если следовать простому правилу.

Просто относитесь к любому сравнению с undefined/null , кроме строгого равенства === , с осторожностью.

Не используйте сравнения >= > с переменными, которые могут принимать значения null/undefined , если вы не уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.

Оператор Тип оператора А О Типы значений
… …
… >= …
… == …
… != …
… === …
… !== …
Меньше чем
Меньше или равно
Больше чем
Больше или равно
Равно
Не равно
Строго равно
Строго не равно
слева направо
слева направо
слева направо
слева направо
слева направо
слева направо
слева направо
слева направо
2
2
2
2
2
2
2
2
число, число → булево
число, число → булево
число, число → булево
число, число → булево
любое, любое → булево
любое, любое → булево
любое, любое → булево
любое, любое → булево
Читайте также:  После установки виндовс 10 не загружается система

Оператор === ( строго равно ) производит сравнение значений операндов без преобразования типов.

Значения считаются равными:

  • Если оба значения являются null или undefined .
  • Если оба значения являются true или false .
  • Если оба значения являются числами с одним и тем набором цифр ( 0 и -0 равны).
  • Если оба значения являются строками и они содержат одни и те же 16-битные последовательности.
  • Если оба операнда ссылаются на один и тот же объект, массив или функцию.

Значения считаются не равными:

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

Если значения операндов равны оператор === возвращает true , если не равны – false :

Оператор == ( равно ) выполняет сравнение значений. Если значения операндов имеют разные типы, оператор выполняет неявное преобразование типов и затем пытается выполнить сравнение.

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

  • Если одно значение является числом, а другое – строкой, то строка преобразуется в число.
  • Если один из операндов имеет значение true , оно преобразуется в число 1 , если значение false – в число 0 .
  • Если значение ссылочного типа сравнивается с числом или строкой, оператор попытается преобразовать его к примитивному значению.

Значения считаются равными:

  • Если одно значение null , а другое undefined .
  • Если оба значения являются null или undefined .
  • Если оба значения являются true или false .
  • Если оба значения являются числами с одним и тем набором цифр ( 0 и -0 равны).
  • Если оба значения являются строками и они содержат одни и те же 16-битные последовательности.
  • Если оба операнда ссылаются на один и тот же объект, массив или функцию.

Значения считаются не равными:

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

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

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

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

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

Читайте также:  Windows system32 services msc

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

Код буквы в нижнем регистре всегда больше, чем код буквы в верхнем регистре. Код цифры находящейся в строке всегда меньше кода буквенного символа в любом регистре. Обычно, буква расположенная в алфавитном порядке раньше меньше , чем буква (в том же регистре) расположенная в алфавитном порядке после неё:

Сравнение и логические операторы используются для проверки на true или false .

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

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

Учитывая, что x = 5 , в таблице ниже объясняются операторы сравнения: Если x = 5 , в таблице ниже описаны операторы сравнения:

Как его можно использовать

Операторы сравнения можно использовать в условных операторах для сравнения значений и принять меры в зависимости от результата:

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

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

Учитывая, что x = 6 и y = 3 , в таблице ниже объясняются логические операторы:

Операторы Описание Сравнение Возврат Редактор кода
== равно x == 8 false Редактор кода »
x == 5 true Редактор кода »
x == «5» true Редактор кода »
=== равное и равный тип x === 5 true Редактор кода »
x === «5» false Редактор кода »
!= не равно x != 8 true Редактор кода »
!== не равное или не равный тип x !== 5 false Редактор кода »
x !== «5» true Редактор кода »
x !== 8 true Редактор кода »
> больше x > 8 false Редактор кода »
= больше или равно x >= 8 false Редактор кода »
Оператор Описание Пример Редактор кода
&& И (x 1) будет true Редактор кода »
|| ИЛИ (x == 5 || y == 5) будет false Редактор кода »
! НЕ !(x == y) будет true Редактор кода »

Условный (троичный) оператор

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

Синтаксис

Пример

Сравнение различных типов

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

При сравнении строки с числом JavaScript преобразует строку в число при сравнении. Пустая строка превращается в 0. Нечисловая строка преобразуется в NaN, которая всегда false.

Пример Значение Редактор
2 "Андрей" false Редактор кода »
2 == "Андрей" false Редактор кода »
"2" "12" true Редактор кода »
"2" == "12" false Редактор кода »

При сравнении двух строк, то "2", будет больше, чем на "12" и, поскольку (в алфавитном порядке) 1 меньше 2.

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