Меню

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



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

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

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

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

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

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

Источник

Форум

Справочник

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

Описание, примеры

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

Яваскрипт допускает как строгое сравнение, так и сравнение с приведением типов. Для строгого сравнения оба операнда должны иметь одинаковый тип и:

  • Две строки строго равны, если состоят из одинаковой последовательности символов
  • Два числа строго равны, если равны в обычном смысле слова. +0 строго равен -0 .
  • NaN строго не равно ничему, включая NaN
  • Два булевых операнда строго равны, если они оба true или false
  • Два операнда-объекта строго равны, если являются ссылками на один и тот же общий объект
  • Null и Undefined равны == , но не строго равны ===
Читайте также:  Сравнение ферментных препаратов при панкреатите

Следующая таблица описывает операторы сравнения:

var1 != 4
var1 != «5»

var2 >= var1
var1 >= 3

Использование операторов сравнения

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

При конвертации типов яваскрипт преобразует String, Number, Boolean и Object следующим образом:

  • При сравнении числа и строки, строка преобразуется в числовое значение. Яваскрипт при этом получает значение числа из строкового литерала: «123» == 123 .
  • Если один из операндов — булевый, то он преобразуется к 1, если он true и к +0, если он false
  • Если объект сравнивается с числом или строкой, яваскрипт пытается получить соответствующее значение для объекта. Он преобразует объект к элементарному значению, строке или числу, используя методы valueOf и toString . Если преобразовать объект не удается — генерируется ошибка выполнения.

Источник

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

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

  1. Больше/меньше: a > b , a .
  2. Больше/меньше или равно: a >= b , a .
  3. Равно: a == b (нестрогое равенство; помните, что один знак равенства a = b означает присваивание).
  4. Равно: a === b (строгое равенство, предпочтительно для использования! см. ниже).
  5. Не равно: a != b , a !== b (нестрогое и строгое неравенство; в математике обозначается символом ≠).

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

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

Следующие значения являются ложными:

  • false
  • undefined
  • null
  • 0 (ноль)
  • NaN
  • пустая строка ( «» ).

Все остальные значения при передаче в условное выражение, включая все объекты, будут восприняты как ИСТИНА ( TRUE ).

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

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

Cтроки в JavaScript сравниваются посимвольно (используется «алфавитный» или «лексикографический» порядок), при этом:

  • используется кодировка Unicode, а не настоящий алфавит;
  • имеет значение регистр символов (заглавная «A» меньше «a», так как строчные буквы имеют больший код в Unicode).

Алгоритм сравнения строк в JS:

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

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

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

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

При нестрогом сравнении возможна ситуация, когда два значения разных типов равны, при этом:

  • одно из них как логическое значение — true;
  • другое — false.

Таким образом, использование обычного сравнения == может вызывать проблемы (например, оно не отличает 0 от false):

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

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

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

Специальное правило языка JavaScript:

  1. При строгом равенстве === значения null и undefined различны, так как различны их типы.
  2. При нестрогом равенстве == значения null и undefined равны друг другу и не равны никаким другим значениям.
  3. При использовании математических операторов и других операторов сравнения = значения null и undefined преобразуются к числам:
    • null — 0;
    • undefined – NaN.

Источник

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

JavaScript предоставляет три оператора сравнения величин:

  • равенство («двойное равно») использует ==,
  • строгое равенство (или «тройное равно» или «идентично») использует ===,
  • и Object.is (новшество из ECMAScript 6).

Выбор оператора зависит от типа сравнения, которое необходимо произвести.

В общих чертах, двойное равно перед сравнением величин производит приведение типов; тройное равно сравнивает величины без приведения (если величины разных типов, вернёт false , даже не сравнивая); ну и Object.is ведёт себя так же, как и тройное равно, но со специальной обработкой для NaN , -0 и +0 , возвращая false при сравнении -0 и +0 , и true для операции Object.is(NaN, NaN) . (В то время как двойное или тройное равенство вернут false согласно стандарту IEEE 754.) Следует отметить, что все эти различия в сравнениях применимы лишь для примитивов. Для любых не примитивных объектов x и y , которые имеют одинаковые структуры, но представляют собой два отдельных объекта (переменные x и y не ссылаются на один и тот же объект), все операторы сравнения вернут false .

