Question

我一直在努力理解JavaScript的比较运算符之间的区别：身份和平等。根据我的阅读，如果使用==检查两个对象的相等性，JavaScript将尝试确定它们是否是相同类型，如果不是，则尝试将它们设置为相同类型。但是，===的行为方式不同。举个例子：

var n = "1";
console.log(n==1);        // outputs true
console.log(n===1);       // outputs false

那么这些“身份”运营商和正规平等运营商之间有什么区别？两者兼有的好处是什么？

性能有差异吗？我认为身份运算符会更快，因为它不会进行转换。

另外，当涉及更复杂的对象（如数组）时，它们有何不同？最重要的是，惯例会说什么时候应该使用另一个，为什么？

Answer 1

在进行比较之前，相等运算符将尝试使数据类型相同。另一方面，身份运算符要求两种数据类型都与先决条件相同。

还有很多其他帖子与此问题类似。参见：

How do the PHP equality (== double equals) and identity (=== triple equals) comparison operators differ?（有一个很好的比较图表）
Which equals operator (== vs ===) should be used in JavaScript comparisons?

实际上，当你想要确定布尔值为真或假时，身份运算符非常方便...

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

Answer 2

区别在于==，＆lt; =，＆gt; =和！=将执行类型强制 - 例如，强制将字符串计算为数字。 ===，＆lt; ==，＆gt; ==，和！==不会进行类型强制。他们会将字符串与数字进行比较，由于字符串“1”与数字值1不同，因此结果为false。

参考文献：
https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators

Answer 3

==与===相同，只是==进行了类型转换

为了向您展示我的意思，这是一个JavaScript函数，其行为与==完全相同：

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

    // 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 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;

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

此功能应该有助于解释为什么人们一直说你不应该使用==。

正如您所看到的，==有很多复杂的类型转换逻辑。因此，很难预测你会得到什么结果 - 这可能会导致错误。

以下是您不期望的一些结果的一些示例：

意外的真相

[1] == true // returns true
'0' == false // returns true
[] == false // returns true
[[]] == false // returns true
[0] == false // returns true

'\r\n\t' == 0 // returns true

意外结论

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

具有特殊功能的对象

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**

Answer 4

原因是identity或strict运算符（===），它与没有类型转换进行比较，这意味着如果两个值没有相同的值和相同的类型，它们将被视为不相等。 / p>

以下链接中有一个更清晰的解释：

https://medium.com/@ludico8/identity-vs-equality-battle-of-understanding-vs-758d396e922#.hhg396ey9

Answer 5

相等和标识运算符特别值得注意。相等运算符将尝试将操作数强制（转换）为相同类型以评估相等性。只要您知道它正在发生，这就是一个方便的功能。此代码块显示了相等运算符的作用。

let firstVal = 5;
let secondVal = "5";
if (firstVal == secondVal) {
console.log("They are the same");
} else {
console.log("They are NOT the same");
}

此脚本的输出如下：

它们是相同的

JavaScript会将两个操作数转换为相同类型并进行比较。本质上，相等运算符会测试值是否相同，而与它们的类型无关。

如果要测试以确保值和类型相同，则需要使用恒等运算符（===，三个等号，而不是相等运算符中的两个）

let firstVal = 5;
let secondVal = "5";
if (firstVal === secondVal) {
console.log("They are the same");
} else {
console.log("They are NOT the same");
}

在此示例中，身份运算符将认为两个变量不同。该运算符不强制输入类型。该脚本的结果如下：

他们不一样

JavaScript比较运算符：Identity与Equality

5 个答案: