我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
当前回答
為什麼 ==是如此不可預測的?
如果你比较一个空的字符串“”与零的数字,你会得到什么?
它没有结束,这里还有一个:
'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();
}
那么这意味着什么呢?
这意味着你可以用错误结束。
让你的生活更不复杂。
使用 === 而不是 ==。
其他回答
这是一个严格的检查测试。
这是一个很好的事情,特别是如果你在0和虚假和零之间检查。
例如,如果你有:
$a = 0;
然后:
$a==0;
$a==NULL;
$a==false;
所有返回是真实的,你可能不想这样做. 假设你有一个功能可以返回一个序列的 0th 指数或错误的故障. 如果你检查“=="错误,你可以得到一个混乱的结果。
所以,与上面的相同,但严格的测试:
$a = 0;
$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
原因在上面的答案中被解释,而且杜格拉斯·克罗克福德也对此非常清楚(JavaScript:The Good Parts)。
但是,有一個例外: == null 是檢查“是零或不定義”的有效方式:
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;
编辑 2021-03:
如今,大多数浏览器支持 Nullish coalescing 操作器(??) 和 Logical nullish 任务(??=),如果变量是 null 或 undefined,例如:
if (a.speed == null) {
// Set default if null or undefined
a.speed = 42;
}
可以用任何形式写作。
a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;
无,无,无,无,无,无。
var a;
var b = null;
在这里, a 和 b 没有值. 因为, 0 是虚假的和 '' 都是值. 其中的一件常见的是,它们都是虚假的值,这意味着它们都满足虚假的条件。
因此, 0 虚假和 '' 一起形成一个子组. 另一方面, null 和 undefined 形成第二个子组. 查看下图中的比较. null 和 undefined 将是相同的. 其他 3 将是相同的。
此分類上一篇
這是相同的任何物體(如 {}, arrys,等),不空的線 & Boolean 真實是所有真實的條件. 但,他們都不是平等。
平等比较:
运营商 =
回归是真实的,当两个操作员是平等的时,操作员在比较之前转换为相同的类型。
>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
平等与类型比较:
主持人 ===
回来是真实的,如果两个操作员是相同的和类型。 一般情况下,如果你比较这个方式,它是更好的和更安全的,因为没有背后的场景类型转换。
>>> 1 === '1'
false
>>> 1 === 1
true
使用一个未提到的理由 === - 是你与 / 交叉编写到 / 从咖啡脚本共存的情况。
JavaScript 的弱平等比较有某种混乱的行为,并且往往是混乱的错误的来源。 解决方案是使用严格的平等运营商,由三个平等标志组成: ===. 它就像正常的平等运营商一样工作,但没有任何类型的强迫。
如果你经常转换到和从咖啡脚本,你应该只使用 ===。
CoffeeScript 解决了这一点,简单地将所有弱的比较与严格的比较相替代,换句话说,将所有 ==比较器转换为 ===. 在 CoffeeScript 中,你不能进行弱的平等比较,并且在需要时比较之前,你应该明确地转换类型。