Сравнение с использованием ==

Перед сравнением оператор равенства приводит обе величины к общему типу. После приведений (одного или обоих операндов), конечное сравнение выполняется также как и для === . Операция сравнения симметрична: A == B возвращает то же значение, что и B == A для любых значений A и B .

В следующей таблице приведены результаты сравнения оператора равенства для различных значений:

Оператор Описание Примеры, возвращающие true при var1=3, var2=4
Равно ( == ) Если два операнда не одного типа, javascript преобразовывает типы и сравнивает строго. Если какой-либо операнд — число или булево значение, то операнды преобразуются в числа; если какой-либо операнд строка — второй преобразуются в строку
Не равно ( != ) Возвращает true , если операнды не равны. Если операнды имеют разный тип, javascript преобразовывает.
Строго равно ( === ) Возвращает true , если операнды строго равны (см. выше), без преобразования типов.
Строго не равно ( !== ) Возвращает true , если операнды не являются строго равными (см. выше) или имеют разные типы.
Больше ( > ) Возвращает true , если левый операнд больше правого.
Больше или равно ( >= ) Возвращает true , если левый операнд больше правого или равен ему.
Меньше ( ) Возвращает true , если левый операнд меньше правого.
Меньше или равно ( ) Возвращает true , если левый операнд меньше правого или равен ему.

Операнд B
Undefined Null Number String Boolean Object
Операнд A true true false false false false
Null true true false false false false
Number false false A === B A === ToNumber(B) A === ToNumber(B) A == ToPrimitive(B)
String false false ToNumber(A) === B A === B ToNumber(A) === ToNumber(B) A == ToPrimitive(B)
Boolean false false ToNumber(A) === B ToNumber(A) === ToNumber(B) A === B ToNumber(A) == ToPrimitive(B)
Object false false ToPrimitive(A) == B ToPrimitive(A) == B ToPrimitive(A) == ToNumber(B) A === B

В таблице выше, ToNumber(A) пытается перед сравнением привести свой аргумент к числу. Такое поведение эквивалентно +A (унарный оператор + ). Если ToPrimitive(A) получает объект в качестве аргумента, то производятся попытки привести его к примитиву, вызывая на нем методы A.toString и A.valueOf .

Традиционно ( и в соответствии с ECMAScript ) , ни один из объектов не равен undefined или null . Но большинство браузеров позволяет определённому классу объектов (в частности, объектам document.all для любой страницы ) эмулировать значение undefined. Оператор равенства вернёт значение true для null == A и undefined == A , тогда, и только тогда, когда объект эмулирует значение undefined . Во всех остальных случаях объект не может быть равен undefined или null .

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

Строгое равенство с использованием ===

Строгое равно проверяет на равенство две величины, при этом тип каждой из величин перед сравнением не изменяется (не приводится). Если значения имеют различающиеся типы, то они не могут быть равными. С другой стороны все не числовые переменные, принадлежащие одному типу, считаются равными между собой, если содержат одинаковые величины. Ну и, наконец, числовые переменные считаются равными, если они имеют одинаковые значения, либо одна из них +0 , а вторая -0 . В то же время, если хотя бы одна из числовых переменных содержит значение NaN , выражение вернёт false .

Практически всегда для сравнения следует использовать оператор строгого равенства. Для всех значений, за исключением числовых используется очевидная семантика: величина равна только сама себе. Как было сказано выше для числовых типов можно выделить два особых случая. Во-первых, сравнение +0 и -0 . Знак для нуля введён для упрощения некоторых вычислений с плавающей запятой, однако, с точки зрения математики, разницы между +0 и -0 не существует, поэтому оператор строгого равенства считает их равными. Во-вторых, сравнение величин NaN . NaN (Not a number) представляет из себя значение не определённой величины, которое применяется для не чётко определённых математических задач (например +∞ + -∞ ). Для оператора строго равенства NaN не равен ни одной из величин, в том числе и самому себе (единственный случай, когда (x!==x) вернёт true).

