Object.is vs = = =

我偶然发现了一个使用这种比较的代码示例:

var someVar = 0;
Object.is(false, someVar); //Returns false

我知道 false == 0将是 true，这就是为什么我们有 ===。

Object.is和 ===有什么不同？

17019 次浏览
小开
最佳答案

在 JavaScript 中，===被称为严格比较运算符。除了 NaN和 +0/-0之外，Object.is和严格比较运算符的行为完全相同。

来自 MDN:

根据 ===运算符，Object.is()方法不等于相等。===操作符(以及 ==操作符)将数值 -0和 + 0视为相等，将 Number.NaN视为不等于 NaN。

下面的代码突出显示了 ===和 Object.is()之间的区别。

console.log(+0 === -0); //true
console.log(Object.is(+0, -0)); //false


console.log(NaN === NaN); // false
console.log(Object.is(NaN, NaN)); //true


console.log(Number.NaN === Number.NaN); // false
console.log(Object.is(Number.NaN, Number.NaN)); // true


console.log(NaN === Number.NaN); // false
console.log(Object.is(NaN, Number.NaN)); // true

enter image description here

你可以找到更多的例子 给你。

注意: Object.is是 ECMAScript 6提案的一部分，目前还没有得到广泛支持(例如，它不受任何版本的 Internet Explorer 或其他浏览器的许多旧版本的支持)。然而，您可以使用非 ES6浏览器的填充，这可以在上面给出的链接中找到。

小开

Object.is使用规范的 SameValue 算法，而 ===使用 严格等式算法。关于严格平等算法的一份说明指出了这种差异:

这个算法不同于 SameValue 算法，它处理有符号的零和 NaN。

请注意:

  • NaN === NaN为假，但 Object.is(NaN, NaN)为真
  • +0 === -0为真，但 Object.is(+0, -0)为假
  • -0 === +0为真，但 Object.is(-0, +0)为假

JavaScript 有 至少四种“平等”:

  • “ Loose”(==) ，其中操作数将被强制尝试使它们匹配。规则是 说得很清楚，但不明显。("" == 0是 true; "true" == true是 false，...)。
  • “严格”(===) ，其中不同类型的操作数不会被强制(也不会是相等的) ，但是请参阅上面关于 NaN和正负零的说明。
  • SameValue-如上所列(由 Object.is使用)。
  • 除了 +0和 -0之外，与 SameValueZero 类似的 SameValue是相同的而不是不同的(Map用于键，Array.prototype.includes用于键)。

还有 对象等价性对象等价性，它不是由语言或运行时本身提供的，但通常表示为: 对象具有相同的原型，相同的属性，并且它们的属性值是相同的(根据“相同”的一些合理定义)。

SameValue 算法 :

  • 如果 Type (x)与 Type (y)不同，则返回 false。
  • 如果 Type (x)是 Number，则
    • 如果 x 是 NaN，y 是 NaN，返回 true。
    • 如果 x 为 + 0，y 为 -0，返回 false。
    • 如果 x 为 -0，y 为 + 0，返回 false。
    • 如果 x 与 y 的 Number 值相同，则返回 true。
    • 返回假。
  • 返回 SameValueNonNumber (x，y)。

SameValueNonNumber在哪里:

  • 断言: Type (x)不是 Number。
  • 断言: Type (x)与 Type (y)相同。
  • 如果 Type (x)未定义，则返回 true。
  • 如果 Type (x)为 Null，则返回 true。
  • 如果 Type (x)是 String，则
    • 如果 x 和 y 是完全相同的代码单位序列(相同的长度和相同的代码单位对应的索引) ，返回 true; 否则返回 false。
  • 如果 Type (x)是 Boolean，则
    • 如果 x 和 y 都为 true 或者都为 false，则返回 true; 否则返回 false。
  • 如果类型(x)是符号，则
    • 如果 x 和 y 都是相同的符号值，则返回 true; 否则返回 false。
  • 如果 x 和 y 是相同的 Object 值，返回 true。否则，返回 false。

严格相等算法 :

  1. 如果 Type (x)与 Type (y)不同，则返回 false。
  2. 如果 Type (x)是 Number，则
    • 如果 x 是 NaN，返回 false。
    • 如果 y 是 NaN，则返回 false。
    • 如果 x 与 y 的 Number 值相同，则返回 true。
    • 如果 x 为 + 0，y 为 -0，返回 true。
    • 如果 x 为 -0，y 为 + 0，返回 true。
    • 返回假。
  3. 返回 SameValueNonNumber (x，y)。
小开 

Object.is = function(v1, v2){
//test for `-0`
if(v1 === 0 && v2 === 0) {
return 1 / v1 === 1 / v2;
}
  

//test for `NaN`
if(v1 !== v1) {
return v2 !== v2;
}
  

//everything else
return v1 === v2;
}

上面这个填充函数展示了 Object.is是如何工作的，有兴趣的人可以了解。对 你不知道的 JS的引用

小开

摘要:

Object.is()函数接受2个值作为参数，如果给定的2个值完全相同，则返回 true，否则返回 false。

我们为什么需要这个？

您可能会想，我们已经在 javascript 中使用 ===运算符进行了严格的相等检查(检查类型 + 值) ，为什么还需要这个函数呢？在某些情况下，严格的平等是不够的，它们是这样的:

console.log(NaN === NaN);   // false
console.log(-0 === +0);     // true

Object.is()帮助我们比较这些值，看看它们是否相似，这是严格相等运算符无法做到的。

console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(-0, 0));     // false
console.log(Object.is(+0, +0));    // true
console.log(Object.is(+0, -0));    // false

小开

简而言之，他们是相似的，但 Object.is更聪明，更准确..。

我们来看看这个。

+0 === -0 //true

但这是不完全正确的，因为它忽略了 -和 +之前..。

现在我们使用:

Object.is(+0, -0) //false

如您所见，这个比较更准确。

同样在 NaN的情况下，工作更像是正确的，因为考虑任何 NaN相同。

小开

===被认为是一种严格的比较，它将返回一个布尔值，指示操作数是否具有相同的类型和内容是否匹配。

对于 +/-0和 NaN 情况，Object.is的表现与 ===相同

console.log({} === {}) // false
console.log(Object.is({}, {})) // false


console.log(1 === 1) // true
console.log(Object.is(1, 1)) // true


console.log(NaN === NaN) // false
console.log(Object.is(NaN, NaN)) // true


console.log(+0 === -0) // true
console.log(Object.is(+0, -0)) // false


提交答案