javascript - 等于运算符( == VS === ) 我在JavaScript比较中使用?

  显示原文与译文双语对照的内容

我用 JSLint通过javascript和返回许多建议来取代 == ( 两个等号) 与 === ( 三个等号) 当做事比较 idSele_UNVEHtype.value.length == 0if 语句。

== 替换为 === 有性能优势?

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

如果没有进行类型转换,是否会在 == 上获得性能提升?

时间:

标识( === ) 运算符的行为与相等( == ) 运算符相同,但不进行类型转换,并且类型必须相同,才能被视为相等。

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

在执行任何必要的类型转换后,== 运算符将比较相等 。 === 运营商不会做转换,如果两个值不相同类型 ===false 只会回报。 在这种情况下,=== 会比 == 更快,并且返回不同的结果。 在所有其他情况下,性能都是相同的。

要引用Douglas的crockford JavaScript: 好的部件,

JavaScript有两组相等运算符: ===!==,以及它们的邪恶孪生 ==!= 。 好的工作就像你预期的那样。 如果两个操作数具有相同的类型并且具有相同的值,那么 === 生成 true!== 生成 false 。 当操作数具有相同类型时,邪恶的双胞胎做正确的事情,但是如果它们是不同的类型,它们试图强制。 它们执行的规则复杂且 unmemorable 。 以下是一些有趣的案例:


'' == '0'//false
0 == ''//true
0 == '0'//true

false == 'false'//false
false == '0'//true

false == undefined//false
false == null//false
null == undefined//true

' trn ' == 0//true

传递的缺乏引起了警告。 我的建议是从不使用 evil 。 相反,总是使用 ===!== 。 刚才显示的所有比较都产生了 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

使用 == 运算符( 等 )


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

这是因为相等运算符 == does类型强制,这意味着解释器在比较之前隐式地尝试转换值。

另一方面,的标识运算符 === 不执行类型强制,因此在比较时不转换值。

在这里的答案中,我没有阅读任何关于等于的内容。 有些人会说, === 意味着平等和相同类型的,但这不是真的。 这实际上意味着两个操作数引用同一个对象,或值类型,有相同的价值。

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


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

引用类型的英镑:
a === b 如果 ab 引用完全相同的对象,则返回真

字符串:
a === b 如果 ab 都是字符串并且包含完全相同的字符,则返回真


字符串:特殊情况。。

字符串不是值类型,但在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,它在大多数时间都是字符串 。

让我添加这个律师:

如果在 read specification,则

ECMA-262是一个脚本语言的规范,JavaScript是一种方言。 当然,在实践中,最重要的浏览器比一个深奥的定义更重要。 但是理解为什么要花费的新 String("a") =="一个"

请让我解释如何阅读规范来澄清这个问题。 我发现在这个非常古老的主题中没有人对非常奇怪的效果有答案。 所以,如果你能阅读一个规范,这将对你的职业大有帮助。 这是一个获得的技能。 那么,我们继续。

在===文件中搜索,将我带到规范的第 56页: 11.9.4.严格等于运算符( === ),经过specificationalese后,我发现:

11.9.6 严格相等比较算法
比较x===y,x和y值,产生 。 这样做的比较如下:
1.如果 Type(x) 与 Type(y), 不同,则返回
2.如果未定义 Type(x),返回
3 。如果 Type(x) 为空,则返回
4.如果 Type(x) 不是数字,请转到步骤 11.
5.如果x是,返回
6.如果y是,返回
7.如果x的数字值与y 相同,则返回


10.返回
11.如果 Type(x) 字符串,然后返回真正如果x和y是完全相同的字符序列( 相应位置的长度和相同字符) ;否则,返回
12.如果布尔 Type(x), 返回真的如果x和y都是或两者;否则,返回 。 13.如果x 和y 引用了相同的对象,或者它们引用了与彼此相连的对象,则返回 。 否则,返回

有趣的是第 11步。是,字符串被视为值类型。 但这并不解释为什么要用 String("a") =="一个" 。 我们是否有一个不符合ECMA-262的浏览器?

不要这么快!

让我们检查操作数的类型。 通过将它们包装为 typeof() 来亲自尝试。 我发现新 String("a") 是一个对象,并使用 1步: 如果类型不同则返回

如果你想知道为什么新 String("a") 不返回一个字符串,锻炼阅读规范呢? 尽情玩耍吧!


Aidiakapi在下面的评论中写道:

从规范中

11.2.2 新运营商 :

如果 Type(constructor) 不是对象,则抛出TypeError异常。

换句话说,如果字符串不是类型对象,它不能与新运算符一起使用。

总是返回一个对象,即使对于字符串构造函数。 and 字符串( 查看步骤 11 )的值语义丢失。

这最终意味着:String("a") =="一个"

===== 之间相等比较的有趣图示。

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


var1===var2

when using three equals signs for JavaScript equality testing, everything is as is. 在评估之前没有任何东西被转换。

Equality evaluation of === in JS


var1==var2

使用两个等号javascript平等测试时,一些时髦的转换。

Equality evaluation of == in JS


这个故事的 Moral 除非你完全理解two-equals发生的转换,否则使用三个等式。

在PHP和JavaScript中,它是一个严格的相等运算符。 也就是说,它将比较类型和值。

我在 Firefox 中使用像这样的代码使用 Firebug 测试了这一点:


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中得到的一样安全),代码质量为。

在JavaScript中,它的值和类型相同。

比如,


4 =="4"//will return true

但是


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

===运营商称为严格的比较运算符,它不同 ==算子。

让我们以 2和b 为例。

对于 "=="评估为truea和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%使用场景中你使用哪一种不重要,但是它可以非常方便地知道不同的一天,当你得到一些意想不到的行为。

这意味着没有强制类型转换平等


0==false//true
0===false//false, different types

...