Javascript больше или равно: Операторы сравнения

Справочник javascript: Операторы сравнения

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 становятся нулём.

Как же тогда отличать 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 , если вы не уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.

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

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

• Если оба значения являются 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 :

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

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

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

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

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

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

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

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

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

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

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

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

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

Синтаксис

Пример

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

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

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

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

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

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

В этом разделе мы познакомимся с операторами сравнения и с логическими значениями, которые такие операторы возвращают.

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

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

Логические значения

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

Существует всего два логических значения:

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

Например:

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

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

Строки сравниваются побуквенно:

Буквы сравниваются в алфавитном порядке. Какая буква в алфавите позже — та и больше.

Аналогом «алфавита» во внутреннем представлении строк служит кодировка, у каждого символа — свой номер (код). JavaScript использует кодировку Unicode. При этом сравниваются численные коды символов.

В кодировке Unicode обычно код у строчной буквы больше, чем у прописной, поэтому:

Для корректного сравнения символы должны быть в одинаковом регистре.

Сравнение осуществляется как в телефонной книжке или в словаре . Об этом говорит сайт https://intellect.icu . Сначала сравниваются первые буквы, потом вторые, и так далее, пока одна не будет больше другой.

Иными словами, больше — та строка, которая в телефонной книге была бы на большей странице.

Например:

Такое сравнение называется лексикографическим.

Обычно мы получаем значения от посетителя в виде строк. Например, promptвозвращает строку, которую ввел посетитель.

Числа, полученные таким образом, в виде строк сравнивать нельзя, результат будет неверен. Например:

В примере выше 2 оказалось больше 14, потому что строки сравниваются посимвольно, а первый символ '2' больше '1'.

Правильно было бы преобразовать их к числу явным образом. Например, поставив перед ними +:

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

При сравнении значения преобразуются к числам. Исключение: когда оба значения — строки, тогда не преобразуются.

Например:

Тема преобразований типов будет продолжена далее, в главе  Преобразование объектов : toString и valueOf .

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

Обычное равенство не может отличить 0 от false:

Что же делать, если все же нужно отличить 0 от false?

Для проверки равенства без преобразования типов используются операторы строгого равенства === (тройное равно) и !==.

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

Сравнение с 

null и undefined

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

Интуитивно кажется, что null/undefined эквивалентны нулю, но это не так! Они ведут себя по-другому.

1. Значения null и undefined равны == друг другу и не равны чему бы то ни было еще.
   Это жесткое правило буквально прописано в спецификации языка.
2. При преобразовании в число null становится 0, а undefined становится NaN.

Посмотрим забавные следствия.

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

Итак, мы получили, что null не больше и не равен нулю. А теперь…

Как такое возможно? Если нечто «больше или равно нулю», то резонно полагать, что оно либо больше, либо равно. Но здесь это не так.

Дело в том, что алгоритмы проверки равенства == и сравнения >= > < <= работают по-разному.

Сравнение честно приводит к числу, получается ноль. А при проверке равенства значения null и undefined обрабатываются особым образом: они равны друг другу, но не равны чему-то еще.

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

Значение undefined вообще нельзя сравнивать:

• Сравнения (1) и (2) дают false потому, что undefined при преобразовании к числу дает NaN. А значение NaN по стандарту устроено так, что сравнения ==, <,>, <=, >= и даже === с ним возвращают false.
• Проверка равенства (3) дает false, потому что в стандарте явно прописано, что undefined равно лишь null и ничему другому.

Вывод: любые сравнения с undefined/null, кроме точного ===, следует делать с осторожностью. Желательно не использовать сравнения >= > < <=, во избежание ошибок в коде.

Итого

• В JavaScript есть логические значения true (истина) и false (ложь). Операторы сравнения возвращают их.
• Строки сравниваются побуквенно.
• Значения разных типов приводятся к числу при сравнении, за исключением строгого равенства=== (!==).
• Значения null и undefined равны == друг другу и не равны ничему другому. В других сравнениях (с участием >,<) их лучше не использовать, так как они ведут себя не как 0.

Выражения отношений в JavaScript — Выражения и операторы — codebra

Знания, полученные в этом и последующих уроках, нужны для понимания четвертой главы этого сайта. В этих уроках описаны операторы отношения: равно, не равно, больше, меньше и так далее. Выражения отношений всегда возвращают true (истина) или false (ложь). В основном применяются эти отношения в конструкции if, о которой вы узнаете очень подробно в следующей главе.

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

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

Операторам == и === есть противоположные != и !==, которые выполняют проверку: «не равно», «не идентично». Если два операнда равны, то будет возвращено значение false. Далее посмотрим на таблицу, чем руководствуется оператор ===, чтобы проверить на идентичность:

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

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

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

Пример 1

"0" == false    /* -> равны */
"0" === false   /* -> не идентичны */
"0" === "0"     /* -> идентичны */
"0" === 0       /* -> не идентичны */
"0" == 0        /* -> равны */

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

Есть четыре оператора сравнения:

• Меньше (<): оператор возвращает true, если первый операнд меньше, чем второй операнд; иначе возвращает false
• Больше (>): оператор возвращает true, если первый операнд больше, чем второй операнд; иначе возвращает false
• Меньше или равно (<=): оператор возвращает true, если первый операнд меньше или равен второму операнду; иначе возвращает false
• Больше или равно (>=): оператор возвращает true, если первый операнд больше или равен второму операнду; иначе возвращает false

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

Пример 2

1 <= 1    /* -> истина */
1 <= 2    /* -> истина */
1 >= 2    /* -> ложь */

Справочник по операторам сравнения OData — Azure Cognitive Search

• 
  09/16/2021
• Чтение занимает 4 мин

В этой статье

Наиболее простой операцией в выражении фильтра OData в службе «Когнитивный поиске Azure» является сравнение поля с заданным значением. Возможны два типа сравнения — сравнение на равенство и сравнение диапазонов. Для сравнения поля с постоянным значением можно использовать следующие операторы:

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

• eq: проверяет, является ли поле равным постоянному значению.
• ne: проверяет, является ли поле не равным постоянному значению.

Операторы диапазона:

