null和undefined是虚无，也就是说，

var a;
var b = null;

在这里a并b没有值。而0，false和''均为值。所有这些之间的共同点是它们都是虚假的值，这意味着它们都满足虚假的条件。

因此，0，false和''共同构成一个子组。另一方面，null和undefined构成第二个子组。检查下图中的比较。null和undefined相等。其他三个将彼此相等。但是，它们在JavaScript中都被视为虚假条件。

这与任何对象（如{}，数组等）相同，非空字符串和布尔值true都是真实条件。但是，它们都不相等。

这是一个方便的比较表，显示所发生的转换之间的差异==和===。

结论如下：

“除非您完全了解两个相等的转换，否则请使用三个相等。”

http://dorey.github.io/JavaScript-Equality-Table/

null and undefined are nothingness, that is,

var a;
var b = null;

Here a and b do not have values. Whereas, 0, false and '' are all values. One thing common beween all these are that they are all falsy values, which means they all satisfy falsy conditions.

So, the 0, false and '' together form a sub-group. And on other hand, null & undefined form the second sub-group. Check the comparisons in the below image. null and undefined would equal. The other three would equal to each other. But, they all are treated as falsy conditions in JavaScript.

This is same as any object (like {}, arrays, etc.), non-empty string & Boolean true are all truthy conditions. But, they are all not equal.

这是一个方便的比较表，显示所发生的转换之间的差异==和===。

结论如下：

"Use three equals unless you fully understand the conversions that take place for two-equals."

http://dorey.github.io/JavaScript-Equality-Table/

来自核心javascript参考

===返回true如果操作数严格相等（见上文），没有类型转换。

问题是您可能很容易遇到麻烦，因为JavaScript具有很多隐式转换，这意味着...

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

哪一个很快成为问题。隐式转换为什么是“邪恶的”的最佳示例可以从MFC / C ++中的此代码中获取，该代码实际上将由于从CString到HANDLE的隐式转换而编译，HANDLE是指针typedef类型。

CString x;
delete x;

显然，在运行时这会做非常不确定的事情...

Google在C ++和STL中进行隐式转换，以获取针对它的一些参数...

上面提到的前两个答案==表示平等，===表示身份。不幸的是，这个说法是不正确的。

如果==的两个操作数都是对象，则将它们进行比较以查看它们是否是同一对象。如果两个操作数都指向同一个对象，则equal操作符将返回true。否则，两者不相等。

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

在上面的代码中，==和===都为假，因为a和b不是同一对象。

这就是说：如果==的两个操作数都是对象，则==的行为与===相同，这也意味着标识。这两个运算符的本质区别在于类型转换。==在检查相等性之前已经进行了转换，但是===没有。

根据经验，我通常会使用===代替==（和!==代替!=）。

原因在上面的答案中进行了解释，Douglas Crockford对此也很清楚（JavaScript：The Good Parts）。

但是，只有一个例外： == null一种有效的方法来检查“是否为null或未定义”：

if( value == null ){
    // value is either null or undefined
}

例如，jQuery 1.9.1使用此模式43次，因此JSHint语法检查器甚至提供了eqnull放宽选项。

从jQuery样式指南：

应该使用严格的相等性检查（===）来支持==。唯一的例外是通过null检查undefined和null时。

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

=== 操作员检查值以及变量类型是否相等。

== 运算符只是检查变量的值是否相等。

这是严格的检查测试。

这是一件好事，尤其是如果您要检查0到false和null之间。

例如，如果您有：

$a = 0;

然后：

$a==0; 
$a==NULL;
$a==false;

全部返回true，您可能不希望这样。假设您有一个可以返回数组的第0个索引或在失败时返回false的函数。如果使用“ ==” false进行检查，则会得到令人困惑的结果。

因此，与上述相同，但进行了严格的测试：

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

使用中的两个操作之间的性能差异不大。由于两个参数已经是相同的类型，因此无需进行类型转换。这两个操作都将进行类型比较，然后进行值比较。

JavaScript === 与 ==。

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

该===运算符称为严格的比较操作符，它不会从不同的==操作符。

取2个变数a和b。

为了使“ a == b”评估为真，a和b必须为相同的值。

在“ a === b”的情况下，a和b必须具有相同的值和相同的类型，才能将其评估为true。

请看下面的例子

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

总而言之 ; 在您不希望使用===运算符的情况下，使用==运算符可能会得出true，因此使用===运算符会更安全。

在90％的使用情况下，使用哪一个无关紧要，但是当您一天有某些意外行为时，知道它们之间的区别很方便。

在JavaScript中，它表示相同的值和类型。

例如，

4 == "4" // will return true

但

4 === "4" // will return false 

在PHP和JavaScript中，它是严格的相等运算符。这意味着它将比较类型和值。

在这里的答案中，我什么都没有读到什么相等的意思。有人会说这===意味着相等并且属于同一类型，但这不是真的。实际上，这意味着两个操作数都引用相同的对象，或者在值类型的情况下，它们具有相同的value。

因此，让我们采用以下代码：

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

这里也是：

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

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

甚至：

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

这种现象并不总是很明显。故事不只是平等和同类型。

规则是：

对于值类型（数字）：
a === b如果a和b具有相同的值并且属于相同的类型，则返回true

对于引用类型：
a === b如果a和b引用完全相同的对象，则返回true

对于字符串：
a === b如果a和b均为字符串且包含完全相同的字符，则返回true

字符串：特例...

字符串不是值类型，但是在Javascript中，它们的行为类似于值类型，因此，当字符串中的字符相同且长度相同时，它们将“相等”（如第三条规则所述）

现在变得有趣了：

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

但是呢？：

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

我以为字符串的行为类似于值类型？好吧，这取决于您问的是谁...在这种情况下，a和b不是同一类型。a是类型的Object，b而是类型的string。只需记住，使用String构造函数创建字符串对象会创建某种类型的东西，大多数情况下Object它的行为都类似于字符串。

==和之间的相等比较的有趣的图形表示形式===。

资料来源：http : //dorey.github.io/JavaScript-Equality-Table/

var1 === var2

当===用于JavaScript相等性测试时，一切保持原样。在评估之前，没有任何转换。

var1 == var2

在==用于JavaScript相等性测试时，会进行一些时髦的转换。

故事的道德启示：

使用===除非你完全明白发生与转换==。