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

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

Илья Кантор, 25 мая 2009 — 13:26 Описание, примеры Операндами операторов сравнения могут быть численные и строковые значения. Строки сравниваются, исходя из стандартного лексикографического порядка при использовании Unicode. Яваскрипт допускает как строгое сравнение, так и сравнение с приведением типов. Для строгого сравнения оба операнда должны иметь одинаковый тип и: Две строки строго равны, если состоят из одинаковой последовательности символов Два числа строго равны, если равны в обычном смысле слова. +0 строго равен -0. NaN строго не равно ничему, включая NaN Два булевых операнда строго равны, если они оба true или false Два операнда-объекта строго равны, если являются ссылками на один и тот же общий объект Null и Undefined равны ==, но не строго равны === Следующая таблица описывает операторы сравнения: Оператор Описание Примеры, возвращающие true при var1=3, var2=4 Равно (==) Если два операнда не одного типа, javascript преобразовывает типы и сравнивает строго. Если какой-либо операнд — число или булево значение, то операнды преобразуются в числа; если какой-либо операнд строка — второй преобразуются в строку 3 == var1 "3" == var1 3 == '3' Не равно (!=) Возвращает true, если операнды не равны. Если операнды имеют разный тип, javascript преобразовывает. var1 != 4 var1 != "5" Строго равно (===) Возвращает true, если операнды строго равны (см. выше), без преобразования типов. 3 === var1 Строго не равно (!==) Возвращает true, если операнды не являются строго равными (см. выше) или имеют разные типы. var2 !== 3 3 !== '3' Больше (>) Возвращает true, если левый операнд больше правого. var2 > var1 Больше или равно (>=) Возвращает true, если левый операнд больше правого или равен ему. var2 >= var1 var1 >= 3 Меньше (<) Возвращает true, если левый операнд меньше правого. var1 < var2 Меньше или равно (<=) Возвращает true, если левый операнд меньше правого или равен ему. var1 <= var2 var2 <= 5 Стандартные операторы равенства (== и !=) сравнивают два операнда безотносительно их типа. Строгое равенство (=== и !==) производит сравнения операндов одинакового типа. Используйте строгое равенство, если операнды должны иметь одинаковый тип и значение. В ином случае, используйте обычные операторы равенства, которые позволяют проверить равенство операндов, даже если они разного типа. При конвертации типов яваскрипт преобразует String, Number, Boolean и Object следующим образом: При сравнении числа и строки, строка преобразуется в числовое значение. Яваскрипт при этом получает значение числа из строкового литерала: "123" == 123. Если один из операндов — булевый, то он преобразуется к 1, если он true и к +0, если он false Если объект сравнивается с числом или строкой, яваскрипт пытается получить соответствующее значение для объекта. Он преобразует объект к элементарному значению, строке или числу, используя методы valueOf и toString. Если преобразовать объект не удается — генерируется ошибка выполнения. См. также Выражения /Стандарт языка/

Поиск по сайту Содержание Введение Основы javascript DOM: работа с HTML-страницей События Объекты, ООП AJAX Особенности регулярных выражений в Javascript Базовые типы: Строки, Числа, Boolean Операторы, их особенности в JS Массивы Функции Замыкания Регулярные выражения Конструкции языка. Обработка ошибок. Редактирование и отладка скриптов Cookie HTTP-Отладка Просмотр живого HTML Разное полезное Drag and drop Грамотное javascript-дерево за 7 шагов Интеграция AJAX в интерфейс Координаты элемента на странице Правильные show/hide/toggle Удобное дерево с AJAX-подгрузкой Введение в Ajax Ajax и Rich Client Ajax и клиент-серверная архитектура. Способы общения с сервером COMET Форматы данных для AJAX Обмен данными для документов с разных доменов Обмен данными между доменами. Часть 2. Google Closure Compiler в деталях Yahoo: лучшие способы ускорения сайта Анализ оптимизации страниц c Yslow Интерфейсы. Прочь от MVC Оптимизация Javascript-кода Польза от documentFragment Сжатие Javascript и CSS Улучшаем сжимаемость Javascript-кода. Умное Кеширование и Версионность в Javascript/CSS Асинхронное программирование Google Gears в деталях Javascript <-> Flash мост Букмарклеты и правила их написания О подборке книг на сайте Почему <a href=»javascript:. ..»> — плохо Способы идентификации в интернете Уровни DOM Что почитать? Шаблонизация с javascript Юнит-тесты уровня браузера на связке Selenium + PHP. Справочники: Javascript/HTML/CSS Система сборки и зависимостей Google Closure Library Хранение данных на клиенте. DOM Storage и его аналоги. 10 лучших функций на JavaScript Дерево всех статей

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

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

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

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

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

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

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

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

