使用 === 如果你想在JavaScript中比较几件事,它被称为严格的平等,这意味着如果只有两种类型和值是相同的,就不会有任何不需要的类型纠正为你,如果你使用 ==,你基本上不关心类型,在许多情况下你可能会遇到问题与空虚的平等比较。

使用严格的平等 ===

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false

使用平等 = = =

空的平等比较两种平等值,然后将两种值转换为一个常见的类型。 转换后(一方或两方可能遭受转换),最终的平等比较按 === 进行。 空的平等是相同的: A == B 总是具有相同的序列为 B == A 的任何值 A 和 B (除了应用转换顺序)。

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// both false, except in rare cases
console.log(obj == null);
console.log(obj == undefined);

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

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

看到这一点在一个答案. a 和 b 不是真正相同的类型在这种情况下,如果你检查 tipof(a) 你会得到“对象” 和 tipof(b) 是“紧张”。

在这里的答案中,我没有读到什么是平等的意思,有些人会说 === 意味着平等和相同的类型,但这不是真的。

所以,让我们采取下列代码:

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 具有相同的值,并且具有相同的类型,则返回真实。

下一篇:特殊案例...

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 是类型对象,而 b 是类型线条。

JSLint 有时会给你一些不现实的理由来改变事物。 === 具有与 == 相同的性能,如果类型已经相同。

它只有当类型不相同时更快,在这种情况下它不会尝试转换类型,而是直接返回虚假。

因此,IMHO,JSLint可能用来写新的代码,但无用的过度优化应该以任何代价避免。

也就是说,在一个检查中没有理由改变 == 到 === 如果(一个 == 测试)当你知道它是因为一个可以只是一个线条。

修改大量的代码会浪费开发人员和评论家的时间,并无所得。

这是一个严格的检查测试。

这是一个很好的事情,特别是如果你在0和虚假和零之间检查。

例如,如果你有:

$a = 0;

然后:

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

所有返回是真实的,你可能不想这样做. 假设你有一个功能可以返回一个序列的 0th 指数或错误的故障. 如果你检查“=="错误,你可以得到一个混乱的结果。

所以,与上面的相同,但严格的测试:

$a = 0;

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

这里有一个有趣的视觉化平等之间的比较 ==和 ===。

来源: https://github.com/dorey/JavaScript-Equality-Table(演示,统一演示)

var1 === var2

当使用 === 用于 JavaScript 平等测试时,一切都如同。

此分類上一篇

此分類上一篇: Var1 = Var2

当使用 ==为JavaScript平等测试时,会发生一些 funky 转换。

此分類上一篇

平等在JavaScript中的概述

此分類上一篇

结论:

总是使用 ===,除非你完全了解与 ==发生的 funky 转换。