Равенство одинаковых величин

Равенство одинаковых величин определяет функциональную идентичность во всех контекстах сравниваемых величин. (Данный способ сравнения основывается на принципе подстановки Барбары Лисков.) Рассмотрим пример попытки изменения неизменяемого (immutable) свойства :

При попытке изменения неизменяемого свойства, вызов Object.defineProperty выбросит исключение, однако, если новое свойство равняется старому, изменений не произойдёт и исключение не будет выброшено. Если v содержит -0 , изменений не произойдёт, а значит, код отработает без выброса исключений. Однако, если же v содержит +0 , Number.NEGATIVE_ZERO утратит свою неизменяемую величину. Именно для сравнения нового и текущего неизменяемых свойств используется сравнение одинаковых величин, представленное методом Object.is .

Спецификации для равенства, строгого равенства и равенства одинаковых величин

В стандарте ES5, сравнение выполняемое оператором == описывается в секции 11.9.3, The Abstract Equality Algorithm. Описание оператора === находится в секции 11.9.6, The Strict Equality Algorithm. В секции 9.12, The SameValue Algorithm ES5 описывает операцию сравнение одинаковых величин для внутреннего движка JS. Строгое равенство и равенство одинаковых величин, практически одинаковы, за исключением обработки числовых типов. ES6 предлагает использовать алгоритм сравнения одинаковых величин через вызов Object.is .

Как понимать все эти способы сравнения?

До выхода редакции ES6 считалось, что оператор строгого равенства просто «улучшенная» версия оператора нестрогого равенства. Например, некоторые считали, что == просто улучшенная версия === потому, что первый оператор делает всё то же, что и второй, плюс приведение типов своих операндов. То есть 6 == «6». (Или же наоборот: оператор нестрогого равенства базовый, а оператор строгого равенства просто его улучшенная версия, ведь он добавляет ещё одно условие — требует, чтобы оба операнда были одного и того же типа. Какой вариант ближе вам, зависит только от вашей точки зрения на вещи.)

Но эти точки зрения уже нельзя применить к новому методу сравнения Object.is из новой редакции ES6. Нельзя сказать, что Object.is более или менее строг относительно существующих способов сравнения, или что это нечто среднее между ними. Ниже в таблице показаны основные различия операторов сравнения. Object.is интересен тем, что различает -0 и +0, а также умеет сравнивать два не числа NaN.

Сравнительная таблица операторов сравнения

x y == === Object.is
undefined undefined true true true
null null true true true
true true true true true
false false true true true
«foo» «foo» true true true
x true true true
true true true
+0 -0 true true false
false true false false
«» false true false false
«» true false false
«0» true false false
«17» 17 true false false
[1,2] «1,2» true false false
new String(«foo») «foo» true false false
null undefined true false false
null false false false false
undefined false false false false
false false false
new String(«foo») new String(«foo») false false false
null false false false
NaN false false false
«foo» NaN false false false
NaN NaN false false true

Когда же использовать Object.is ?

Особенность обработки Object.is нулей будет полезна в метапрограммировании, когда необходимо присвоить противоположное значение свойству через дескриптор Object.defineProperty . Если ваши задачи этого не требуют, то лучше воздержаться от использования Object.is , отдав предпочтение === (en-US) . Даже если в коде необходимо сравнивать два NaN , обычно проще всего использовать существующий метод isNaN , чтобы последующие вычисления не влияли на сравнение нулей с разными знаками.

Вот примеры операторов и методов, которые могут сделать различия между -0 и +0 более явными, что непременно отразиться в вашем коде:

Очевидно, что применение унарного минуса к нулю даст -0 . Но, иногда, это происходит совершенно незаметно. К примеру:

Источник