Например:

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

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

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

Аналогом «алфавита» во внутреннем представлении строк служит кодировка, у каждого символа – свой номер (код). JavaScript использует кодировку Unicode.

При этом сравниваются численные коды символов. В частности, код у символа Б больше, чем у А, поэтому и результат сравнения такой.

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

Поэтому регистр имеет значение:

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

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

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

Например:

• Если первая буква первой строки больше – значит первая строка больше, независимо от остальных символов:

• Если одинаковы – сравнение идёт дальше. Здесь оно дойдёт до третьей буквы:

• При этом любая буква больше отсутствия буквы:

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

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

, которую ввел посетитель.

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

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

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

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

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

Например:

Тема преобразований типов будет продолжена далее, в главе Преобразование типов для примитивов.

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

В обычном операторе == есть «проблема» – он не может отличить 0 от false:

Та же ситуация с пустой строкой:

Это естественное следствие того, что операнды разных типов преобразовались к числу. Пустая строка, как и false, при преобразовании к числу дают 0.

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

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

Если тип разный, то они всегда возвращают false:

Строгое сравнение предпочтительно, если мы хотим быть уверены, что «сюрпризов» не будет.

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

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

Интуитивно кажется, что null/undefined эквивалентны нулю, но это не так.

Они ведут себя по-другому.

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

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

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

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

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

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

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

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

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

Несравнимый undefined

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

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

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

Желательно не использовать сравнения >= > < <= с ними, во избежание ошибок в коде.

Итого

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

Мы ещё вернёмся к теме сравнения позже, когда лучше изучим различные типы данных в JavaScript.

javascript — Разница между != и !==

спросил 6 лет, 1 месяц назад

Изменено 21 день назад

Просмотрено 65 тысяч раз

В этой функции при сравнении длины массива используется оператор !=, а при сравнении всех элементов массива используется оператор !==. Почему?! Спасибо.

 переменная а = [1,2,3];
вар б = [2,3,4];
функция equalArrays(a,b){
    если (a.length != b.length) вернуть ложь;
    for(var i = 0; i < a.length; i++)
        if(a[i] ==! b[i]) вернуть false;
    вернуть истину;
 

}

• JavaScript

4

= — оператор присваивания, например. Если вы запустите var x = 1; , то x будет иметь значение 1 .

== (или != ) — это оператор сравнения, который проверяет, равно ли значение чего-то значению чего-то другого. например if(x == 1) будет оцениваться как true , так же как и if(x == true) , потому что 1 будет оцениваться как true , а 0 оцениваться как false .

=== (или !== ) — это еще один оператор сравнения, который проверяет, равно ли значение чего-то значению и того же типа, что и что-то еще. например if(x === 1) будет оцениваться как true однако if(x === true) будет оцениваться как false потому что 1 (значение x ) является целым числом и true — логическое значение.

0

Тройное равенство (===) проверяет не только значение, но и тип.

Верно следующее:

 ложь == ложь
ложь == 0
2 == "2"
 

Неверно следующее:

 ложь === ноль
ложь === не определено
ложь === 0
2 === "2"
 

---

вернусь к этому несколько лет спустя... пришлось отредактировать свой ответ, потому что следующее

 false != undefined
ложь != ноль
ноль == не определено
 

0

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

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

 if( '5' !== 5 ){
    вернуть ложь
}еще{
    вернуть истину;
}
 

Приведенный выше фрагмент вернет false, потому что два операнда относятся к разным типам. Но это не может быть поймано != , я имею в виду:

 если( '5' != 5 ){
    вернуть ложь;
}еще{
    вернуть истину;
}
 

вернет true.

Помните, что:

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

• Две строки строго равны, если они имеют одинаковую последовательность символов, одинаковую длину и одинаковые символы в соответствующих позициях.

• Два числа строго равны, если они численно равны (имеют одинаковое числовое значение). NaN ничему не равен, в том числе и NaN. Положительные и отрицательные нули равны друг другу.

• Два логических операнда строго равны, если оба истинны или оба ложны.

• Два объекта строго равны, если они ссылаются на один и тот же объект.

• Типы Null и Undefined — это == (но не ===). [Т.е. (Null==Undefined) истинно, но (Null===Undefined) ложно]

Цитата из: https://stackoverflow.com/a/523647

!== означает, что две переменные проверяются как на их значение, так и на их тип значения ( 8!==8 вернет false в то время как 8!=="8" возвращает true). != проверяет только значение переменной ( 8!=8 и 8!="8" вернут false).

Оператор !== возвращает значение true, если элементы не имеют равного значения или неравного типа.

Источник: W3Schools

Операторы сравнения JavaScript - Pi My Life Up

Из этого туториала вы узнаете, как использовать операторы сравнения в языке JavaScript.

Операторы сравнения позволяют сравнивать значение левого операнда с правым операндом. Затем JavaScript вернет true или false в зависимости от того, верно ли это сравнение.

Операторы сравнения являются неотъемлемой частью JavaScript и помогут вам написать полезные условия для операторов if.

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

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

  Например, число 1 будет соответствовать строке "1" при использовании свободного сравнения.

• Когда JavaScript выполняет « strict ” сравнение, переменные будут совпадать только в том случае, если типы данных совпадают.

  Если типы данных различаются, сравнение вернет false и не будет считаться равным.

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

Оператор	Имя	Пример	Результат
==	Равно	x == y	истинно , если x равно y . Типы могут быть разными
===	Идентичные	x === y	true if x равно y , и являются идентичными типами.
!=	Не равно	x != y	true , если x не равно и . Типы могут быть разными
!==	Не идентичные	x !== y	true если x не равно 9 или 9023 x не равно y типы разные,
<	Меньше	x < y	true , если x меньше y
<=	Меньше 90 или 2 = у	правда , если x меньше или равно y
>	Больше	x > y	истинно больше у
>=	Больше или равно	x >= y	true , если x больше или равно y

90974 Примеры сравнения в JavaScript

2 В следующих нескольких разделах мы рассмотрим, как использовать каждый поддерживаемый оператор сравнения в JavaScript.

В каждом примере объясняется, как использовать оператор и когда этот оператор возвращает значение true или false.

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

== ) в JavaScript

Оператор сравнения равенства ( == ) в JavaScript позволяет проверить, равны ли два значения. Типы данных этих двух значений могут быть разными, пока JS может жонглировать ими, чтобы они были одинаковыми.

Чтобы продемонстрировать это, давайте рассмотрим следующий фрагмент кода. Каждый из вызовов « console.log() » содержит сравнение, показывающее различное использование оператора равенства.

• В первом сравнении мы просто сравниваем, равно ли число 10 10 . Поскольку эти значения равны, оператор вернет true .
• В этом втором журнале мы используем оператор сравнения, чтобы проверить, соответствует ли число 10 соответствует строке "10" .

  Хотя это разные типы, оператор « равно » позволяет JavaScript жонглировать типами, чтобы увидеть, совпадают ли значения. Это сравнение вернет true, так как JavaScript может преобразовать строку "10" в 10 .

• Окончательный журнал показывает, что использование оператора сравнения для сравнения двух значений не совпадает.

  Поскольку 10 не равно 11 , этот оператор вернет ложь .

Ниже вы можете увидеть результат каждого из наших сравнений в JavaScript.

Идентичный оператор (

=== )

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

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

Возьмем те же три « console.log() », которые мы использовали в предыдущем примере, чтобы продемонстрировать это изменение поведения.