• gt: проверяет, больше ли поле постоянного значения.
• lt: проверяет, меньше ли поле постоянного значения.
• ge: проверяет, больше или равно поле постоянному значению.
• le: проверяет, меньше или равно поле постоянному значению.

Для проверки того, находится ли поле в определенном диапазоне значений, можно использовать операторы диапазона в сочетании с логическими операторами. См. примеры далее в этой статье.

Примечание

При желании можно разместить константу в левой части оператора, а имя поля — в правой. Для операторов диапазона значение сравнения изменяется на противоположное. Например, если значение константы находится слева, gt будет проверять, больше ли значение константы, чем поле. Операторы сравнения также можно использовать для сравнения результатов функции, например geo.distance, с определенным значением. Для логических функций, таких как search.ismatch, сравнение результата с true или false является необязательным.

Синтаксис

Приведенная далее EBNF (расширенная форма Бэкуса — Наура) определяет грамматику выражения OData, в котором используются операторы сравнения.

comparison_expression ::=
    variable_or_function comparison_operator constant |
    constant comparison_operator variable_or_function

variable_or_function ::= variable | function_call

comparison_operator ::= 'gt' | 'lt' | 'ge' | 'le' | 'eq' | 'ne'

Кроме того, доступна интерактивная схема синтаксиса:

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

Типы данных для сравнений

Типы данных с обеих сторон оператора сравнения должны быть совместимыми. Например, если левая часть является полем типа Edm.DateTimeOffset, то правая часть должна быть константой даты и времени. Числовые типы данных являются более гибкими. Переменные и функции любого числового типа можно сравнивать с константами любого другого числового типа с некоторыми ограничениями, как описано в таблице ниже.

Для недопустимых сравнений, например для сравнения поля типа Edm.Int64 с NaN, REST API Когнитивного поиска Azure будет возвращать ошибку «HTTP 400: недопустимый запрос».

Важно!

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

Особые случаи для

null и NaN

При использовании операторов сравнения важно помнить, что все поля, не связанные с коллекцией, в Когнитивном поиске Azure могут принимать значение null. В таблице ниже показаны все возможные результаты для выражения сравнения, где с любой из сторон может быть null.

Можно сказать, что значение null равно только самому себе и не является меньше или больше какого-либо другого значения.

Если в индексе есть поля типа Edm.Double и вы загружаете в эти поля значения NaN, необходимо учитывать это при составлении фильтров. В Когнитивном поиске Azure реализован стандарт IEEE 754 при обработке значений NaN, и сравнения с такими значениями дают неочевидные результаты, как показано в таблице ниже.

Можно сказать, что значение NaN не равно никакому другому значению, включая его само.

Сравнение геопространственных данных

Сравнивать поле типа Edm.GeographyPoint с постоянным значением напрямую нельзя, но можно использовать функцию geo.distance. Эта функция возвращает значение типа Edm.Double, которое можно сравнить с числовой константой для фильтрации по расстоянию от фиксированных геопространственных координат. См. примеры ниже.

Сравнение строковых данных

Строки можно сравнивать в фильтрах на предмет точного совпадения с помощью операторов eq и ne. При сравнении строк учитывается регистр.

Примеры

Найти документы, в которых значение в поле Rating лежит в диапазоне между 3 и 5 включительно:

Rating ge 3 and Rating le 5

Найти документы, в которых значение в поле Location находится на расстоянии меньше 2 километров от заданных координат широты и долготы:

geo.distance(Location, geography'POINT(-122.031577 47.578581)') lt 2.0

Найти документы, в которых значение в поле LastRenovationDate больше или равно 1 января 2015 г., полночь по UTC:

LastRenovationDate ge 2015-01-01T00:00:00.000Z

Найти документы, в которых значение в поле Details/Sku не равно null:

Details/Sku ne null

Найти документов для гостиниц, где по меньшей мере один номер относится к типу «Deluxe Room» (Номер люкс), а строка поля Rooms/Type в точности соответствует фильтру:

Rooms/any(room: room/Type eq 'Deluxe Room')

Дальнейшие действия

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

  Как в javascript правильно делать сравнения через switch

  Стандартным методом для сравнения в JavaScript применяется оператор if с конструкцией else if и else. Об этом написано во всех учебниках по javascript с разбором разных вариантов.

  Но как выполнить сравнение через оператор switch ?

Сравнение в операторе switch

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

switch(true) {
    case(a > b)  :   x = a * b; y = b / a; break;
    case(a < b)  :   x = a / b; y = a * b; break;
    case(a == b) :   x = 150; y = 150; break;
}

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

let x;

switch(true) {
    case(a > b)  :   x = "Первое больше второго"; break;
    case(a < b)  :   x = "Первое меньше второго"; break;
    case(a == b) :   x = "Первое равно второму"; break;
}

Главное не забывать проставлять break; так как это является обязательным условием для оператора switch

Записи по теме

JavaScript методы, свойства и события для video и audio

Эти методы, свойства и события позволяют нам управлять элементами audio и video с помощью JavaScript, что позволяет писать собственные видео-плееры и аудио-проигрыватели с любым необходимым функционалом.

Методы консоли в JavaScript

В JavaScript специально для работы с консолью есть объект console. Ниже описаны доступные для объекта Console методы и приведены несколько примеров их использования.

Методы массивов JavaScript

Методы массивов в JavaScript и примеры их использования: push, pop, unshift, shift, split, join, slice, splice, reverse, map, filter, reduce, sort, includes …

Операции сравнения Javascript — jQuery, Prototype, Extjs. Javascript

Операции сравнения сравнивают два операнда и возвращают логическое значение, означающее результат этого сравнения. Строки сравниваются в лексикографическом порядке в кодировке Unicode. Если типы операндов различны, то делается попытка преобразовать их к одному типу. При этом:

• Операции «больше», «меньше», «не больше» и «не меньше» сначала пытаются преобразовать операнды в числа, а, если это невозможно, то в строки, а затем производят их сравнение.
• Операции «равно» и «не равно» пытаются преобразовать операнды в строки, затем в числа и в логические значения, а затем производят их сравнение.
• Операции «тождественно» и «не тождественно» не преобразовывают типы данных: два операнда считаются тождественно равными, если они имеют одинаковые типы и одинаковые значения.

