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

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

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

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

• Больше/меньше: 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 или себе и ничему другому.

Вывод: любые сравнения с

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

Итого

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

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

Операторы сравнения. HTML 5, CSS 3 и Web 2.0. Разработка современных Web-сайтов

ВикиЧтение

HTML 5, CSS 3 и Web 2.0. Разработка современных Web-сайтов
Дронов Владимир

Содержание

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

Операторы сравнения сравнивают два операнда согласно определенному условию и выдают (или, как говорят программисты, возвращают) логическое значение. Если условие сравнения выполняется, возвращается значение true, если не выполняется — false.

Все поддерживаемые JavaScript операторы сравнения приведены в табл. 14.4.

Пример:

a1 = 2 < 3;

a2 = -4 > 0;

a3 = r < t;

Переменная a1 получит значение true (2 меньше 3), переменная a2 — значение false (число –4 по определению не может быть больше нуля), а значение переменной a3 будет зависеть от значений переменных r и t.

Можно сравнивать не только числа, но и строки:

a = «JavaScript»!= «Java»;

Переменная a получит значение true, т. к. строки «JavaScript» и «Java» не равны.

На двух последних операторах из табл. 14.4 — «строго равно» и «строго не равно» — нужно остановиться подробнее. Это операторы так называемого строгого сравнения. Обычные операторы «равно» и «не равно», если встречают операнды разных типов, пытаются преобразовать их к одному типу (о преобразованиях типов см. далее в этой главе). Операторы строгого равенства и строгого неравенства такого преобразования не делают, а в случае несовпадения типов операндов всегда возвращают false.

Пример:

a1 = 2 == «2»;

a2 = 2 === «2»;

Переменная a1 получит значение true, т. к. в процессе вычисления строка «2» будет преобразована в число 2, и условие сравнение выполнится. Но переменная a2 получит значение false, т. к. сравниваемые операнды принадлежат разным типам.

Данный текст является ознакомительным фрагментом.

Операции сравнения

Операции сравнения Операции сравнения используются для сопоставления операндов. В этих операциях операндами могут быть не только числа, но и строки, логические величины и объекты. В табл. 11.8 приведены все операции сравнения.Таблица 11.8. Операции сравнения В листинге 11.10

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

Операторы отношения и логические операторы Операторы отношения используются для сравнения значений двух переменных. Эти операторы, описанные в табл. П2.11, могут возвращать только логические значения true или false.Таблица П2.11. Операторы отношения Оператор Условие, при

Функции сравнения

Функции сравнения strcmpСравнивает строки. Синтаксис:int strcmp(string str1, string str2)Эта функция сравнивает две строки посимвольно (точнее, бобайтово) и возвращает:Так как сравнение идет побайтово, то регистр символов влияет на результаты сравнений.strncmpСравнивает начала

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

Операторы сравнения Операторы сравнения сравнивают два операнда согласно определенному условию и выдают (или, как говорят программисты, возвращают) логическое значение. Если условие сравнения выполняется, возвращается значение true, если не выполняется — false.Все

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

Операторы сравнения Операторы сравнения возвращают значение типа Boolean:• = — равно;• &lt;&gt; — не равно;• &lt; — меньше;• &gt; — больше;• &lt;= — меньше или равно;• &gt;= — больше или

Сравнения (Comparisons)