• Первый пример вернет true, так как оба значения равны и оба являются числами.
• Во втором примере идентичный оператор JavaScript вернет false .

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

• Для последнего примера JavaScript по-прежнему будет возвращать false для этого сравнения.

  Идентичный оператор сравнения возвращает false, поскольку 10 не равно 11 .

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

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

!= )

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

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

После запуска приведенного выше примера вы должны получить следующий результат. Этот результат показывает, как JavaScript оценивал каждое использование оператора «не равно».

Неидентичный оператор (

!== )

Неидентичный оператор сравнения ( !== ) в JavaScript очень похож на оператор не равно. Однако не идентичный оператор выполняет строгое сравнение. Это означает, что если типы данных различаются, JavaScript вернет true .

Чтобы продемонстрировать это более строгое поведение, давайте возьмем тот же пример, который мы использовали в предыдущих трех примерах.

• Не идентичный оператор все равно вернет false для первого примера. Это связано с тем, что 10 равно 10 и имеют одинаковые типы данных.
• Во втором примере этот оператор вернет true . Этот ответ связан с тем, что типы данных значений различаются.
• В последнем примере неидентичный оператор все равно вернет true . Это потому, что 10 не равно 11 .

Вы можете увидеть, как этот оператор сравнения ведет себя в JavaScript, посмотрев на результат ниже. Вы можете увидеть, как оценивалось каждое выражение.

Оператор сравнения «меньше чем» в JavaScript (

< )

Оператор сравнения «меньше чем» в JavaScript ( < ) позволяет вам сравнивать, меньше ли одно значение, чем другое.

• Этот оператор вернет true только в том случае, если значение на меньше сравниваемого значения на .
• Если значения равны, возвращается false .

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

• Для первого сравнения мы проверяем, меньше ли 10 20 .

  Так как 10 меньше, чем 20 , оператор меньшего значения вернет true .

• Во-вторых, проверяем, меньше ли 10 на , чем 10 .

  Поскольку эти значения равны, оператор вернет false .

• При окончательном сравнении проверяем, 10 на меньше, чем 5 .

  Поскольку 10 больше, чем 5 , оператор "меньше чем" вернет false .

Ниже вы можете увидеть результат меньшего оператора сравнения в JavaScript. JavaScript оценил только первый пример как true .

Оператор меньше или равно (

<= )

Оператор меньше или равно ( <= ) полезен для сравнения значений, когда вы хотите, чтобы оператор возвращал верно , даже если значения совпадают.

• Если значения равны, оператор вернет true .
• Оператор вернет true , если значение слева меньше значения справа.

Давайте рассмотрим три быстрых примера, чтобы показать, как работает оператор сравнения меньше или равно в JavaScript.

• Первое сравнение вернет true . Это связано с тем, что 10 меньше 20 .
• Наше второе использование оператора меньше или равно в JavaScript также вернет true . Это потому, что 10 равно 10 .
• Окончательное сравнение вернет false , поскольку 10 больше 5 .

Ниже вы можете увидеть результат вышеприведенных операторов сравнения в JavaScript.

Оператор больше чем (

> )

Оператор больше чем в JavaScript ( > ) противоположен оператору «меньше». Следовательно, этот оператор сравнения вернет true, если левый операнд больше правого.

Если значения равны, то оператор больше возвращает false .

В приведенном ниже примере вы можете увидеть, как оператор сравнения «больше чем» работает в JavaScript.0023 верно .

Поскольку 20 равно 20 , второе сравнение вернет false .

15 меньше 20 , поэтому окончательное сравнение также вернет false .

Ниже вы можете увидеть результат вышеприведенного использования оператора сравнения «больше чем» в JavaScript.

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

>= ) в JavaScript

Последний оператор сравнения JavaScript, который мы будем изучать, — это оператор сравнения больше или равно ( >= ).

Этот оператор вернет true , когда значение слева больше или равно значению справа.

Чтобы продемонстрировать поведение этого оператора, воспользуемся теми же примерами, что и в предыдущем операторе.