identity(===)运算符的行为与equality(==)运算符完全相同,但不进行类型转换,并且类型必须相同才能被视为相等.

参考:Javascript教程:比较运算符

在进行任何必要的类型转换后,==运算符将比较相等性.该运营商将不会进行转换,因此,如果两个值是不一样的类型将简单地返回.两者都同样快.======false

引用Douglas Crockford的优秀JavaScript:The Good Parts,

'' == '0'           // false
0 == ''             // true
0 == '0'            // true
false == 'false'    // false
false == '0'        // true
false == undefined  // false
false == null       // false
null == undefined   // true
' \t\r\n ' == 0     // true

缺乏传递性令人震惊.我的建议是永远不要使用邪恶的双胞胎.相反,总是使用===和!==.一切只是显示的比较的生产false与===经营者.

更新:

@Casebash在评论和@Phillipe Laybaert 关于参考类型的回答中提出了一个很好的观点.对于参考类型==并且===彼此一致地行动(在特殊情况除外).

var a = [1,2,3];
var b = [1,2,3];
var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };
var e = "text";
var f = "te" + "xt";
a == b            // false
a === b           // false
c == d            // false
c === d           // false
e == f            // true
e === f           // true

特殊情况是,当您将文字与评估为同一文​​字的对象进行比较时,由于其toString或valueOf方法.例如,考虑将字符串文字与String构造函数创建的字符串对象进行比较.

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

这里==操作员正在检查两个对象的值并返回true,但是===看到它们不是同一类型并返回false.哪一个是正确的？这真的取决于你想要比较的东西.我的建议是完全绕过这个问题,不要使用String构造函数来创建字符串对象.

参考
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