Примеры:

var x = "3";
a = x == 3;	// a равно true
b = x === 3;	// b равно false (разные типы)

Javascript Пример «Больше или равно»

Оператор «больше или равно» (> = ) возвращает true , если левый операнд больше или равен правому операнду, и false в противном случае.

Синтаксис

 х> = у 

Описание

Операнды сравниваются с использованием алгоритма абстрактного реляционного сравнения. Краткое описание этого алгоритма см. В документации по оператору «Меньше чем».

Примеры

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

Консоль

.журнал ("а"> = "б");
console.log ("а"> = "а");
console.log ("а"> = "3");
 

Сравнение строки с числом

 console.log ("5"> = 3);
console.log ("3"> = 3);
console.log ("3"> = 5);

console.log ("привет"> = 5);
console.log (5> = "привет"); 

Число для сравнения числа

 console.log (5> = 3);
console.log (3> = 3);
console.log (3> = 5); 

Number для сравнения BigInt

Консоль

.журнал (5n> = 3);
console.log (3> = 3n);
console.log (3> = 5n); 

Сравнение Boolean, null, undefined, NaN

 console.log (истина> = ложь);
console.log (true> = true);
console.log (false> = true);

console.log (истина> = 0);
console.log (истина> = 1);

console.log (ноль> = 0);
console.log (1> = ноль);

console.log (undefined> = 3);
console.log (3> = undefined);

console.log (3> = NaN);
консоль.журнал (NaN> = 3); 

Технические характеристики

Совместимость с браузером

См. Также

Javascript: любопытный случай нулевого значения> = 0 | by Abinav Seelan

Абстрактный алгоритм реляционного сравнения

Давайте проведем первую проверку.

 нуль> 0; // false 

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

 1. Позвоните в ToPrimitive (x, номер подсказки) .2. Позвоните в ToPrimitive (y, номер подсказки) 3. Если Тип (Результат (1)) - Строка, а Тип (Результат (2)) - Строка, переходите к шагу 16. (Обратите внимание, что этот шаг отличается от шага 7 в алгоритме для оператора сложения + использованием 'и' вместо 'или'.) 4. Вызов ToNumber (Результат (1)). 5. Вызов ToNumber (Результат (2)). 6. Если Результат (4) равен NaN, вернуть undefined.7. Если Результат (5) - NaN, вернуть undefined. 8. Если Результат (4) и Результат (5) являются одним и тем же числовым значением, вернуть false. Если Результат (4) равен +0, а Результат (5) равен -0, вернуть false.10. Если Результат (4) равен -0, а Результат (5) равен +0, вернуть false.11. Если Результат (4) равен + ∞, вернуть false. 12. Если Результат (5) равен + ∞, вернуть истину 13. Если Результат (5) равен -∞, вернуть false. 14. Если Результат (4) равен -∞, вернуть истину. Если математическое значение результата (4) меньше математического значения результата (5) --- обратите внимание, что оба этих математических значения конечны, а не оба равны нулю --- верните true. В противном случае верните false. 16. Если Результат (2) является префиксом Результата (1), вернуть false. (Строковое значение p является префиксом строкового значения q, если q может быть результатом объединения p и некоторой другой строки r.Обратите внимание, что любая строка является префиксом самой себя, потому что r может быть пустой строкой.) 17. Если Результат (1) является префиксом Результата (2), вернуть истину. 18. Пусть k будет наименьшим неотрицательным целым числом, такое что символ в позиции k в Результате (1) отличается от символа в позиции k в Результате (2). (Должен быть такой k, поскольку ни одна строка не является префиксом другой.) 19. Пусть m будет целым числом, которое является значением кодовой точки для символа в позиции k в Результате (1) .20. Пусть n будет целым числом, которое является значением кодовой точки для символа в позиции k в Результате (2).21. Если m 
 Давайте рассмотрим этот алгоритм с нашим утверждением -  null> 0 .
  Шаги 1 и 2  просят нас вызвать  ToPrimitive ()  на  null  и  0  соответственно, чтобы преобразовать эти значения в их примитивные типы значений (например,  Number  и  String ). Преобразование  ToPrimitive  следует за этой таблицей.
 Судя по таблице, и наши LHS,  null , и RHS,  0 , не претерпевают никаких преобразований.
 Теперь  Шаг 3  к нам не относится, поэтому мы можем проигнорировать его и двигаться дальше. На шагах 4 и 5   нам нужно преобразовать как LHS, так и RHS в тип  Number . Преобразование в  Число  следует за этой таблицей.
  (Я пропустил    String    и    Object    из таблицы, поскольку они имеют более сложное преобразование, и преобразования в любом случае не имеют отношения к нам в данный момент.Если вам интересно, вы можете найти их   здесь  .)  🙃
  null  преобразуется в  +0 , а  0  остается  0 . Ни одно из значений не соответствует  NaN , поэтому мы можем пропустить  шаги 6 и 7.  Нам нужно остановиться на шаге 8 , .  +0   равно  , равному   0 , и алгоритм возвращает  false . Следовательно,
 null> 0; // ложь  и  null <0; // также неверно 
 Справочник по оператору сравнения OData - Когнитивный поиск Azure 
  16.09.2021 
 Читать 5 минут
 В этой статье 
 Самая простая операция в выражении фильтра OData в Когнитивном поиске Azure - это сравнение поля с заданным значением.Возможны два типа сравнения - сравнение на равенство и сравнение диапазонов. Вы можете использовать следующие операторы для сравнения поля с постоянным значением:
 Операторы равенства:
  eq : Проверить, является ли поле  равным  постоянному значению
  ne : Проверить, является ли поле  не равным  постоянному значению
 Операторы диапазона:
  gt : Проверить, является ли поле  большим, чем , постоянное значение
  lt : Проверить, действительно ли поле на  меньше  постоянного значения
  ge : проверьте, действительно ли поле на  больше или равно , постоянное значение
  le : Проверить, действительно ли поле на  меньше или равно  постоянному значению
 Вы можете использовать операторы диапазона в сочетании с логическими операторами, чтобы проверить, находится ли поле в пределах определенного диапазона значений.См. Примеры далее в этой статье.
 Примечание
 При желании вы можете поместить постоянное значение слева от оператора и имя поля справа. Для операторов диапазона значение сравнения обратное. Например, если значение константы находится слева,  gt  проверит, больше ли значение константы, чем поле. Вы также можете использовать операторы сравнения для сравнения результата функции, например  geo.distance , со значением.Для логических функций, таких как  search.ismatch , сравнение результата с  true  или  false  необязательно.
 Синтаксис 
 Следующая EBNF (расширенная форма Бэкуса-Наура) определяет грамматику выражения OData, в котором используются операторы сравнения.
  выражение_сравнение :: =
    переменная_или_функция сравнение_оператора константа |
    константа оператор_сравнения переменная_или_функция

