Операторы ===и являются операторами строгого!== сравнения . Это означает, что если операнды имеют разные типы, они не совпадают. Например,

1 === "1" // false
1 !== "1"  // true
null === undefined // false

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

1 == "1" // true
1 != "1" // false
null == undefined // true

Стоит отметить, что оператор ==не является транзитивным , в отличие от ===.

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

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

Я не помню всех тонкостей оператора ==, поэтому давайте заглянем в спецификацию, пункт 11.9.3:

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

Сравнение x == y , где x и y — значения, возвращает true или false . Это сравнение делается следующим образом:

1. Если тип (x) и тип (y) совпадают,
   1. Если Type(x) имеет значение Undefined , он возвращает true .
   2. Если Type(x) равен Null , он возвращает true .
   3. Если Type(x) равно Number ,
      1. Если x равно NaN , возвращается false .
      2. Если y равно NaN , вернуть false .
      3. Если x является тем же значением Number , что и y , возвращается true .
      4. Если x равно +0 и y равно −0 , вернуть true .
      5. Если x равно -0 и y равно +0 , вернуть true .
      6. Вернуть ложь .
   4. Если Type(x) равно String , функция возвращает true , если x и y представляют собой точно такую ​​же последовательность символов (с одинаковой длиной и одинаковыми символами в соответствующих позициях). В противном случае возвращается false .
   5. Если Type(x) имеет значение Boolean , он возвращает true , если x и y оба равны true или оба false . В противном случае возвращается false .
   6. Возвращает true , если x и y относятся к одному и тому же объекту. В противном случае возвращается false .
2. Если x равно null , а y не определено , вернуть true .
3. Если x не определено , а y равно null , вернуть true .
4. Если Type(x) — это число , а Type(y) — это String ,
   вернуть результат сравнения x == ToNumber(y) .
5. Если Type(x) — это String , а Type(y) — это Number ,
   вернуть результат сравнения ToNumber(x) == y .
6. Если Type(x) имеет значение Boolean , вернуть результат сравнения ToNumber(x) == y .
7. Если Type(y) имеет значение Boolean , вернуть результат сравнения x == ToNumber(y) .
8. Если Type(x) — это String или Number , а Type(y) — это Object ,
   вернуть результат сравнения x == ToPrimitive(y) .
9. Если Type(x) — это Object , а Type(y) — это String или Number ,
   вернуть результат сравнения ToPrimitive(x) == y .
10. Вернуть ложь .

Этот ответ является переводом моего ответа на этот же вопрос на русском сайте .

Разница в том, что == сначала пытается преобразовать типы перед их сравнением. Оператор === этого не делает, он выполняет прямое сравнение, хотя всегда возвращает false, если типы разные. источник (на английском языке)

бывший:

1 == "1" // verdadero    
1 === "1" // falso
'' == 0 // verdadero
'' === 0 // falso

Эти графики могут помочь вам визуализировать разницу:

'==' оператор

Оператор '==='

( источник изображений )

Он эффективно ==сравнивает значение, а ===также сравнивает тип. Например.

"1" == 1 // true
"1" === 1 // false
null == undefined // true
null === undefined // false

Вы можете прочитать технические подробности (на английском языке) в разделе «Сравнения и одинаковость».

undefinedявляется зарезервированным словом и используется без кавычек.

Не совсем. Это правда, что оператор ===сравнивает тип и значение, не выполняя преобразования, как это сделал бы оператор ==. Однако это верно только для типов значений. В ссылочных типах он проверяет, что это один и тот же объект, недостаточно того, что он имеет тот же тип и значение. Таким образом, это ===будет оператор идентификации, а не ==.

Например:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

a === b  // false
a === c  // true

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

Также обратите внимание, что оператор ==не является транзитивным в некоторых преобразованиях. Например:

'' == '0'  // false
0 == ''    // true

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

В любом случае, вы можете взглянуть на эту страницу , которая разрешит сомнения относительно обоих операторов. Там вы можете проверить среди прочего, что undefined == nullно undefined !== null.

очень простой

==это равенство значения, а не типа.
===является равенством значения и типа.

 console.log("1 == '1   =>", 1 == '1')  // true
 console.log("1 === '1' =>", 1 === '1') // false, ya que uno es un string.
 console.log("1 === 1   =>", 1 === 1)   // son iguales

На ваш вопрос уже был дан правильный ответ, но я хотел бы прокомментировать то, что кажется вашей проблемой (я также начал с java, и есть определенные вещи, которые javascript упрощает).

Переменная может иметь 2 состояния: «не определено» или иметь что-то, нуль, поскольку в SQl это тип значения, то есть, если ваша переменная имеет значение null, она определена и имеет что-то, ничего, кроме чего-то: P, undefined означает, что ваша переменная не была определена, этот факт любопытен, особенно потому, что null == undefined отвечает true.

Теперь, когда вы ищете элемент с помощью js и не находите его (например, document.getElementById("inpt")), его значение равно null, в случае, если вы находите его, вы запрашиваете его значение, а если нет нет, он отвечает "" .

Самое интересное, что с простым, если вы решаете многое.

var una,dos = null,tres =[],cuatro = 1;

if(noexisto) //es undefinided, saca error por que estas preguntando por ella
if( typeof notoy == "undefined") //es la manera correcta de preguntar si una variable no ha sido definida
if(una)//false pero no saca error por que implicitamente tiene un null
if(una == null) //es lo mismo que la anterior
if(dos) //false pero no saca error
if(tres) //true por que contiene un array, vacio pero es algo
if("")//false por que esta vacio
if(cuatro)//tiene algo por tanto es true

Если вы не транспилируете свой код JS (например, с помощью Babel), операция "==" выполняется быстрее, чем проверка типа с помощью "===", поэтому, если ваш код будет использоваться много раз (он является частью архитектура или какая-то библиотека) предпочтительнее использовать "==", учитывая, что вы не собираетесь проходить фильтр типов. Во всех остальных случаях (подавляющее большинство) лучше использовать проверку типов с "===", чтобы избежать неожиданных результатов.

Уточним понятия:

• Каждая переменная в JavaScript имеет тип и значение .

• В JavaScript есть нечто, называемое принуждением . Приведение — это автоматическое (и неявное) преобразование, которое выполняет движок JavaScript в попытке оперировать значениями разных типов. Например:

const valor1 = '5';
const valor2 = 9;
let suma = valor1 + valor2;
console.log(suma);

Поскольку значение1 имеет тип строка , а значение2 имеет тип число , JavaScript выполняет автоматическое преобразование второго значения, пытаясь выполнить суммирование. Таким образом, значение переменной sumaбудет строкового типа :

'59'

ВЫВОД

Оператор ==сравнивает два значения независимо от типа. То есть принуждает, а потом сравнивает. Если значения совпадают после конвертации, вернуть значение true.

Вместо этого оператор ===возвращает trueзначение только в том случае, если значение и тип совпадают.

Уточнение: это относится только к 6 примитивным типам.