我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
当前回答
平等比较运营商 ==是混乱的,应该避免。
如果你必須與它一起生活,請記住以下三件事:
它不是过渡的:(a ==b)和(b ==c)不会导致(a ==c)它是相互排斥它的否认:(a ==b)和(a!=b)总是保持相反的布莱恩值,所有A和B。
平等运营商在JavaScript中的真实表格
表中的每个行都是三个相互“平等”值的组合,这意味着它们之间的任何2个值都是平等的,使用平等的 ==标志*。
** 奇怪:请注意,第一列中的任何两个值在这个意义上不平等。
'' == 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 不会自动将任何其他数据类型转换为序列数据类型
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 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
平等与类型比较:
主持人 ===
回来是真实的,如果两个操作员是相同的和类型。 一般情况下,如果你比较这个方式,它是更好的和更安全的,因为没有背后的场景类型转换。
>>> 1 === '1'
false
>>> 1 === 1
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();
}
那么这意味着什么呢?
这意味着你可以用错误结束。
让你的生活更不复杂。
使用 === 而不是 ==。
操作员 = = = = = = = = = = = = = = = = = = = = = = = = = = =
此分類上一篇
缺乏过渡性是令人担忧的,我的建议是永远不要使用邪恶的双胞胎,相反,总是使用 === 和!== 所有仅仅显示的比较都是与 === 运营商虚假的。
更新:
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
"abc" == new String("abc") // true
"abc" === new String("abc") // false
在这里 ==运营商正在检查两个对象的值,并返回真实,但 ===看到它们不是相同的类型,并返回虚假。 哪一个是正确的? 这真的取决于你正在试图比较什么。
参考 http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3