переменная_или_функция :: = переменная | function_call

оператор_сравнения :: = 'gt' | 'lt' | 'ge' | 'le' | 'экв' | 'ne'
  
 Также доступна интерактивная синтаксическая диаграмма:
 Есть две формы сравнительных выражений.Единственная разница между ними заключается в том, появляется ли константа слева или справа от оператора. Выражение с другой стороны оператора должно быть  переменной  или вызовом функции. Переменная может быть либо именем поля, либо переменной диапазона в случае лямбда-выражения.
 Типы данных для сравнения 
 Типы данных на обеих сторонах оператора сравнения должны быть совместимы. Например, если в левой части находится поле типа  Edm.DateTimeOffset , то правая сторона должна быть константой даты и времени. Числовые типы данных более гибкие. Вы можете сравнивать переменные и функции любого числового типа с константами любого другого числового типа с некоторыми ограничениями, как описано в следующей таблице.
 Тип переменной или функции
 Тип постоянного значения
 Ограничения
  Edm. Двойной 
  Эдм. Двойной 
 Сравнение подлежит особым правилам для  NaN 
  Эдм.2-местный 
  Edm.Int64 
 Константа преобразуется в  Edm.Double , что приводит к потере точности для значений большой величины
  Edm. Двойной 
  Edm.Int32 
 нет данных
  Edm.Int64 
  Эдм. Двойной 
 Сравнения с  NaN ,  -INF  или  INF  не допускаются
  Эдм.Int64 
  Edm.Int64 
 нет данных
  Edm.Int64 
  Edm.Int32 
 Константа преобразуется в  Edm.Int64  перед сравнением
  Edm.Int32 
  Эдм. Двойной 
 Сравнения с  NaN ,  -INF  или  INF  не допускаются
  Edm.Int32 
  Эдм.Int64 
 нет данных
  Edm.Int32 
  Edm.Int32 
 нет данных
 Для недопустимых сравнений, таких как сравнение поля типа  Edm.Int64  с  NaN , REST API Когнитивного поиска Azure вернет ошибку «HTTP 400: неверный запрос».
 Важно
 Несмотря на то, что сравнения числовых типов являются гибкими, мы настоятельно рекомендуем записывать сравнения в фильтрах, чтобы постоянное значение имело тот же тип данных, что и переменная или функция, с которыми оно сравнивается.Это особенно важно при смешивании значений с плавающей запятой и целых чисел, где возможны неявные преобразования, которые теряют точность.
 Особые случаи для 
 null  и  NaN 
 При использовании операторов сравнения важно помнить, что все поля, не относящиеся к коллекции, в Когнитивном поиске Azure потенциально могут иметь значение  null . В следующей таблице показаны все возможные результаты для выражения сравнения, где любая сторона может иметь значение  null :
 Оператор
 Результат, когда только поле или переменная имеет значение  null 
 Результат, когда только константа  null 
 Результат, когда и поле или переменная, и константа равны  null 
  GT 
  ложь 
 HTTP 400: ошибка неверного запроса
 HTTP 400: ошибка неверного запроса
  л 
  ложь 
 HTTP 400: ошибка неверного запроса
 HTTP 400: ошибка неверного запроса
  GE 
  ложь 
 HTTP 400: ошибка неверного запроса
 HTTP 400: ошибка неверного запроса
  le 
  ложь 
 HTTP 400: ошибка неверного запроса
 HTTP 400: ошибка неверного запроса
  экв. 
  ложь 
  ложь 
  правда 
  ne 
  правда 
  правда 
  ложь 
 Таким образом,  null  равно только самому себе и не меньше или не больше любого другого значения.
 Если в вашем индексе есть поля типа  Edm.Double  и вы загружаете в эти поля  значений NaN , вам нужно будет учесть это при написании фильтров. Когнитивный поиск Azure реализует стандарт IEEE 754 для обработки значений  NaN , и сравнения с такими значениями дают неочевидные результаты, как показано в следующей таблице.
 Оператор
 Результат, когда хотя бы один операнд равен  NaN 
  GT 
  ложь 
  л 
  ложь 
  GE 
  ложь 
  le 
  ложь 
  экв. 
  ложь 
  ne 
  правда 
 Таким образом,  NaN  не равно никакому значению, включая его самого.
 Сравнение геопространственных данных 
 Вы не можете напрямую сравнить поле типа  Edm.GeographyPoint  с постоянным значением, но вы можете использовать функцию  geo.distance . Эта функция возвращает значение типа  Edm.Double , поэтому вы можете сравнить его с числовой константой для фильтрации на основе расстояния от постоянных геопространственных координат. См. Примеры ниже.
 Сравнение строковых данных 
 Строки можно сравнивать в фильтрах на предмет точного совпадения с помощью операторов  eq  и  ne .Эти сравнения чувствительны к регистру.
 Примеры 
 Соответствие документов, в которых поле  Рейтинг  находится между 3 и 5 включительно:
  Рейтинг ge 3 и рейтинг le 5
  
 Сопоставить документы, в которых поле  Location  находится менее чем в 2 километрах от заданных широты и долготы:
  geo.distance (Местоположение, география'POINT (-122.031577 47.578581) ') lt 2.0
  
 Сопоставление документов, в которых поле  LastRenovationDate  больше или равно 1 января 2015 г., полночь по всемирному координированному времени:
  LastRenovationDate ge 2015-01-01T00: 00: 00.000Z
  
 Сопоставить документы, в которых поле  Details / Sku  не равно  null :
  Детали / Артикул null
  
 Сопоставьте документы для отелей, в которых хотя бы один номер имеет тип "Deluxe Room", где строка поля  Rooms / Type  точно соответствует фильтру:
  Комната / любая (комната: комната / Тип экв. 'Deluxe Room')
  
 Следующие шаги 
 Истина и ложь: когда в JavaScript не все равно 
  Сравнение двух вещей на предмет равенства часто может сбить с толку неосторожного разработчика JavaScript, поскольку у языка есть несколько причуд, о которых нам нужно знать.
 В этой статье мы рассмотрим, почему это так, исследуя операторы двойного и тройного равенства, а также концепцию истинности и ложности значений в JavaScript. К тому времени, когда вы закончите читать, вы поймете, как JavaScript производит сравнения, а также как достоверные и ложные значения могут помочь вам писать более чистый код.
 Ввод в JavaScript 
 Переменные JavaScript имеют слабую / динамическую типизацию, и языку не важно, как значение объявляется или изменяется:
  пусть х;
х = 1;
х = '1';
х = [1];
  
 По-видимому, разные значения соответствуют  истинному  по сравнению с  ==  (свободное или абстрактное равенство), потому что JavaScript (эффективно) преобразует каждое в строковое представление перед сравнением:
 
1 == '1';
1 == [1];
'1' == [1];
  
 Более очевидный результат  false  возникает при сравнении с  ===  (строгое равенство), потому что учитывается тип:
 
1 === '1';
1 === [1];
'1' === [1];
  
 Внутренне JavaScript устанавливает значение одного из семи примитивных типов данных:
 Undefined (переменная без определенного значения)
 Null (одно значение NULL)
 Boolean (значение  true  или  false )
 Число (сюда входят  Infinity  и  NaN  - не число!)
 BigInt (целое число больше 2 ^ 53-1)
 Строка (текстовые данные)
 Symbol (уникальный и неизменный примитив, новый для ES6 / 2015)
 Все остальное - это объект, включая массивы.
 Истинные и ложные значения в JavaScript 
 Помимо типа, каждое значение также имеет собственное логическое значение, обычно известное как  правдивый  или  ложный . Некоторые правила выглядят немного странно, поэтому понимание концепций и их влияния на сравнение помогает при отладке приложений JavaScript.
 Следующие значения  всегда ложны :
  ложный 
  0  (ноль)
  -0  (минус ноль)
  0n  ( BigInt  ноль)
  ", " ", "  (пустая строка)
  null 
  не определено 
  NaN 
 Все остальное  правдиво .В том числе:
  '0'  (строка, содержащая единственный ноль)
  'false'  (строка, содержащая текст «false»)
  []  (пустой массив)
  {}  (пустой объект)
  function () {}  («пустая» функция)
 Таким образом, в условиях можно использовать одно значение. Например:
  if (значение) {
  
}
еще {
  
  
}
  
 документ.все 
 Вы также можете увидеть документ . Все  указаны как ложное значение. Это возвращает  HTMLAllCollection , который содержит список всех элементов документа. И хотя это оценивается как  false  в логическом контексте, это устаревшая функция, и MDN не рекомендует ее использовать.
 Свободное сравнение равенства с 
 == 
 Неожиданные ситуации могут возникнуть при сравнении значений  истинного  и  ложного  с использованием  ==  слабого равенства:
   ==  
   правда  
   ложный  
   0  
   ''  
   null  
   undefined  
   NaN  
   Бесконечность  
   []  
   {}  
   истинно  
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   ложный  
 ложь
 правда
 правда
 правда
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
   0  
 ложь
 правда
 правда
 правда
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
   ''  
 ложь
 правда
 правда
 правда
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
   null  
 ложь
 ложь
 ложь
 ложь
 правда
 правда
 ложь
 ложь
 ложь
 ложь
   undefined  
 ложь
 ложь
 ложь
 ложь
 правда
 правда
 ложь
 ложь
 ложь
 ложь
   NaN  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   Бесконечность  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
 ложь
   []  
 ложь
 правда
 правда
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   {}  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 Правил:
  false , нулевая и пустая строки эквивалентны.
  null  и  undefined  эквивалентны сами себе и друг другу, но ничего больше.
  NaN  ничему не эквивалентно -  включая еще  NaN ! .
  Infinity  является правдой - , но его нельзя сравнивать с  true  или  false ! .
 Пустой массив правдив - , но сравнивая с  истинно  - это  ложно  и сравнивая с  ложным  - это  истинно ?! .
 Примеры:
 
false == 0;
0 == '';
null == undefined;
[] == ложь;
!! [0] == истина;


false == null;
NaN == NaN;
Бесконечность == истина;
[] == верно;
[0] == верно;
  
 Строгое сравнение равенства с 
 === 
 Ситуация более ясна при использовании строгого сравнения, потому что типы значений должны совпадать:
  === 
   правда  
   ложный  
   0  
   ''  
   null  
   undefined  
   NaN  
   Бесконечность  
   []  
   {}  
   истинно  
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   ложный  
 ложь
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   0  
 ложь
 ложь
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   ''  
 ложь
 ложь
 ложь
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   null  
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
 ложь
 ложь
 ложь
 ложь
   undefined  
 ложь
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
 ложь
 ложь
 ложь
   NaN  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   Бесконечность  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 правда
 ложь
 ложь
   []  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
   {}  
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 ложь
 Единственное исключение -  NaN , который упорно не эквивалентен всему.
 Рекомендации по работе с истинными или ложными значениями 
 Правдивые и ложные значения могут уловить даже самых опытных разработчиков. У тех, кто плохо знаком с программированием или переходом с других языков, нет никаких шансов! К счастью, есть три простых шага для выявления наиболее трудных для обнаружения ошибок при работе с истинными и ложными переменными. Давайте рассмотрим каждый по очереди.
 1. Избегайте прямых сравнений 
 Редко нужно сравнивать два истинных и ложных значения, когда одно значение всегда будет равно истинному или ложному:
 
если (x == ложь)



если (! x)

  
 2.Используйте 
 === , строгое равенство
 Используйте сравнения  ===  со строгим равенством (или ! ==  со строгим неравенством) для сравнения значений и избежания проблем с преобразованием типов:
 
