我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
我使用JSLint通过JavaScript,它返回了许多建议,以取代 ==(两个平等的标志)与 ===(三个平等的标志)当做一些事情,如比较idSele_UNVEHtype.value.length == 0在一个假设声明。
能否取代 = = = = = = =?
任何性能改进都将被欢迎,因为有许多比较运营商。
如果没有类型转换发生,会有超越 ==的性能收益吗?
当前回答
这是一个严格的检查测试。
这是一个很好的事情,特别是如果你在0和虚假和零之间检查。
例如,如果你有:
$a = 0;
然后:
$a==0;
$a==NULL;
$a==false;
所有返回是真实的,你可能不想这样做. 假设你有一个功能可以返回一个序列的 0th 指数或错误的故障. 如果你检查“=="错误,你可以得到一个混乱的结果。
所以,与上面的相同,但严格的测试:
$a = 0;
$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
其他回答
操作员只是比较不数据类的值。
=== 运营商将值与其数据类型的比较进行比较。
艾:
1 == "1" //true
1 === "1" //false
此操作员(“===”)用于自动输入字符的语言,例如 PHP,JavaScript。
為什麼 ==是如此不可預測的?
如果你比较一个空的字符串“”与零的数字,你会得到什么?
它没有结束,这里还有一个:
'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();
}
那么这意味着什么呢?
这意味着你可以用错误结束。
让你的生活更不复杂。
使用 === 而不是 ==。
平等比较:
运营商 =
回归是真实的,当两个操作员是平等的时,操作员在比较之前转换为相同的类型。
>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
平等与类型比较:
主持人 ===
回来是真实的,如果两个操作员是相同的和类型。 一般情况下,如果你比较这个方式,它是更好的和更安全的,因为没有背后的场景类型转换。
>>> 1 === '1'
false
>>> 1 === 1
true
在这里的答案中,我没有读到什么是平等的意思,有些人会说 === 意味着平等和相同的类型,但这不是真的。
所以,让我们采取下列代码:
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 具有相同的值,并且具有相同的类型,则返回真实。
下一篇:特殊案例...
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 是类型对象,而 b 是类型线条。
从核心JavaScript参考
=== 返回是真实的,如果操作员是严格平等的(见上)没有类型转换。