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

Сравнение JavaScript и логические операторы

Предыдущий: JavaScript Оператор

Далее: JavaScript Если … Else

Сравнение и логические операторы для тестирования истинным или ложным.

---

сравнение

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

х = 5, в приведенной ниже таблице описываются операторы сравнения:

операторы	описание	сравнить	Возвращаемое значение	примеров
==	равных	х == 8	ложный	Примеры >>
		х == 5	правда	Примеры >>
===	Абсолютно равно (значение и тип равны)	х === «5»	ложный	Примеры >>
		х === 5	правда	Примеры >>
! =	Не равно	х! = 8	правда	Примеры >>
! ==	Абсолютно не равна (или введите значение не равно)	х! == «5»	правда	Примеры >>
		х! == 5	ложный	Примеры >>
>	Более	х> 8	ложный	Примеры >>
<	Менее	х <8	правда	Примеры >>
> =	Больше или равно	х> = 8	ложный	Примеры >>
<=	Меньше или равно	х <= 8	правда	Примеры >>

---

Как использовать

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

if (age<18) x=»Too young»;

Вы узнаете больше об условных операторов в следующем разделе данного руководства.

---

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

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

При х = 6 и у = 3, в приведенной ниже таблице описываются логические операторы:

运算符	描述	例子
&&	and	(x < 10 && y > 1) 为 true
||	or	(x==5 || y==5) 为 false
!	not	!(x==y) 为 true

---

Условный оператор

JavaScript также содержит определенные условия, основанные на переменных условиях оператора присваивания.

грамматика

variablename =( condition )? value1 : value2

пример

примеров

Если переменная возраст меньше 18, а затем присваивается переменной voteable «слишком молодой», в противном случае назначить «Возраст достигнута. »

voteable=(age

Попробуйте »

Предыдущий: JavaScript Оператор

Далее: JavaScript Если … Else

4.9.2. Операторы сравнения . JavaScript. Подробное руководство, 6-е издание

Операторы сравнения определяют относительный порядок двух величин (числовых или строковых):

Меньше (<)

Оператор < возвращает true, если первый операнд меньше, чем второй операнд; в противном случае он возвращает false.

Больше (>)

Оператор

> возвращает true, если его первый операнд больше, чем второй операнд; в противном случае он возвращает false.

Меньше или равно (<=)

Оператор <= возвращает true, если первый операнд меньше или равен второму операнду; в противном случае он возвращает false.

Больше или равно (>=)

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

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

• Если какой-либо операнд является объектом, этот объект преобразуется в простое значение, как было описано в конце раздела 3.8.3: если метод valueOf() объекта возвращает простое значение, используется это значение. В противном случае используется значение, возвращаемое методом toString().

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

• Если после преобразований объектов в простые значения хотя бы один операнд не является строкой, оба операнда преобразуются в числа и сравниваются как числа. Значения 0 и -0 считаются равными. Значение

Infinity считается больше любого другого числа, а значение -Infinity — меньше любого другого числа. Если какой-либо из операндов преобразуется в значение NaN, то оператор сравнения всегда возвращает false.

Не забывайте, что строки в JavaScript являются последовательностями 16-бит-ных целочисленных значений, и сравнение строк фактически сводится к числовому сравнению этих значений в строках. Порядок кодирования символов, определяемый стандартом Юникода, может не совпадать с традиционным алфавитным порядком, используемым в конкретных языках или регионах. Обратите внимание, что сравнение строк производится с учетом регистра символов и все прописные буквы в кодировке ASCII «меньше» соответствующих им строчных букв ASCII. Это правило может приводить к непонятным результатам. Например, согласно оператору < строка «Zoo” меньше строки «aardvark”.

При сравнении строк более надежные результаты позволяет получить метод String.localeCompare(), который учитывает национальные определения «алфавитного порядка». Для сравнения без учета регистра необходимо сначала преобразовать строки в нижний или верхний регистр с помощью метода String.toLowerCase() или String.toUpperCase().

Оператор + и операторы сравнения по-разному обрабатывают числовые и строковые операнды. Оператор + отдает предпочтение строкам: если хотя бы один из операндов является строкой, он выполняет конкатенацию строк. Операторы сравнения отдают предпочтение числам и выполняют строковое сравнение, только когда оба операнда являются строками:

1+2 // Сложение. Результат: 3.

«1» + «2» // Конкатенация.

Результат: «12».

«1» +2 // Конкатенация. 2 преобразуется в «2». Результат: «12».

11 < 3 // Числовое сравнение. Результат: false.

«11» < «3» // Строковое сравнение. Результат: true.

”11″ < 3 // Числовое сравнение. «11» преобразуется в 11. Результат: false

«one» < 3 // Числовое сравнение, «one» преобразуется в NaN. Результат: false.

Наконец, обратите внимание, что операторы <= (меньше или равно) и >= (больше или равно) для определения «равенства» двух значений не используют операторы равенства или идентичности. Оператор «меньше или равно» определяется просто как «не больше», а оператор «больше или равно» — как «не меньше». Единственное исключение имеет место, когда один из операндов представляет собой значение

NaN (или преобразуется в него). В этом случае все четыре оператора сравнения возвращают false.

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

В JavaScript есть много операторов для самых разных ситуаций. Мы уже узнали о двух типах операторов:

• Арифметические операторы: + , - , * и /.
• Оператор присваивания: =

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

---

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

 > const FavoriteNumber = 42;
> любимый номер;
42
 

= называется оператором присваивания , потому что он присваивает значение справа от оператора переменной слева. В приведенном выше примере FavoriteNumber присваивается значение 42.

Другой оператор присваивания — += , потому что он также присваивает новое значение переменной слева на основе значения справа.

 > пусть myNumber = 5;
> мой номер += 1;
> мой номер;
6
 

Для каждой из математических функций: сложения, вычитания, умножения и деления существует оператор присваивания.

 +=
знак равно
знак равно
знак равно
 

При использовании любого из этих операторов присваивания значение переменной слева изменяется математической операцией и значением справа. Давайте сделаем по одному из каждого:

 > пусть testNumber = 10;
> testNumber += 5;
> номер теста;
15
> номер_теста -= 9;
> номер теста;
6
> testNumber *= 3;
> номер теста;
18
> testNumber /= 2
> номер теста;
9
 

Документация по операторам присваивания

Посетите эту ссылку для справочной страницы MDN по операторам присваивания:

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

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

---

Операторы присваивания изменяют значение переменной слева от оператора. Операторы сравнения не изменяют никаких значений, но возвращают логические значения true или false в зависимости от того, оценивается ли выражение JavaScript как истинное или ложное.

 > const myNumber = 5;
> мой номер < 10;
истинный
> мой номер > 10;
ЛОЖЬ
 

Операторы сравнения также называются реляционными операторами , потому что они помогают найти связь между двумя операндами, задавая вопросы типа «10 больше, чем 5?».

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

>

> означает «больше (и не равно)»:

• 3 > 4 оценивается как false .
• 3 > 3 также оценивается как false , потому что 3 равно 3 и не больше.
• 3 > 2 оценивается как true .

Меньше чем оператор

<

< противоположно > . Это означает «меньше (и не равно)»:

• 3 < 5 оценивается как true .
• 3 < 3 оценивается как false , поскольку они равны.

Оператор "больше или равно"

>=

>= аналогичен > , за исключением того, что он оценивается как true , если две стороны равны:

to 7 s
• >9000 правда
• 3 >= 2 также оценивается как true .

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

<=

<= является противоположностью >= . Это означает «меньше или равно»:

• 3 <= 3 оценивается как true , потому что 3 равно 3.
• 3 <= 1 оценивается как false
• 3 <= 5 оценивается как true .

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

Документация по операторам сравнения/реляционных операций

Посетите эту ссылку для справочной страницы MDN по операторам отношений:

• Реляционные операторы

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

---

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

 > const myNumber = 5;
> мой номер === 10;
ЛОЖЬ
> мой номер === 5;
истинный
 

Обратите внимание на синтаксис тройного равенства: === . Это тип оператора равенства , называемый строгим равенством . Мы используем 3 знака равенства === , когда спрашиваем, равны ли два операнда друг другу. Когда мы присваиваем переменной значение, такое как const myNumber = 5 , мы используем один знак равенства = . Их смешивание — одна из самых простых синтаксических ошибок.

В JavaScript также есть оператор равенства с двумя знаками равенства, == , но он почти никогда не используется, и его следует избегать. Попробуйте этот пример в консоли DevTools:

 > const myNumber = 5;
> мой номер === 5;
истинный
> мой номер === "5"
ЛОЖЬ
> мой номер == "5"
истинный
 

Оператор двойного равенства возвращает true при сравнении 5 == "5" , указывая, что число и строка совпадают. В то время как оператор строгого равенства с 3 знаками равенства возвращает false при сравнении 5 === "5" , потому что число и строка не являются одним и тем же типом данных. С оператором двойного равенства JavaScript делает предположение, что вы хотите, чтобы два разных типа данных оценивались одинаково. Как разработчик, вы можете не ожидать такого предположения, и это может привести к запутанным ошибкам в вашем коде.

Найдите время, чтобы больше поиграть с оператором двойного равенства и оператором строгого равенства, посетив документацию MDN:

• Оператор строгого равенства
• Двойной оператор равно

Мы также можем проверить обратное равенство — не равенство — с помощью оператора неравенства !== .

 > const myNumber = 5;
> мой номер !== 10;
истинный
> мой номер !== 5;
ЛОЖЬ
 

Операторы равенства работают и со строками.

 > const Greeting = "привет, мир";
> приветствие === "привет мир";
истинный
> приветствие === "до свидания";
ЛОЖЬ
> приветствие;
"Привет мир"
 

Обратите внимание, что если вы наберете приветствие после использования операторов равенства, вы увидите, что переменная приветствие по-прежнему содержит строку "hello world" . Операторы сравнения и равенства не изменяют значение переменной. Давайте рассмотрим еще один пример, чтобы проиллюстрировать важное различие между операторами присваивания и операторами сравнения/равенства.

 > пусть myNumber = 5;
> мой номер === 5;
истинный
> мой номер === 10;
ЛОЖЬ
> мой номер = 10;
> мой номер === 10;
истинный
> мой номер === 5;
ЛОЖЬ
 

Обратите внимание, что здесь мы используем let вместо const , потому что мы переназначаем значение myNumber на 10. Мы не смогли бы этого сделать, если бы myNumber была постоянной переменной, объявленной с const .

Вот еще несколько примеров операторов равенства.

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

===

=== означает "равно".

• 5 === 5 или "кошка" === "кошка" оценивается как истина
• 3 === 5 или "кошка" === "собака" оценивается как false .

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

!==

!== означает "не равно". Это противоположно === .

• "кошка" !== "собака" оценивается как правда
• 5 !== 5 оценивается как false , потому что утверждение, что 5 не равно 5, неверно.

Документация по операторам равенства

Посетите эту ссылку для справочной страницы MDN по операторам равенства:

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

Сравнение в JavaScript. Когда использовать двойное или тройное равенство… | Мэтт Кроак Код

Когда использовать оператор двойного или тройного равенства?

Photo by Dietmar Becker on Unsplash

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

 == или === 

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

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

Например, если var x = 'hello world' , вы можете подтвердить, что тип «x» — это строка . Попробуйте следующий код в консоли:

 var x = 'hello world' 
 console.log(typeof x)> string 

Итак, почему тип элемента имеет значение, когда дело доходит до решения, использовать ли двойной или оператор тройного равенства?

Jk Я скажу вам

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

 var x = '1' 
 var y = 1 
 console.log(x === y)> false 

А что произойдет, если вместо этого использовать оператор двойного равенства?

 var x = '1' 
 var y = 1 
 console.log(x == y)> true 

Почему это происходит? Что ж, символ двойного равенства выполняет то, что называется приведением типа перед фактическим сравнением двух значений. Это означает, что перед сравнением значения преобразуются в один и тот же тип. В приведенном выше случае x (строка) было преобразовано в 9.0006 1 (число) перед сравнением с y (число 1). Полученное сравнение доказывает, что верно , потому что 1 === 1 .

Для получения дополнительной информации о том, что определяет, какой элемент будет принудительно применен, ознакомьтесь с этой сравнительной таблицей в документации MDN.

Когда использовать какой?

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

Зачем сравнивать два значения и игнорировать типы? Один пример, который я могу вспомнить, относится к элементу select в HTML. Выбранные значения по своей сути имеют тип string . Предположим, вы визуализируете список элементов To-Do в виде опций в элементе select ниже.

 var todos = [{id: 1, title: 'item 1', subItem: 'a'}, {id: 2, title: 'item 1', subItem: 'b'}, {id: 3, title : 'item 2', subItem: 'a'},...] 

Каждой опции может быть присвоен объект id в качестве значения. Когда вы выбираете опцию, типом для e.target.value будет строка , а не число . Теперь, если вы хотите сохранить объект, соответствующий выбранному id , найти элемент по id с помощью оператора тройного равенства не получится. Поскольку тройное равенство сравнивает как значение, так и тип, e. target.value не будет равняться ни одному из идентификаторов объектов. Введите в консоль следующий код:

 var todos = [{id: 1, title: 'item 1', subItem: 'a'}, {id: 2, title: 'item 1', subItem: 'b'}, {id: 3, title: 'item 2', subItem: 'a'}]var todo = todos.find(x=>x.id === '1')console.log(todo)> undefined 

Теперь вы можете либо сделать x =>x.id === parseInt(e.target.value) , которые превращают выбранное значение в число перед его использованием в функции find . Или вы можете просто использовать оператор двойного равенства.

 var todos = [{id: 1, title: 'item 1', subItem: 'a'}, {id: 2, title: 'item 1', subItem: 'b'}, {id: 3, title : 'item 2', subItem: 'a'}]// Где e.target.value равно '1' 
 var todo = todos.find(x=>x.id == '1')console.log(todo)> {id: 1, title: "item 1", subItem: "a"} 

Приведение типов с оператор 'Not'

Приведение типа, наблюдаемое с двойным равенством, также выполняется при использовании одинарного оператора not ( != ) по сравнению с двойным оператором not ( !== ).