если (х == у)




если (x === y)


  
 3. Преобразовать в реальные логические значения, если необходимо. 
 Вы можете преобразовать любое значение в реальное логическое значение в JavaScript, используя либо логический конструктор, либо двойное отрицательное значение  !! . Это позволит вам быть абсолютно уверенным, что ложь генерируется только  false ,  0 ,  "" ,  null ,  undefined  и  NaN :
 
если (x === y)




если (логическое (x) === логическое (y))

если (!! x === !! y)


  
 Конструктор  Boolean  возвращает  true  при передаче истинного значения и  false  при передаче ложного значения.Это может быть полезно в сочетании с методом итерации. Например:
  const truthy_values ​​= [
  ложный,
  0,
  ``,
  '',
  "",
  нулевой,
  неопределенный,
  NaN,
  '0',
  'ложный',
  [],
  {},
  function () {}
] .filter (логический);


console.log (truthy_values);
  
 Заключение 
 Истинные и ложные значения позволяют писать краткие условия JavaScript и тернарные операторы. Однако всегда учитывайте крайние случаи. Неверный пустой массив или переменная NaN могут привести к многочасовым трудностям при отладке!
 Вам нужна помощь с чем-то, что мы здесь рассмотрели? Почему бы не зайти на наш форум JavaScript и задать вопрос.У нас есть команда дружелюбных экспертов, готовых помочь.
 Обычные операторы сравнения JavaScript 
 Вчера мы рассмотрели разницу между операторами сравнения == и ===. Они используются для сравнения двух значений или объектов. Но в  JavaScript  есть больше операторов сравнения, которые мы можем использовать.
 Операторы сравнения JavaScript постоянная ссылка 
 В пределах  JavaScript  мы можем использовать следующие операторы сравнения. Я записал таблицу ниже, чтобы иметь быстрый справочник.
 Оператор
 Описание
 Сравнение
 Возврат
 ==
 Равно
 x == 10 
 x == 3 
 x == "3"
 false 
 true 
 true
 ===
 Равно значение и тип
 x === 3 
 x === "3"
 true 
 false
! =
 Не равно
 x! = 10 
 x! = "3"
 true 
 false
! ==
 Не равное значение и тип
 x! == "3" 
 x! == 3
 true 
 false
>
 Больше
 x> 2
 истинно
 <
 Меньше
 x <4
 истинно
> =
 Больше или равно
 x> = 3
 истинно
 <=
 Меньше чем или экв. ual
 x <= 3
 true
 == и === мы подробно обсуждали вчера.
 JavaScript! = И! == Постоянная ссылка для сравнения 
 Как вы можете догадаться, они очень похожи на == и ===, но! В большинстве языков программирования означает , а не . Таким образом, они будут сравниваться, если значение НЕ то, с чем мы его сравниваем. И! == даже проверит правильный тип.
  х = 3; 
 
  
 console.log (x! = 10) 
 console.log (x! = "3") 
 
  
 console. log (x! == "3") 
 console.log (x! == 3)  
 Как вы можете видеть во втором примере, он подумает, что строка номер три неверна.
 JavaScript Меньше и больше чем Сравнение постоянная ссылка 
 Следующие все в отношении меньше или больше чем:
   сравнение -> 
 console.log (x> 2) 
 
  
 console.log (x <4) 
 
  = сравнение -> 
 console.log (x> = 3) 
 
  
 консоль.log (x <= 3)  
 Итак, примечание >  только для большего, чем, а > =  также включает само фактическое число. То же самое для  < и  <= .
 Не стесняйтесь изучить следующий Codepen.
 См. Операторы сравнения Pen Vanilla JavaScript Криса Бонгерса (@rebelchris) на CodePen.
 Спасибо, что прочитали, и давайте подключимся! постоянная ссылка 
 Спасибо, что прочитали мой блог. Не стесняйтесь подписаться на мою рассылку новостей по электронной почте и подключиться к Facebook или Twitter.
 Операторы сравнения в XQuery: В чем разница между «eq» и ​​«=»? 
 Один из распространенных вопросов, связанных с XQuery, который часто возникает у разработчиков: , почему XQuery и XSLT имеют более одного оператора для каждого сравнения?  В таблице ниже показано, что существует двенадцать, а не шесть операторов сравнения, половина из которых использует буквы (например,  eq ), а половина из которых использует символы (например,  = ):
  Сравнение значений 
  Общее сравнение 
  равно 
  экв.
  = 
  не равно 
  ne 
 ! = 
  менее 
  лит 
  <
  больше 
  GT 
 > 
  меньше или равно 
  le 
  <= 
  больше или равно 
  GE 
 > = 
 В 1.0-мл версия XQuery, по умолчанию никакой разницы в поведении нет;  eq  ведет себя так же, как  =  и т. Д. Если вы хотите копнуть немного глубже, это связано с отображением функций, которое вы можете включить или отключить; если вы отключите отображение функций,  eq  не будет вести себя так же, как  = .
 Однако, хотя они  ведут себя  одинаково в 1,0 мл, на самом деле они  означают  разные вещи. Операторы сравнения значений ( eq ,  lt  и т. Д.) предназначены для сравнения  отдельных значений  (т. е. последовательностей по одному значению каждая). Общие операторы сравнения ( = ,  < и т. Д.) Предназначены для сравнения последовательностей более чем одного значения.
 Как я могу применить это на практике? 
 В стандартной версии XQuery 1.0 (которую MarkLogic также поддерживает) вы получите сообщение об ошибке, если попытаетесь использовать оператор сравнения значений для сравнения последовательностей из более чем одного значения:
 версия xquery "1.0 ";
"foo" eq ("foo", "bar") 
 Вот результат ошибки:
 Реализация 1.0 мл ослабляет это ограничение, следовательно, практически идентичное поведение  eq  и  =  и т. Д. В XQuery версии 1.0 вам вместо этого потребуется использовать общий оператор сравнения ( = ):
 "foo" = ("foo", "bar") 
 Использование общего оператора сравнения вернет истину в обеих версиях 1.0 и 1.0-ml, а выражение вернет истину, если  любые  элементов слева успешно сравнятся с  любыми  элементами справа.Иногда это называют «экзистенциальной количественной оценкой». Более длинный и более явный способ записать это в XQuery - использовать выражение «some»:
 некоторый $ item1 в "foo", $ item2 in ("foo", "bar") удовлетворяет $ item1 eq $ item2 
 У вас может быть политика (и я думаю, что она в целом хорошая) всегда писать код в версии 1.0-ml, так имеет ли значение то, что вы знаете эту разницу?
 Думаю, да. Знание разницы позволяет вам писать код, который не только будет более совместимым, но и более выразит ваши намерения:
 Вы можете написать XQuery 1.0, которая работает в нескольких реализациях
 Возможно, вы захотите лучше понять код, написанный в библиотеках XQuery 1.0, которые вы используете.
 Возможно, вам не захочется зависеть от специфического для XQuery 1.0-ml поведения отката при ошибке
 Возможно, вы захотите более четко выразить свои намерения при выборе оператора, который будет использовать
 Например, если вы знаете, что  $ var  будет содержать не более одного числа, и хотите сравнить его с буквальным числом, лучше всего использовать оператор сравнения значений, например  le :
 $ var le 5 
 Использование  <=  означало бы, что $ var может содержать более одного числа.С другой стороны, если $ var внезапно имеет более одного значения, вы бы  хотели, чтобы  использовал вместо этого <= (чтобы избежать ошибки в версии 1.0), если на самом деле это ваше намерение (т.е. вернуть истину, если любое из $ var меньше или равно заданному числу):
 (: Любое из чисел в $ var меньше или равно 5? :)
$ var <= 5 
 Посмотреть пример 
 Приведем это к более практическому примеру, скажем, у вас есть элемент  в вашем XML, и вы хотите найти человека по имени «Билл»:
 // человек [имя эк. "Билл"] 
 Если вы знаете, что у  всегда будет только одно , то приведенный выше код безопасен.Но если вы используете 1.0 и один из ваших элементов  имеет более одного , это вызовет ошибку. Если вы предпочитаете найти элемент  с  любым дочерним элементом   со значением «Bill», тогда оператор = будет работать так, как вы хотите (в обеих версиях 1.0 и 1.0-ml):
 // человек [name = "Bill"] 
 В заключение добавлю одну историческую заметку. До XPath 2.0 (который использует XQuery) не было операторов сравнения значений;  eq ,  gt ,  lt  и т.п. просто не существовало.У вас были только =,>, <и т. Д. В XSLT / XPath 1.0. С XPath 2.0, XSLT 2.0 и XQuery теперь у вас есть выбор.
 Дополнительные ресурсы 
 Узнайте больше о сопоставлении функций в 1.0 мл, чтобы лучше понять, почему эти операторы ведут себя одинаково.
 значений, выражений и операторов JavaScript 
 значений, выражений и операторов JavaScript
 Выражения 
 Выражение - это любой допустимый набор литералов, переменных, операторов,
 и выражения, вычисляющие одно значение.Значение может быть числом, строкой или логическим значением.
Концептуально существует два типа выражений:
 те, которые присваивают значение переменной, и те, которые просто
 иметь ценность. Например, выражение
  х = 7 
 является выражением, которое присваивает x значение 7. Само это выражение
 принимает значение 7. В таких выражениях используется  оператора присваивания. 
 С другой стороны, выражение
  3 + 4 
 просто оценивается как 7; он не выполняет задания.В
 операторы, используемые в таких выражениях, называются просто  операторами .
 В JavaScript есть следующие виды выражений:
 Арифметика: вычисляет число, например
 Строка: оценивается как строка символов, например «Фред» или «234».
 Логический: принимает значение "истина" или "ложь"
 Специальное ключевое слово  null  обозначает нулевое значение.
 Напротив, переменные, которым не было присвоено значение, имеют вид  undefined  и не могут
 использоваться без ошибок времени выполнения.
 Условные выражения 
 Условное выражение может иметь одно из двух значений в зависимости от условия.
 Синтаксис:
( условие )?  val1 :  val2 
 
 Если  условие  истинно, выражение имеет значение  val1 ,
 В противном случае он имеет значение  val2 .
 Вы можете использовать условное выражение везде, где бы вы ни использовали стандартный
 выражение.
 Например,
status = (возраст> = 18)? "взрослый": "несовершеннолетний"
 
