运算符===和是严格!==的比较运算符。这意味着如果操作数具有不同的类型，则它们是不相同的。例如，

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

记住所有轻松比较的规则并不容易，有时它以违反直觉的方式工作。因此，我建议使用===而不是==.

operator 的小细节我不记得了==，所以让我们看一下规范，第 11.9.3 点：

抽象等式比较算法

比较x == y，其中x和y是值，返回true或false。这种比较是按如下方式进行的：

1. 如果Type(x)和Type(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与y的Number值相同，则返回true。
      4. 如果x为+0且y为-0，则返回true。
      5. 如果x为-0且y为+0，则返回true。
      6. 返回假。
   4. 如果Type(x)是String ，如果x和y是完全相同的字符序列（具有相同的长度和对应位置的相同字符） ，则返回true 。否则，它返回false。
   5. 如果Type(x)是Boolean，它返回true，如果x和y都是true或两者都是false。否则，它返回false。
   6. 如果x和y引用同一个对象，则返回true 。否则，它返回false。
2. 如果x为null且y未定义，则返回true。
3. 如果x未定义且y为null ，则返回true。
4. 如果Type(x)是Number并且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 是一种值，也就是说，如果你的变量有 null 它被定义并且有一些东西，除了一些东西 :P ，未定义意味着您的变量尚未定义，这一事实很奇怪，尤其是因为 null == undefined 响应为真。

现在，当您使用 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 中有一种叫做coercion的东西。强制转换是 JavaScript 引擎为了尝试对不同类型的值进行操作而执行的一种自动（和隐式）转换。例如：

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

由于 value1 是string类型， value2 是number类型，JavaScript 会自动转换第二个值以尝试求和。这样，变量的值suma将是string类型：

'59'

结论

运算符==比较两个值，不考虑类型。也就是说，它先强制然后比较。如果转换后的值相同，则返回该值true。

运算符仅在值和类型匹配的情况下===返回。true

说明：这仅适用于 6 种原始类型。