• ===永远不会比==慢.它们都进行类型检查,所以===与==相比没有做任何额外的事情,但是类型检查可能允许===在类型不同时更快退出.
• 用=== /!==替换所有== /!=会增加js文件的大小,然后需要更多的时间来加载.:)
• 如果类型相同,===不会更快.如果类型不相同,===会更快,因为它不会尝试进行转换.
• "......他们这样做的规则既复杂又不可取......"现在这些陈述使你在编程时感到如此安全......
• 来自克罗克福德:"缺乏传递性令人震惊." 如果您开发软件并且在比较运算符警报中没有发现缺乏传递性,或者在==和===或文件大小/加载时间之间的速度比较优先考虑比较运算符的行为的传递确定性,那么可能需要回去重新开始.
• 我们真的不应该使用`==`吗？你见过[这个回应](http://stackoverflow.com/questions/359494/javascript-vs-does-it-matter-which-equal-operator-i-use/957602#957602)
• @Bartdude它们不被认为具有相同的值,因为它们不是同一个对象.对象可能是如此复杂,以至于尝试将它们与价值的相似性进行比较是荒谬的.考虑具有许多嵌套属性的2个对象,其中一些可能是函数.你会如何比较它的价值？
• @Casebash:是的,我见过.那个答案并没有真正地比较`==`和`===`,这就是这个问题的意义所在.对于每个测试我都使用引用类型`==`和`===`act**一致**彼此除外.在注释中指出的情况是`new String("abc")=="abc"`返回`true`,但`new String("abc")==="abc"`返回`false`.我的建议是*不*使用`String`构造函数,并且总是使用`===`.
• @Blauhirn是的,推荐的方法是做手动类型强制(将`1`转换为字符串,或将`"1"转换为数字).`parseInt`和`parseFloat`函数工作正常,但您也可以使用`+"1"`或`Number("1")`将`"1"转换为数字.注意:`Number("1")`和`new Number("1")`之间有很大的区别!第一个是强制类型,第二个是创建一个新的`Number`对象.
• @EvanPlaice废话.对象的引用(并且没有其他引用)*是这些语言中的**值*.实际上,没有涉及实现的引用类型; 这纯粹是一种规范机制.
• ==和!=不是邪恶的.它们的存在和功能完全符合javascript的整体概念和应用.无法保证任何浏览器,用户或服务器都会以您期望的方式执行任何操作 - 特别是考虑到尚不存在的浏览器 - 这就是javascript如此动态的原因.也许浏览器A将文本框的输入解释为"最适合"类型,但浏览器B始终将其解释为字符串.使用===会导致两个浏览器之间出现兼容性问题.
• 所以假设类型是相同的 - = =实际上更快？:)
• 原因`new String("xxx")=="xxx"`是因为toString方法.类似的事情发生在`valueOf`.`new Number(7)== 7`,`({valueOf:function(){return 8;}})== 8`如果`==`改为`===,则eval为true,eval为false `
• @MarcoDemaio pal使用!==/===将为您节省更多空间,因为如果您不使用它们,您将编写if(val!= 0 && val!='')代码而不是if( val!=== 0).
• @Bill技术上,更新是"正确的"答案.===是引用相等,==是值相等.
• 值得注意的是,"abc"=== String("abc")`是`true`.说来也怪.
• "总是使用`===`和`!==`." - 我喜欢这种方法,但是如果我想在我的代码中的某个地方认为"1"和"1"被认为相等,我该怎么办？例如在JSON导入之后？`parseInt`？
• 我只想补充一点,jquery会将属性中的字符串值转换为数字,`$('.foo').attr('data-id')`,`$('.foo').data(' id')`,`$('.foo').prop('data-id')`所以如果你坚持严格的相等比较,你必须确保在进行比较之前先将数字"转换"为整数.双重等于"邪恶"的论点也是邪恶的.
• 我认为===(从长远来看)较慢,因为你必须添加额外的代码行才能进行显式转换.但是,我喜欢===当涉及到财务计算时,因为你必须做强类型的工作,而不是让未知转换的数字不稳定.
• `==`不使用逻辑。它用心。
• `new Number()=="0"`.同样在Firefox中:`(function(){})=="function(){\n}"`
• 我仍然不明白为什么{} === {}返回false.我完全理解这些在内存中不是同一个对象,但它仍然具有相同的类型和相同的值...
• @Devsman是的,他们是邪恶的,但你所谈论的是浏览器的功能不是javascript.这与创建返回字符串的函数的Mozilla没什么不同,webkit返回一个对象.在那种情况下,== /!=无论如何都不起作用.有一个保证,任何人现在创建一个新的浏览器,有接受当前正在使用的JavaScript,因为如果你甚至不能提出像Facebook,Instagram或某人的银行这样的基本网页.没有人会使用浏览器(在利基之外).
• 如果由于某些原因(糟糕的设计？)通过不同的API端点,它会返回相同的结果,但作为不同的类型？由于某种原因,您无权更改API.可以返回"2"或2.你需要==那里:)
• I'd also point out that 0 === -0 and NaN !== NaN, which can be confusing sometimes. If you want to differentiate ±0 and consider NaNs equal, use Object.is (ES2015)

使用==运算符(Equality)

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

使用===运营商(身份)

true === 1; //false
"2" === 2;  //false

这是因为相等运算符==确实键入了强制,这意味着解释器会在比较之前隐式尝试转换值.

另一方面,身份运算符===不进行类型强制,因此在比较时不会转换值.

• 由于没有人提到Javascript Equality Table,这里是:http://dorey.github.io/JavaScript-Equality-Table/
• @Software Monkey:不适用于值类型(数字,布尔值,...)
• 在第一个语句中,您确定'true'转换为1而不是1转换为true吗？

一个有趣的图形表示的==和之间的平等比较===.

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

var1 === var2

var1 == var2

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

• @vsync:如果你真的不希望类型相等*,你*应该*使用*三等于*!
• 一个例外：您可以安全地使用x == null来检查x是否为null或undefined。
• @mfeineis你的意思是===或!==而不是==或!=.不想混淆新的程序员;)

在这里的答案中,我没有读到关于什么是平等的意思.有些人会说这===意味着相同和相同的类型,但事实并非如此.它实际上意味着两个操作数引用相同的对象,或者在值类型的情况下,具有相同的值.

那么,我们来看下面的代码:

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表现为字符串的类型.

• `String`对象的行为与[任何其他对象](http://jsfiddle.net/k83ad/1/)一样.永远不应该使用`new String`,因为它不会创建真正的字符串.一个真正的字符串,可以使用字符串文字或调用`String`作为函数**而不使用**`new`,例如:`String(0); //"0",真正的字符串,而不是对象`
• activa:我想澄清一下,字符串只有在它们是文字的时候才是相同的.new String("abc")==="abc"是假的(根据我的研究).
• 但在您详细说明的情况下,运算符"=="的行为完全相同.
• `new Number()=="0"`.同样在Firefox中:`(function(){})=="function(){\n}"`
• 谢谢你解释为什么`new String("123")!=="123"`.它们是不同的类型.简单而又令人困惑.

让我加上这个忠告:

如有疑问,请阅读规范!

ECMA-262是脚本语言的规范,JavaScript是一种方言.当然,在实践中,最重要的浏览器的行为方式比关于应该如何处理某些东西的深奥定义更重要.但是理解为什么新的String("a")!=="a"是有帮助的.

请让我解释如何阅读说明书以澄清这个问题.我看到在这个非常古老的主题中,没有人能够得到非常奇怪的效果的答案.因此,如果您可以阅读规范,这将极大地帮助您的职业.这是一项后天的技能.所以,让我们继续吧.

搜索PDF文件===使我进入规范的第56页:11.9.4.严格等于运算符(===),在浏览规范后,我发现:

有趣的是第11步.是的,字符串被视为值类型.但这并不能解释为什么新的String("a")!=="a".我们的浏览器是否符合ECMA-262标准？

没那么快!

我们来检查一下操作数的类型.通过将它们包装在typeof()中来自己尝试一下.我发现新的String("a")是一个对象,并且使用了第1步:如果类型不同,则返回false.

如果你想知道为什么新的String("a")没有返回一个字符串,那么阅读规范的练习怎么样？玩得开心!

Aidiakapi在下面的评论中写道:

11.2.2新运营商:

如果Type(构造函数)不是Object,则抛出TypeError异常.

换句话说,如果String不是Object类型,则它不能与new运算符一起使用.

new总是返回一个Object,即使对于String构造函数也是如此.唉!字符串的值语义(参见步骤11)将丢失.

这最终意味着:新的字符串("a")!=="a".

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

• @David:对.这就是为什么这个答案不准确(甚至是错误的)
• @David`var a = {},b = {};``a == b`返回false.
• 是的:两个具有相同类型和值的_different_对象比较为false,即这个答案是错误的.为什么它有50个赞成票？
• 我意识到这很古老，但是要弄清楚为什么这个答案仍然“正确”是因为在示例中，`var a = {}，b = {};`尽管`a`和`b`确实都是对象，但从技术上讲，它们不是“相同”值。它们是*不同*的实例。请注意，比较实例的行为与比较基元的行为不同。这可能会增加这种混乱。如果使用原始数据类型的实例版本，您将看到类似的比较行为。例如`new String（'asdf'）`或`new Number（5）`。例如：即使新数值（5）=相同，新数值（5）仍为假。

我使用Firebug在Firefox中使用以下代码测试了这个:

console.time("testEquality");
var n = 0;
while(true) {
n++;
if(n==100000)
break;
}
console.timeEnd("testEquality");

和

console.time("testTypeEquality");
var n = 0;
while(true) {
n++;
if(n===100000)
break;
}
console.timeEnd("testTypeEquality");

我的结果(每次测试五次并取平均值):

==: 115.2
===: 114.4

所以我会说微不足道的差异(这是超过100000次迭代,请记住)可以忽略不计.表现不是理由===.输入安全性(嗯,安全性与JavaScript相同),代码质量也是如此.

• 现在,当`==`运算符存在实际类型的coersion时,如何进行比较？请记住,那就是性能提升的时候.
• 除了类型安全之外,您还需要逻辑正确性 - 有时候,当`=='不同意时,您希望事情变得真实.
• 由于前面提到的原因而进行正确测试时，主要差异在于更快地检查类型不平等。https://jsfiddle.net/4jhuxkb2/

在JavaScript中,它意味着相同的值和类型.

例如,

4 == "4" // will return true

但

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

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

让我们拿2个变量a和b.

要使"a == b"评估为真,a和b需要是相同的值.

在"a === b"的情况下,a和b必须是相同的值,并且它的相同类型才能评估为真.

以下面的例子为例

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%的使用情况下,使用哪一种都无关紧要,但是当你有一天意外行为时,知道差异就很方便了.

它检查相同的边是否在类型和值上相等.

例:

'1' === 1 // will return "false" because `string` is not a `number`

常见例子:

0 == ''  // will be "true", but it's very common to want this check to be "false"

另一个常见例子:

null == undefined // returns "true", but in most cases a distinction is necessary

• 还有,''string'!=='number'

为什么==这么难以预测？

将空字符串""与数字零进行比较时,您会得到什么0？

true

是的,根据==空字符串是正确的,数字零是同一时间.

它并没有结束,这是另一个:

'0' == false // true

数组的事情变得非常奇怪.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

然后用字符串怪异

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

情况变得更糟:

什么时候不相等？

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string
A == B // true - ok...
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

让我再说一遍:

(A == B) && (B == C) // true
(A == C) // **FALSE**

而这只是你用原语获得的疯狂东西.

当你使用==对象时,这是一个全新的疯狂程度.

此时你可能想知道......

为什么会这样？

嗯,这是因为不像"三等于"(===)只检查两个值是否相同.

==做了很多其他的事情.

它具有对函数的特殊处理,对空值的特殊处理,未定义,字符串,您可以命名它.

这很古怪.

事实上,如果你试图编写一个函数来==执行它看起来像这样的东西:

function isEqual(x, y) { // if `==` were a function
if(typeof y === typeof x) return y === x;
// treat null and undefined the same
var xIsNothing = (y === undefined) || (y === null);
var yIsNothing = (x === undefined) || (x === null);
if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);
if(typeof y === "function" || typeof x === "function") {
// if either value is a string
// convert the function into a string and compare
if(typeof x === "string") {
return x === y.toString();
} else if(typeof y === "string") {
return x.toString() === y;
}
return false;
}
if(typeof x === "object") x = toPrimitive(x);
if(typeof y === "object") y = toPrimitive(y);
if(typeof y === typeof x) return y === x;
// convert x and y into numbers if they are not already use the "+" trick
if(typeof x !== "number") x = +x;
if(typeof y !== "number") y = +y;
// actually the real `==` is even more complicated than this, especially in ES6
return x === y;
}
function toPrimitive(obj) {
var value = obj.valueOf();
if(obj !== value) return value;
return obj.toString();
}

那么这是什么意思？

这意味着==很复杂.

因为它很复杂,所以很难知道使用它会发生什么.

这意味着你最终可能会遇到错误.

所以这个故事的寓意是......

让你的生活变得简单.

用===而不是==.

结束.

Javascript执行流程图,用于严格相等/比较'==='

用于非严格相等/比较的Javascript执行流程图'=='

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

它表示没有类型强制
类型强制的相等意味着JavaScript不会自动将任何其他数据类型转换为字符串数据类型

0==false   // true,although they are different types
0===false  // false,as they are different types
2=='2'    //true,different types,one is string and another is integer but
javaScript convert 2 to string by using == operator
2==='2'  //false because by using === operator ,javaScript do not convert
integer to string
2===2   //true because both have same value and same types

在典型的脚本中,没有性能差异.更重要的可能是千位"==="比千位"=="重1 KB.如果您的情况存在性能差异,JavaScript分析器可以告诉您.

但我个人会做JSLint建议的事情.这个建议不是因为性能问题,而是因为类型强制手段('\t\r\n' == 0)是正确的.

• 并非总是如此.使用gzip压缩,差异几乎可以忽略不计.

等于比较运算符==令人困惑,应该避免.

如果你不得不忍受它,那么请记住以下三两件事:

1. 它不具有传递性:(a == b)和(b == c)不会导致(a == c)
2. 它与否定是相互排斥的:(a == b)和(a!= b)总是保持相反的布尔值,所有的a和b.
3. 如有疑问,请记住以下真值表:

JAVASCRIPT中的等号运算符真值表

• 表中的每一行都是一组3个相互"相等"的值,这意味着它们之间的任何2个值都等于使用等于==符号*

**STRANGE:请注意,第一列中的任何两个值在该意义上都不相等.**

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

在您的使用中,这两个操作之间不可能有任何性能差异.没有类型转换要做,因为两个参数已经是相同的类型.两个操作都将进行类型比较,然后进行值比较.

是! 这非常重要.

===操作者在JavaScript 的检查值以及类型,其中作为==操作者只检查的值(如果需要不类型转换).

你可以轻松测试它.将以下代码粘贴到HTML文件中,然后在浏览器中打开它

<script>
function onPageLoad()
{
var x = "5";
var y = 5;
alert(x === 5);
};
</script>
</head>
<body onload='onPageLoad();'>

你会在警报中得到' 假 '.现在,修改onPageLoad()的方法alert(x == 5);,你会得到真正的.

=== 运算符检查值以及变量的类型是否相等.

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

这是一项严格的检查测试.

这是一件好事,特别是如果您在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!= null`.-1

JSLint有时会给你修改内容的不切实际的理由.===具有完全相同的性能,就==好像类型已经相同.

仅当类型不相同时才更快,在这种情况下,它不会尝试转换类型,而是直接返回false.

因此,恕我直言, JSLint可能用于编写新代码,但应该不惜一切代价避免无用的过度优化.

意思是,没有理由在支票中改变==,===就像if (a == 'test')你知道一个只能是一个字符串的事实.

修改大量代码会浪费开发人员和审阅者的时间并且什么都不会实现.

只是

==装置的比较操作数之间有 type conversion

&

===意味着没有操作数之间的比较 type conversion

javaScript中的类型转换意味着javaScript会自动将任何其他数据类型转换为字符串数据类型.

例如:

123=='123'   //will return true, because JS convert integer 123 to string '123'
//as we used '==' operator
123==='123' //will return false, because JS do not convert integer 123 to string
//'123' as we used '===' operator

一个简单的例子是

2 == '2'  -> true, values are SAME because of type conversion.
2 === '2'  -> false, values are NOT SAME because of no type conversion.

根据经验,我通常会使用===而不是==(而!==不是!=).

上面的答案中解释了原因,Douglas Crockford也非常清楚它(JavaScript:The Good Parts).

但是有一个例外:
== null检查'is null或undefined'是一种有效的方法:

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

例如,jQuery 1.9.1使用此模式43次,因此JSHint语法检查程序甚至提供了eqnull放松选项.

从jQuery样式指南:

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

前两个答案都提到==表示平等,===表示身份.不幸的是,这种说法不正确.

如果==的两个操作数都是对象,则比较它们以查看它们是否是同一个对象.如果两个操作数都指向同一个对象,则等于运算符返回true.否则,两者并不相等.

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

在上面的代码中,==和===都得到false,因为a和b不是同一个对象.

也就是说:如果==的两个操作数都是对象,==的行为与===相同,这也意味着身份.这两个运算符的本质区别在于类型转换.==在检查相等性之前进行转换,但===没有.

问题是你很容易遇到麻烦,因为JavaScript有很多隐含的转换意味着......

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

这很快就会成为一个问题.隐式转换为"邪恶"的原因的最佳示例可以从MFC/C++中的代码中获取,该代码实际上将由于从CString到HANDLE的隐式转换而编译,HANDLE是指针typedef类型...

CString x;
delete x;

显然在运行时期间有很多未定义的东西......

谷歌在C++和STL中进行隐式转换以获得一些反对它的论据......

• '0 == null'为假。

从核心javascript参考

平等比较:

操作者 ==

当两个操作数相等时返回true.在比较之前,操作数被转换为相同的类型.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

平等和类型比较:

操作者 ===

如果两个操作数相等且类型相同,则返回true.如果你比较这种方式通常会更好更安全,因为没有幕后类型的转换.

>>> 1 === '1'
false
>>> 1 === 1
true

*运营商=== vs ==*

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

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

结论如下:

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

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

var a;
var b = null;

在这里a,b没有价值观.然而,0,false和''都是值.所有这些之间的共同点是,它们都是假值,这意味着它们都满足虚假条件.

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

这与任何对象(如{},数组等)相同,非空字符串和布尔值都是真实的条件.但是,他们都不平等.

JavaScript具有严格和类型转换比较.严格比较(例如===)仅在操作数具有相同类型时才为真.更常用的抽象比较(例如==)在进行比较之前将操作数转换为相同的类型.

• 句法:

  x == y

  例子:

  3 == 3     // true
  "3" == 3   // true
  3 == '3'   // true
  

• 句法:

  x === y

  例子:

  3 === 3 // true

供参考:比较运算符(Mozilla Developer Network)

如果您正在制作Web应用程序或安全页面,则应始终使用(仅在可能的情况下)

===

因为它将检查它是否是相同的内容,如果它是相同的类型!

所以有人进入时:

var check = 1;
if(check == '1') {
//someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
}

但随着

var check = 1;
if(check === 1) {
//some continued with a number (no string) for your script
} else {
alert('please enter a real number');
}

黑客永远不会深入系统来查找错误并破解您的应用程序或用户

我的观点是

===

将为您的脚本添加更多安全性

当然你也可以检查输入的数字是否有效,是一个字符串等...与第一个例子中的其他if语句,但这至少让我更容易理解和使用

我发布这个的原因是在这个对话中从未说过"更安全"或"安全"这个词(如果你看iCloud.com它使用2019次===和1308次==,这也意味着你有时候使用==而不是===,因为它会阻止你的功能,但正如开头所说,你应该尽可能多地使用===)

===关心对象是否相同.因此,new String("Hello world") === "Hello world"返回false.但是,==不关心对象是否相同; 它只是简单地将一个参数转换为另一个参数:如果转换不可能,则返回false.然后new String("Hello world") == "Hello world"返回true而不是false.

我的推理过程使用emacs org-mode和node.js来运行测试.

| use =      | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |
| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

我的测试脚本如下:run> node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems
for(var i = 0; i < rowItems.length; i++) {
for (var j = 0; j < colItems.length; j++) {
var r = (rowItems[i] === colItems[j]) ? true : false;
console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
};
}

javascript是一种弱类型语言,即没有任何数据类型,例如C,c ++.int,boolean,float等因此变量可以包含任何类型的值,这就是为什么这些特殊比较运算符存在的原因

例如

var i = 20;var j = "20";

如果我们应用比较运算符,这些变量结果将是

i==j //result is true

要么

j != i//result is false

为此,我们需要一个特殊的比较运算符来检查变量的值和数据类型

如果我们这样做

i===j //result is false

• =operator用于分配value.
• = =operator用于比较valuesnotdatatype
• = = =运算符用于比较values以及datatype.

== 运算符只是比较值而不是数据类型

=== 运算符将值与其数据类型的比较进行比较

例如.

1 == "1" //true
1 === "1" //false

"==="运算符用于执行自动类型转换的语言,例如.PHP,Javascript."==="运算符有助于防止由自动类型转换引起的意外比较.

总是使用' === ',你会避免数以千计的错误.现在使用三重相等更适合不同的样式指南,因为它考虑了操作数的类型.

是的,平等==和身份===运营商之间存在很大差异.
通常,身份运算符执行速度更快,因为没有进行类型转换.但如果值的类型相同,您将看不到任何差异.
查看我的帖子JavaScript等式运算符的图例,它通过大量示例解释了详细信息,包括类型转换和比较算法.

使用的一个未提及的原因===- 在您与/交叉编译共存的情况下coffee-script.来自CoffeeScript的小书 ......

解决方案是使用严格相等运算符,它由三个等号组成:===.它的工作方式与普通的相等运算符完全相同,但没有任何类型强制.建议始终使用严格相等运算符,并在需要时显式转换类型.

如果你经常转换coffee-script,你应该使用===.事实上,coffee-script编译器会强迫你 ......