Этот оператор присваивает переменной status значение "взрослый". y
 x | = означает x = x | у
 Операторы 
 В JavaScript есть арифметические, строковые и логические операторы.Там
 являются  двоичными  и  унарными  операторами. Бинарный оператор
 требуется два операнда, один перед оператором и один после
 оператор:
   операнд1 оператор операнд2  
 Например,
 3 + 4 или x * y
 Унарный оператор требует одного операнда до или после
 Оператор:
  оператор-операнд 
 или
  оператор операнда 
 Например x ++ или ++ x.
 Арифметические операторы 
 Арифметические операторы принимают числовые значения (литералы или
 переменные) в качестве своих операндов и возвращают одно числовое значение.
 Стандартные арифметические операторы 
 Стандартные артметические операторы: сложение (+), вычитание (-), умножение (*),
 и деление (/). Эти операторы работают стандартным образом.
 Модуль (%) 
 Оператор модуля используется следующим образом:
 
  var1% var2 
 Оператор модуля возвращает первый операнд по модулю второго.
 операнд, то есть  var1  modulo  var2 , в операторе
 выше, где  var1  и  var2  - переменные.По модулю
 Функция представляет собой остаток от целого деления  var1  на  var2 .
 Например, 12% 5 возвращает 2.
 Приращение (++) 
 Оператор инкремента используется следующим образом:
 
  var ++  или  ++ var 
 Этот оператор увеличивает (добавляет на единицу) свой операнд и возвращает значение.
 Если используется постфикс, с оператором после операнда (например, x ++), то он
 возвращает значение до увеличения. Если используется префикс с оператором перед
 операнд (например, ++ x), то он возвращает значение после увеличения.
 Например, если x равно 3, то утверждение
  у = х ++ 
 увеличивает x до 4 и устанавливает y до 3.
 Если x равно 3, то утверждение
  у = ++ х 
 увеличивает x до 4 и устанавливает y до 4.
 Уменьшение (-) 
 Оператор декремента используется следующим образом:
  var -  или  - var 
 Этот оператор уменьшает (вычитает единицу) свой операнд
 и возвращает значение.Если используется постфикс (например, x--), то он
 возвращает значение до уменьшения. Если используется префикс (например,
 --x), затем возвращает значение после уменьшения.
 Например, если x равно 3, то утверждение
  у = х - 
 уменьшает x до 2 и устанавливает y до 3.
 Если x равно 3, то утверждение
  г = --x 
 уменьшает x до 2 и устанавливает y до 2.
 Унарное отрицание (-) 
 Оператор унарного отрицания должен предшествовать его операнду.Это отрицает
 его операнд. Например,
 х = -х
 отрицает значение x; то есть, если бы x было 3, он стал бы -3.
 Побитовые операторы 
 Поразрядные операторы обрабатывают свои операнды как набор битов (нулей и единиц),
 а не как десятичные, шестнадцатеричные или восьмеричные числа.
 Например, десятичное число 9 имеет двоичное представление 1001.
 Побитовые операторы выполняют свои операции с такими двоичными представлениями,
 но они возвращают стандартные числовые значения JavaScript.
 Побитовые логические операторы 
 Поразрядные логические операторы концептуально работают следующим образом:
 Операнды преобразуются в 32-битные целые числа и выражаются
 серия битов (нулей и единиц).
 Каждый бит в первом операнде спарен с соответствующим битом во втором
 операнд: первый бит - первый бит, второй бит - второй бит и так далее.
 Оператор применяется к каждой паре битов, и создается результат
 побитовое.
 Побитовые операторы:
 Побитовое И & возвращает единицу, если оба операнда равны единице.1001 = 0110)
 Операторы побитового сдвига 
 Операторы побитового сдвига:
 Левый сдвиг (& lt <)
 Сдвиг вправо для распространения знака (>>)
 Сдвиг вправо с заполнением нулями (>>>)
 Операторы сдвига принимают два операнда: первый - это величина, которую нужно сдвинуть, и
 второй определяет количество битовых позиций, по которым первый операнд
 быть перемещенным. Направление операции переключения контролируется используемым оператором.
 Операторы сдвига преобразуют свои операнды в 32-битные целые числа и возвращают результат
 того же типа, что и левый оператор.
 Левый сдвиг (& lt 
<)
 Этот оператор сдвигает первый операнд на указанное количество бит влево.
 Лишние биты, смещенные влево, отбрасываются. Нулевые биты сдвигаются из
 право.
 Например, сдвиг вправо, распространяющий знак (>>)
 Этот оператор сдвигает первый операнд на указанное количество бит вправо.Лишние биты, смещенные вправо, отбрасываются.
 Копии самого левого бита смещаются слева.
 Например, 9 >> 2 дает 2, потому что 1001, сдвинутый на два бита вправо, становится 10,
 что равно 2. Точно так же -9 >> 2 дает -3, потому что знак сохраняется.
 Сдвиг вправо с нулевым заполнением (>>>) 
 Этот оператор сдвигает первый операнд на указанное количество бит влево.
 Лишние биты, смещенные вправо, отбрасываются.
 Нулевые биты сдвигаются слева.
 Например, 19 >>> 2 дает 4, потому что 10011, сдвинутый на два бита вправо, становится 100,
 что равно 4. Для положительных чисел сдвиг вправо с заполнением нулями и распространение знака вправо
 shift дают тот же результат.
 Логические операторы 
 Логические операторы принимают в качестве операндов логические (логические) значения.
 Они возвращают логическое значение. Логические значения:  истинно  и  ложно .
 И (&&) 
  Использование :  expr1 && expr2 
 Оператор логического "и" возвращает истину, если оба логических
 выражения  expr1  и  expr2  верны.Иначе,
 он возвращает false.
 или (||) 
  Использование :  expr1 || expr2 
 Логический оператор "или" возвращает истину, если любой из логических
 выражение  expr1  или  expr2  верно. Если оба  expr1 
 и  expr2  ложны, тогда возвращается ложь.
 Не (!) 
  Использование : ! Expr 
 Логический оператор «не» - это унарный оператор, который
 отрицает свое выражение операнда
  выражение .То есть, если  expr  истинно, оно возвращает false,
 и если  expr  ложно, то возвращается истина.
 Оценка короткого замыкания 
 Поскольку логические выражения оцениваются слева направо, они проверяются на
 оценка возможного «короткого замыкания» по следующему правилу:
  false  &&  все, что  оценивается как короткое замыкание,  false .
  правда  ||  что-нибудь  оценивается коротким замыканием до  истинно .
 Правила логики гарантируют, что эти оценки всегда будут правильными.
 Обратите внимание, что часть  something  приведенных выше выражений не оценивается, поэтому любая
 побочные эффекты от этого не действуют.
 Операторы сравнения (= =,>,> =, 
<, <=,! =)
 Оператор сравнения сравнивает свои операнды и возвращает логическое
 значение в зависимости от того, верно сравнение или нет. Операнды
 могут быть числовыми или строковыми значениями. При использовании со строковыми значениями
 сравнения основаны на стандартном лексикографическом порядке.
 Операторы:
 Equal (= =): возвращает истину, если операнды равны.
 Не равно (! =): Возвращает истину, если операнды не равны.
 Больше чем (>): возвращает истину, если левый операнд больше
 чем правый операнд. Пример: x> y возвращает истину, если x больше
 чем у.
 Больше или равно (> =): возвращает true, если осталось
 операнд больше или равен правому операнду. Пример: x
 > = y возвращает истину, если x больше или равно y.
 Меньше (<): возвращает истину, если левый операнд меньше, чем
правый операнд. Пример: x 
 Меньше или равно (<=):
возвращает истину, если левый операнд меньше или равен правому операнду.
Пример: x <= y возвращает true, если x меньше или равно y.
 Строковые операторы 
 В дополнение к операторам сравнения, которые могут использоваться на
 строковых значений оператор конкатенации (+) объединяет два
 строковые значения вместе, возвращая другую строку, которая является объединением
 из двух строк операндов.