应该在JavaScript比较中使用哪个等于运算符(== vs ===)？

Question

我正在使用JSLint来完成JavaScript,并且在执行诸如比较语句内部之类的事情时,它会返回许多建议来替换==(两个等号)===(三个等号).idSele_UNVEHtype.value.length == 0if

有没有性能优势,以代替==用===？

任何性能改进都会受到欢迎,因为存在许多比较运算符

如果没有进行类型转换,是否会有性能提升==？

Answer 1

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

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

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

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

JavaScript有两套相等运算符:===和!==,邪恶的双胞胎==和!=.好的工作方式与您期望的方式相同.如果两个操作数具有相同的类型且具有相同的值,则===生成true并!==生成false.当操作数属于同一类型时,邪恶的双胞胎做正确的事,但如果它们属于不同的类型,它们会试图强迫价值观.他们这样做的规则是复杂和不可取的.这些是一些有趣的案例:

'' == '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

Answer 2

使用==运算符(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

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

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

Answer 3

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

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

var1 === var2

当===用于JavaScript相等性测试时,一切都按原样.在评估之前没有任何东西被转换.

var1 == var2

当==用于JavaScript相等测试时,会发生一些时髦的转换.

故事的道德启示:

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

Answer 4

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

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

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

Answer 5

让我加上这个忠告:

如有疑问,请阅读规范!

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

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

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

11.9.6严格的等式比较算法
比较x === y,其中x和y是值,产生真或假.这样的比较如下进行:
  1.如果Type(x)与Type(y)不同,则返回false.
  2.如果Type(x)是Undefined,则返回true.
  3.如果Type(x)为Null,则返回true.
  4.如果Type(x)不是Number,请转到步骤11.
  5.如果x是NaN,则返回false.
  6.如果y是NaN,则返回false.
  7.如果x与y的数值相同,则返回true.
  8.如果x为+0且y为-0,则返回true.
  9.如果x是-0且y是+0,则返回true.
  10.返回false.
  11.如果Type(x)是String,则如果x和y完全相同的字符序列(相应位置的长度和字符相同),则返回true ; 否则,返回false.
  12.如果Type(x)是布尔值,如果x和y都为真或两者都为假,则返回true ; 否则,返回false.   13. 如果x和y引用同一个对象或它们引用相互连接的对象,则返回true(见13.1.2).否则,返回false.

有趣的是第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".

Answer 6

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

Answer 7

我使用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相同),代码质量也是如此.

Answer 8

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

例如,

4 == "4" // will return true

但

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

Answer 9

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

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

Answer 10

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

例:

'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

Answer 11

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

将空字符串""与数字零进行比较时,您会得到什么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();
}

那么这是什么意思？

这意味着==很复杂.

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

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

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

让你的生活变得简单.

用===而不是==.

结束.

Answer 12

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

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

Answer 13

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

Answer 14

它表示没有类型强制 类型强制的相等意味着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 

Answer 15

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

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

Answer 16

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

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

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.

Answer 17

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

Answer 18

是! 这非常重要.

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

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

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

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

Answer 19

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

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

Answer 20

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

这是一件好事,特别是如果您在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

Answer 21

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

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

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

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

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

Answer 22

只是

==装置的比较操作数之间有 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 

Answer 23

一个简单的例子是

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

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

Answer 24

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

上面的答案中解释了原因,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样式指南:

应使用严格的相等性检查(===)以支持==.唯一的例外是通过null检查undefined和null.

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

Answer 25

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

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

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

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

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

Answer 26

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

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

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

CString x;
delete x;

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

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

Answer 27

从核心javascript参考

===返回true如果操作数严格相等(见上文),没有类型转换.

Answer 28

平等比较:

操作者 ==

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

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

平等和类型比较:

操作者 ===

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

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

Answer 29

*运营商=== vs ==*

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

Answer 30

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

结论如下:

"使用三个等于,除非你完全理解两个等于的转换."

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

Answer 31

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

var a;
var b = null;

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

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

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

Answer 32

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

• ==如果操作数不是同一类型,则equiv()运算符会转换操作数,然后应用严格比较.如果操作数是数字或布尔值,操作数将尽可能转换为数字; 否则,如果任一操作数是字符串,则尽可能将字符串操作数转换为数字.如果两个操作数都是对象,则JavaScript比较内部引用,当操作数引用内存中的同一对象时,这些内部引用相等.

  句法:

  x == y

  例子:

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

• ===如果操作数严格相等(见上文)且没有类型转换,则identity/strict equality()运算符返回true.

  句法:

  x === y

  例子:

  3 === 3 // true

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

Answer 33

如果您正在制作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次==,这也意味着你有时候使用==而不是===,因为它会阻止你的功能,但正如开头所说,你应该尽可能多地使用===)

Answer 34

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

Answer 35

我的推理过程使用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 + "]")
    };
}

Answer 36

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

Answer 37

不同的关系=,= =,= = =

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

Answer 38

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

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

例如.

1 == "1" //true

1 === "1" //false

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

Answer 39

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

Answer 40

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

Answer 41

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

JavaScript中的弱相等比较具有一些令人困惑的行为,并且通常是混淆错误的根源.

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

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

CoffeeScript通过简单地用严格的比较替换所有弱比较来解决这个问题,换句话说,将所有==比较器转换为===.你不能在CoffeeScript中进行弱相等比较,如果需要,你应该在比较之前显式转换类型.