Сравнения (Comparisons) Библиотека обеспечивает базовые классы функциональных объектов для всех операторов сравнения языкаtemplate ‹class T›struct equal_to: binary_function‹T, T, bool› { bool operator()(const T&amp; x, const T&amp; y) const {return x == y;}};template ‹class T›struct not_equal_to: binary_function‹T, T, bool› { bool operator()(const T&amp; x, const T&amp; y) const

Процедуры сравнения

Сравнения

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

Операции сравнения

Операции сравнения Операции сравнения &lt;, &gt;, &lt;=, &gt;=, =, &lt;&gt; возвращают значение типа boolean и применяются к операндам простого типа и к строкам.Операции = и &lt;&gt; также применяются ко всем типам. Для размерных типов по умолчанию сравниваются значения, для ссылочных типов —

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

Кратко

Логические операторы помогают составлять сложные логические условия, которые часто нужны при ветвлении с помощью if. ..else.

❗

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

Как пишется

И,

Интернет-магазин показывает цены со скидкой только зарегистрированному пользователю, сделавшему больше одной покупки.

В описании два условия, которые должны одновременно быть верными:

• пользователь должен быть зарегистрирован;
• количество покупок должно быть больше одной.

Если одно из условий, или оба сразу неверны, то цену показывать не нужно.

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

if (isRegistered === true && orders > 1) {  // показываем цены}
          if (isRegistered === true && orders > 1) {
  // показываем цены
}

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

ИЛИ,

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

Чтобы написать такое составное условие, воспользуйся оператором логического ИЛИ, обозначается как две вертикальные черты ||. Логическое или вернёт true, если хотя бы одно из условий true.

Генерируйте гостей в демо и смотрите, как отрабатывает условие, которое записано так:

if (hasTicket || isInvited) { . .. }
          if (hasTicket || isInvited) { ... }

НЕ

Оператор «логическое НЕ» превращает true в false и наоборот.

Он записывается в виде восклицательного знака ! перед операндом: !операнд . Чаще всего это переменная. Например, !myVariable . Операторы, которые производят операцию над одним операндом называются унарными.

Например, мы можем предлагать купить билет посетителю без билета:

if (!hasTicket) {  // купи билет, дорогой!}
          if (!hasTicket) {
  // купи билет, дорогой!
}

На практике

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

🛠 Оператор «ИЛИ» (||) можно использовать для установки значения по умолчанию, для этого следует воспользоваться следующей конструкцией:

value = value || 'Значение по умолчанию'
          value = value || 'Значение по умолчанию'

Или можно использовать сокращённый вариант:

value ||= 'Значение по умолчанию'
          value ||= 'Значение по умолчанию'

❗

Нужно помнить, что если в переменную записать undefined, null, NaN, 0, пустую строку или любое другое значение, которое JavaScript сможет привести к false, то данная конструкция перезапишет его значением по умолчанию.

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

let searchEngine1 = 'Яндекс'let searchEngine2searchEngine1 = searchEngine1 || 'Google'searchEngine2 = searchEngine2 || 'Google'console.log(searchEngine1)// Яндексconsole.log(searchEngine2)// Google (значение по умолчанию)
          let searchEngine1 = 'Яндекс'
let searchEngine2
searchEngine1 = searchEngine1 || 'Google'
searchEngine2 = searchEngine2 || 'Google'
console.log(searchEngine1)
// Яндекс
console.log(searchEngine2)
// Google (значение по умолчанию)

Такой способ работает из-за особенности оператора «ИЛИ»: он не приводит значения к типу Boolean, а просто возвращает то, что стоит левее или правее.

• Если левое значение можно привести к true, то оператор возвращает левое значение.
• Если левое значение можно привести к false, то оператор возвращает правое значение.

console.log(null || 0)// 0console.log(0 || null)// nullconsole.log('Собака' || 'Кошка')// Собака
          console.log(null || 0)
// 0
console.log(0 || null)
// null
console.log('Собака' || 'Кошка')
// Собака

В последнем примере JavaScript приводит левое значение к типу Boolean и получает true, из-за чего решает вернуть именно его ('Собака'), а правое – даже не смотрит.

🛠 Оператор «И» (&&) можно использовать в React компонентах, когда мы хотим что-то показать или спрятать в зависимости от определённого условия, для этого нужно воспользоваться следующей jsx конструкцией:

<>  {    condition &&    <p>      Если condition == true,      то показываем этот текст.    </p>  }</>
          <>
  {
    condition &&
    <p>
      Если condition == true,
      то показываем этот текст.
    </p>
  }
</>

Давайте напишем небольшой компонент, который будет выводить секретное сообщение только тем пользователям, которые ввели правильный пароль:

import React, { useState } from 'react'export default function App() {  const [password, setPassword] = useState('')  return (    <>      <h2>Введите пароль, чтобы увидеть секрет</h2>      <label>        <span>Пароль</span>        <input          type="password"          value={password}          onChange={(e) => setPassword(e. target.value)}        />      </label>      {        password === '123456' &&        <p>Секрет: Дока – сокращение от «документация»</p>      }    </>  )}
          import React, { useState } from 'react'
export default function App() {
  const [password, setPassword] = useState('')
  return (
    <>
      <h2>Введите пароль, чтобы увидеть секрет</h2>
      <label>
        <span>Пароль</span>
        <input
          type="password"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
        />
      </label>
      {
        password === '123456' &&
        <p>Секрет: Дока – сокращение от «документация»</p>
      }
    </>
  )
}

Такой способ работает из-за того, что оператор «И» не приводит значения к типу Boolean, а просто возвращает то, что стоит левее или правее.

• Если левое значение можно привести к true, то оператор возвращает правое значение.
• Если левое значение можно привести к false, то оператор возвращает левое значение.

console.log(null && 0)// nullconsole.log(0 && null)// 0console.log('Лево' && 'Право')// Право
          console.log(null && 0)
// null
console.log(0 && null)
// 0
console.log('Лево' && 'Право')
// Право

JavaScript приводит левое значение к типу Boolean и получает true, из-за чего решает вернуть правое значение ('Право').

🛠 Двойное отрицание (!!) можно использовать, если мы хотим привести значение к логическому типу данных. Такой же результат получится, если использовать функцию Boolean.

const value = 'Непустая строка'console.log(Boolean(value))// trueconsole.log(!!value)// true
          const value = 'Непустая строка'
console.log(Boolean(value))
// true
console.log(!!value)
// true

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

Цели

• Объяснить различные операторы сравнения в JS
• Объяснение операторов строгого сравнения
• Использовать операторы строгого сравнения

О

Напомним, что операторы сравнения позволяют проверять отношения (равенство и идентичность) между объектами. Вы будете кодировать в js/comparison.js . Убедитесь, что вы запускаете выучить -b для запуска тестов.

Список

К настоящему времени вы знаете о следующих операторах сравнения:

Оператор	Описание	Пример
==	проверяет, равны ли значения двух операндов. Если да, то возвращает true	(10 == 20) неверно; поэтому возвращает false
!=	проверяет, равны ли значения двух операндов. Если значения не равны, возвращает true	(а != б) верно; следовательно возвращает true
>	проверяет, больше ли значение левого операнда значения правого операнда. Если левый операнд больше правого операнда, возвращает true	(10 > 20) неверно, поэтому возвращает false
<	проверяет, меньше ли значение левого операнда значения правого операнда. Если левый операнд меньше правого операнда, возвращает true	(10 < 20) верно
>=	проверяет, больше ли значение левого операнда или равно значению правого операнда. Если это так, возвращает true; иначе возвращает ложь	(10 >= 20) неверно
<=	проверяет, меньше ли значение левого операнда или равно значению правого операнда. Если левый операнд меньше или равен правому операнду, возвращает true; иначе возвращает ложь	(10 <= 20) верно

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

В JavaScript помимо обычных операторов сравнения имеется операторов строгого сравнения ; которые являются строгим равенством ( === ) и строгим не равенством ( !== ).

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

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

• Определите функцию testFalseLooseEqualityComparison , которая не принимает никаких параметров. В этой функции определите две переменные. Первая переменная должна хранить целое число 0 , а вторая — целое число 1 . Возвращаемое значение функции должно быть оценкой нечеткого сравнения на равенство ( == ) двух переменных. Возвращаемое значение должно быть false , потому что 0 и 1 не являются одним и тем же значением.

• Определите функцию testTrueLooseNonEqualityComparison , которая не принимает никаких параметров. В этой функции определите две переменные, одна из которых хранит 0 , а другая хранит 1 . Возвращаемое значение функции должно быть оценкой произвольного сравнения неравенства ( != ) двух переменных. Возвращаемое значение должно быть true , потому что 0 и 1 не равны.

• Определение функции testTrueLooseEqualityComparison , который не принимает никаких параметров. Функция должна содержать две переменные, одна из которых хранит 1 , а другая хранит "1" . Возвращаемое значение должно быть оценкой нечеткого сравнения равенства ( == ) между двумя переменными. Возвращаемое значение должно быть true , потому что в JavaScript 1 и "1" равны по значению.

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

С другой стороны, операторы строгого сравнения ( === и !== ) сравнивают равенство типов и значений.

• Определите функцию testFalseStrictEqualityComparison , которая не принимает никаких параметров. Внутри функции определите две переменные, одна из которых хранит 1 , а другая хранит "1" . Возвращаемое значение функции должно быть результатом строгого сравнения на равенство ( === ) между двумя переменными. Возвращаемое значение должно быть false , потому что 1 и "1" не являются одним и тем же типом данных.

• Определите функцию testTrueStrictEqualityComparison , которая не принимает никаких параметров. Внутри функции определите две переменные, одна из которых хранит 1 , а другая хранит "1" . Возвращаемое значение функции должно быть результатом строгого сравнения на равенство ( === ) между переменной, хранящей целое число, и parseInt значение переменной, хранящей строку.

Вот пример:

 20 == '20' //=> true
20 === '20' //=> ложь
 

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

ВЫ ПОЧТИ ВСЕГДА ХОТИТЕ ИСПОЛЬЗОВАТЬ === или !== .

Использование неявного приведения типов в JavaScript приводит к появлению в коде незаметных и трудно отслеживаемых ошибок. Используйте === и !== . Единственным исключением является случай, когда вы имеете дело со значением, которое может быть null или undefined , но также может быть 0 или false . В этом случае простой if (variable) { ... } не сработает, потому что все вышеперечисленное ложно. Но мы можем проверить if (variable == null) { ... } или if (variable != null) { ... } , чтобы поймать null и undefined , но не 0 и ложь .

Ресурсы

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

Просмотрите операторы сравнения JavaScript на Learn.co и начните бесплатное обучение программированию.

Открой свое будущее в сфере технологий

Научись программировать.

Начало подготовки к Coding Bootcamp

Связанные темы

• Основы Javascript

• Основы JS Лаборатория онлайн-покупок
• Подъем
• Хеш-файлы

  006

• Intro To Comparison Operators in JS
• Strings in JS

• jQuery

• jQuery Event Listeners
• jQuery Methods
• jQuery Selectors Lab
• Modifying HTML with jQuery
• Stop Propogation

• Object Ориентированный Javascript

• Объектно-ориентированный Javascript
• Создание объектов в JS
• JS Tweet Shortener Lab
• JS Github API Lab
• Объектные методы в JS Lab

Узнайте о миссии школы Flatiron

Как школа Flatiron делает программистов

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

WeWork x Flatiron School Houston Expansion

За шесть месяцев после того, как WeWork приобрела Манхэттенскую школу кодирования, она открыла филиалы в Вашингтоне, округ Колумбия, Бруклине и Лондоне. Теперь WeWork открывает четвертую школу Flatiron School, на этот раз в Хьюстоне.

Учебные курсы по программированию будут расширяться

Адам Энбар, соучредитель Flatiron School, считает, что сейчас самое время расти. «То, как меняется мир, очень похожим образом повлияло на работу и обучение. Мы думаем, что в основе образования лежит одна цель: дать людям возможность жить лучше».

Узнать. Любовь. Код.

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

View Our Courses

• Coding Bootcamp Prep
• Data Science Bootcamp Prep
• Intro to Ruby
• Intro to JavaScript

Find Us

Специальные возможности

Положения и условия

Кодекс поведения

Политика конфиденциальности

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

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

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

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

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

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

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

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

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

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

Operator	Name	Example	Result
==	Equals	x == y	true if x is equal to y . Типы могут быть разными
===	Идентичный	x === y	true , если x равно y , и типы идентичны.
!=	Не равно	x != y	верно , если x не равно y . Типы могут быть разными
!==	Не идентичны	x !== y	true если x не равно y , или если типы, если разные
<	Меньше	x	True IF x меньше y
2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	2	. To	x <= y	true if x is less than or equal to y
>	Greater Than	x > y	true if x is greater than y
>=	Greater Than or Equal To	x >= y	true if x is greater than or equal to y

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

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

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

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

 1 == 1 // правда
'1' == 1 // правда
1 == '1' // правда
0 == ложь // правда
0 == ноль // ложь
0 == не определено // ложь
null == undefined // true 

 1 != 1 // ложь
"1" != 1 // ложь
1 != '1' // ложь
0 != ложь // ложь
0 != ноль // правда
0 != не определено // правда
null != не определено // ложь 

 1 === 1 // правда
"1" === 1 // ложь
1 === '1' // ложь
0 === ложь // ложь
0 === ноль // ложь
0 === не определено // ложь
null === undefined // false 

 1 !== 1 // ложь
"1" !== 1 // правда
1 !== '1' // правда
0 !== ложь // правда
0 !== ноль // правда
0 !== не определено // правда
null !== undefined // true 

 [1,2,3] == [1,2,3]; // ЛОЖЬ
[1,2,3] === [1,2,3]; // ЛОЖЬ
{ х: 1, у: 2 } == { х: 1, у: 2 } // ложь
{ x: 1, y: 2 } === { x: 1, y: 2 } // false