Тройное равно javascript: Зачем использовать тройное равенство в JavaScript?

Содержание

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

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

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

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

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

Операторы, их особенности в JS

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

Некоторые операторы(+,побитовые,логические,===) имеют специфические особенности.

В Javascript есть даже операторы >>> и <<<.

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

Проверим:

Унарный оператор «+» также используется для преобразования строки к числу:

alert(+"123"+1) // 124

Все побитовые операции работают с 4-байтовым signed int.

Операция >>> сдвигает побитово вправо, а слева нулями дополняет. В результате эффект — тот же, что и при простом сдвиге >> для положительных чисел.

Для отрицательных — все по-другому. Например, -9 в битовом виде выглядит как: 11111111111111111111111111110111.

Операция >>>

даст эффект: -9 >>> 2 будет в битовом виде 00111111111111111111111111111101, т.е 1073741821.

Логическое И. Возвращает последний операнд, если все операнды верны. Если хоть один из операндов неверен, то возвратит первый неверный операнд.

Например, 1 && 2 = 2:

1 && 0 && false === 0:

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

Например, нужно свойство petShop.animals.rabbit или ложное значение, если такого свойства нет.

Безопасный способ:

var rabbit = petShop && petShop.animals && petShop.animals.rabbit

Этот код корректно выполнится, даже если petShop = false, в то время как

var rabbit = petShop.animals.rabbit

выдаст ошибку(бросит исключение) об отсутствующем свойстве.

Оператор логического ИЛИ возвращает первое верное знач

Операторы Javascript

В JavaScript существует множество различных операторов: арифметические операторы, операторы присваивания, строковые операторы, операторы сравнения, логические операторы, операторы типов, побитовые операторы.

Оператор присваивания (=) присваивает значение переменной:


var x = 5;         // присваивает значение 5 переменной x
var y = 2;         // присваивает значение 2 переменной y
var z = x + y;     // присваивает значение 7 переменной z (x + y) 

Оператор сложения (+) складывает числа:


var x = 5;
var y = 2;
var z = x + y; 

Оператор умножения (*) перемножает числа:


var x = 5;
var y = 2;
var z = x * y; 

Арифметические операторы JavaScript

Арифметические операторы используются для выполнения арифметических операций с числами:

ОператорОписание
+Сложение
Вычитание
*Умножение
/Деление
%Остаток от деления
++Увеличение на 1
Уменьшение на 1

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

Операторы присваивания присваивают значения переменным JavaScript.

ОператорПримерАналог
=x = yx = y
+=x += yx = x + y
-=x -= yx = x — y
*=x *= yx = x * y
/=x /= yx = x / y
%=x %= yx = x % y

Строковые операторы JavaScript

Оператор сложения (+) также может использоваться для объединения (конкатенации) строк.


 txt1 = "John";
 txt2 = "Doe";
 txt3 = txt1 + " " + txt2; 

В результате в переменной txt3 будет строка — «John Doe».

Также, для конкатенации строк можно использовать оператор присваивания +=:


 txt1 = "Какой теплый ";
 txt1 += "и чудесный день";

В результате в переменной txt1 будет строка — «Какой теплый и чудесный день».

При использовании со строками оператор + еще называют оператором конкатенации.

Сложение строк и чисел

Сложение двух чисел вернет сумму этих чисел, однако сложение числа и строки вернет строку:


 x = 5 + 5;
 y = "5" + 5;
 z = "Hello" + 5;

В результате в переменных x, y, z мы получим 10, 55, Hello5 соответствен

JavaScript — Двойное отрицание (!! x)

пример

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

!!1            // true
!!0            // false
!!undefined    // false
!!{}           // true
!![]           // true

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

ложности в false .

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

x !== 0        // instead of !!x in case x is a number
x != null      // instead of !!x in case x is an object, a string, or an undefined

Использование !!x считается плохой практикой по следующим причинам:

  1. Стилистически это может выглядеть как особый синтаксис, тогда как на самом деле он не делает ничего, кроме двух последовательных отрицаний с неявным преобразованием типов.
  2. Лучше предоставить информацию о типах значений, хранящихся в переменных и свойствах через код. Например, x !== 0 говорит, что x , вероятно, является числом, тогда как !!x не дает такого преимущества читателям кода.
  3. Использование Boolean(x) допускает аналогичную функциональность и является более явным преобразованием типа.



JavaScript — Двойное равенство против тройного равенства | Брэндон Морелли

Udemy Распродажа в Черную пятницу — Тысячи курсов по веб-разработке и разработке программного обеспечения продаются всего за 10 долларов США в течение ограниченного времени! Полную информацию и рекомендации курса можно найти здесь .

Проблема

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

Triple Equals

При использовании Triple Equals === в JavaScript мы проверяем на строгое равенство . Это означает, что сравниваемые значения и должны быть одинаковыми.

Давайте посмотрим на пару примеров строгого равенства.

В этом первом примере мы сравниваем число 5 с числом 5.Как и ожидалось, возвращается true . Оба числа , и оба имеют одно и то же значение из 5.

 5 === 5 
// true

Имея это в виду, мы можем рассмотреть еще два примера, которые вернут true :

 'hello world' === 'hello world' 
// true (обе строки , равны значений ) true === true
// true (оба логических значения , равны значений
)

Отлично.Теперь давайте рассмотрим несколько примеров, которые вернут false :

В этом примере мы сравним число 77 со строковым значением из 77. Это означает, что наши операнды будут иметь такое же значение , а у другой тип . Это вернет false

  77 === '77'  
// false (Number v. String)

Вот два дополнительных примера:

  'cat' === 'dog'  
/ / false (Оба являются строками, но имеют разные значения) false === 0
// false (Другой тип и другое значение)

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

Double равно

При использовании double equals в JavaScript мы проверяем на свободное равенство. Double равно также выполняет приведение типа .

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

Это проиллюстрирует пример. Вспомните ранее, когда мы тестировали следующее со строгим равенством:

  77 === '77'  
// false (Number v.String)

77 не строго равно '77' , потому что они имеют разные типы. Однако, если бы мы проверили эти значения со слабым равенством…

  77 == '77'  
// true

Вы можете видеть, что мы получаем true . Это из-за приведения типа. JavaScript фактически попытается преобразовать наши значения в подобный тип. В этом случае это удается. Строковое значение '77' можно легко преобразовать в числовое значение 77 .Поскольку 77 равно 77 , мы получаем ответ истинный .

Рассмотрим еще один пример.

Вспомните ранее, когда мы тестировали со строгим равенством, если false равно 0 :

 false === 0 
// false (Другой тип и другое значение)

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

 false == 0 
// true

Мы получим true ? Почему это? Это связано с ложными значениями в JavaScript.Мы исследуем эту концепцию в следующем разделе.

Ложные значения

Итак, почему false == 0 в JavaScript? Это сложно, но это потому, что в JavaScript 0 — это ложное значение .

Принуждение типа фактически преобразует наш ноль в ложное логическое значение, тогда false равно false .

В JavaScript всего шесть ложных значений , о которых вы должны знать:

  • false — логическое ложное
  • 0 — нулевое число
  • «» — пустая строка
  • null
  • undefined
  • NaN — Not A Number

Сравнение ложных значений

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

  1. false , 0 и ""

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

  false == 0  
// true 0 == ""
// true "" == false
// true

2. null и undefined

При сравнении null и undefined они равны только себе и друг другу:

  null == null 
// true undefined == undefined
// true null == undefined
// true

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

3. NaN

Наконец, NaN ничему не эквивалентны.Еще круче, это даже не сам по себе!

  NaN == null 
// false NaN == undefined
// false NaN == NaN
// false

Ключевые выводы

  • Как вы видели, принуждение типа может получить немного сумасшедший в JS. Если вы не очень хорошо знакомы с JavaScript, потеря равенства может вызвать больше головной боли, чем оно того стоит. Запоминание шести ложных ценностей и правил, связанных с ними, может иметь большое значение для понимания слабого равенства.
  • Тройное равенство превосходит двойное равенство. По возможности следует использовать тройное равенство для проверки равенства. Проверяя тип и значение, вы можете быть уверены, что всегда выполняете настоящий тест на равенство.

Спасибо за чтение! Если вы готовы, наконец, изучить веб-разработку, ознакомьтесь с The Ultimate Guide to Learning Full Stack Web Development for 6 months .

Каждую неделю я публикую 4 статьи по веб-разработке. Если вы хотите, чтобы вас добавляли в мой еженедельный список рассылки, укажите здесь , введите свой адрес электронной почты , и подписывайтесь на меня в Twitter .

Если этот пост был полезен, пожалуйста, нажмите кнопку хлопка несколько раз ниже, чтобы выразить свою поддержку! ⬇⬇

.

JavaScript тройное равенство и сравнение трех переменных

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании
.

Должен ли я использовать оператор сравнения равенства === или == в JavaScript?

Вы знаете, что в JavaScript есть два разных оператора сравнения равенства: операторы === и == , или тройка равна , а double равняется , как их называют. Вы видели, как используются оба, но не уверены, какой из них выбрать для своего кода. Вы хотели бы знать верный способ решить один или другой.

Как оказалось, есть простой способ решить, какой из них использовать.Та же логика работает и для операторов сравнения неравенств ! == и ! = .

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

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

Этого определения равенства достаточно для большинства случаев использования. При сравнении строки «0» и числа 0 результат ложный, как и ожидалось.

Источники, такие как D. Crockford и MDN, рекомендуют использовать только оператор тройного равенства при программировании на JavaScript, а оператор двойного равенства вообще игнорировать.

Преобразования сложных типов выполняются с помощью ==

Оператор двойного равенства ( == ) пытается выполнить преобразование типов, если типы различаются, а затем сравнить их на равенство. Если типы различаются, сначала один или оба операнда преобразуются в общий тип. Правила преобразования сложны и зависят от типов аргументов.Полную сравнительную таблицу см., Например, в MDN или спецификации ECMAScript.

Например, при сравнении строки «0» и числа 0 первый аргумент сначала преобразуется в число.

 1
2
 
  "0" == 0
ToNumber ("0") === 0  

Хотя сравнение строк и чисел понятно, сложные правила для других типов приводят к нелогичным результатам. Например, см. Сравнения между null , undefined и false :

 1
2
3
 
  false == undefined
false == null
null == undefined  

Используйте только ===

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

Обратите внимание, что эти операторы сравнения предназначены для сравнения примитивных типов. Для сравнения глубокого равенства объектов или массивов необходим другой подход, который сравнивает операнды структурно.

.

node.js — разница в производительности JavaScript между double equals (==) и triple equals (===)

Переполнение стека
  1. Около
  2. Продукты
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
  6. О компании

Загрузка…

    .

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *