Object.is如何实现严格比较详解

在JavaScript中，`Object.is()` 方法提供了一种严格的值比较方式，尤其擅长处理 `NaN` 和带符号零这两种特殊情况，弥补了严格相等运算符 `===` 的不足。与 `===` 不同，`Object.is(NaN, NaN)` 返回 `true`，而 `NaN === NaN` 返回 `false`；同时，`Object.is(+0, -0)` 返回 `false`，而 `+0 === -0` 返回 `true`。在其他情况下，`Object.is()` 与 `===` 行为一致，不进行类型转换，且对象比较基于引用。本文将深入探讨 `Object.is()` 的实现原理、应用场景以及兼容性问题，助你更好地理解和运用这一特性，编写更严谨的JavaScript代码。

Object.is与===的核心区别在于对NaN和带符号零的处理。1. NaN比较：Object.is(NaN, NaN)返回true，而NaN === NaN为false；2. +0与-0比较：Object.is(+0, -0)返回false，而===认为它们相等。其他情况下二者行为一致，均不进行类型转换且对象比较基于引用。

在JavaScript的世界里，判断两个值是否相等，我们通常会想到==和===。但如果我告诉你，还有一个更“较真”的选手，它能处理连===都搞不定的细微差别，那就是Object.is()。简单来说，它提供了一种极致的严格比较，尤其是在区分+0、-0和NaN这些特殊值时，它能确保你得到的是真正意义上的精确匹配。

解决方案

Object.is()方法用于判断两个值是否是相同的值。它在行为上与===（严格相等运算符）非常相似，但在两个关键的边缘情况上有所不同：

1. NaN的比较：Object.is(NaN, NaN)返回true，而NaN === NaN返回false。
2. +0和-0的比较：Object.is(+0, -0)返回false，而+0 === -0返回true。

在所有其他情况下，Object.is()的行为与===完全相同。它不会进行类型转换，所以像Object.is(1, '1')这样的比较会返回false。对于对象（包括数组和函数），Object.is()只在它们引用同一个内存地址时才返回true，即进行引用比较，而不是值比较。

这背后的逻辑是，Object.is()遵循的是ECMAScript规范中的“SameValue”算法，而===遵循的是“Strict Equality Comparison”算法。SameValue算法在处理NaN和带符号的零时，对值的“身份”有更严格的定义。

代码示例：

// 基础比较，与 === 行为一致
console.log(Object.is(25, 25));               // true
console.log(Object.is('foo', 'foo'));         // true
console.log(Object.is('foo', 'bar'));         // false
console.log(Object.is(null, null));           // true
console.log(Object.is(undefined, undefined)); // true
console.log(Object.is(window, window));       // true
console.log(Object.is([], []));               // false (不同对象引用)
let a = {};
console.log(Object.is(a, a));                 // true (相同对象引用)
console.log(Object.is(1, '1'));               // false (不同类型，无类型转换)

// 关键区别：NaN
console.log(Object.is(NaN, NaN));             // true
console.log(NaN === NaN);                     // false

// 关键区别：+0 和 -0
console.log(Object.is(0, -0));                // false
console.log(0 === -0);                        // true

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

在我看来，这种“较真”在某些场景下是很有必要的。比如说，你可能真的需要区分一个数值是正向的零还是负向的零，这在某些图形计算或者物理模拟中或许有实际意义。而NaN与自身相等，这在处理不确定数值时，往往比它不相等更符合直觉。

Object.is和===操作符的核心区别是什么？

要理解Object.is的独特之处，就得把它和我们更熟悉的===操作符拎出来对比一下。说实话，它们绝大部分时候的表现是一致的，但在两个非常特定的边缘案例上，它们分道扬镳了，这也是Object.is存在的最大理由。

1. NaN的自我比较： 这是最常见的“JavaScript怪癖”之一。在JavaScript中，NaN（Not-a-Number）是一个非常特别的值，它的设计初衷就是为了表示那些无法表示的数值结果。所以，NaN === NaN的结果是false，这有时候让人很头疼，因为你无法直接用===来判断一个变量是不是NaN。

console.log(NaN === NaN); // false

而Object.is在这里就显得“正常”多了，它认为NaN就是NaN，它们是同一个“非数字”的值：

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

这让检查一个值是否为NaN变得更直观，如果你不想使用isNaN()（因为isNaN('hello')也会返回true，它有自己的类型转换逻辑），那么Object.is(myValue, NaN)是一个更精确的选择。

2. +0和-0的区分： 在IEEE 754浮点数标准中，是存在正零（+0）和负零（-0）的概念的。虽然它们在数学上都代表零，但在某些底层计算或表示方向的场景下，区分它们可能是有意义的。然而，===操作符在比较它们时，会认为它们是相等的：

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

Object.is则不然，它认为+0和-0是两个不同的值，因为它更关注值的“身份”而非单纯的数值：

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

除了这两个点，其他所有情况，Object.is和===的行为都保持一致。它们都进行严格比较，不进行类型强制转换，并且对于对象，都只比较引用是否相同。所以，Object.is并不是===的完全替代品，它更像是===的一个“补丁”，用来处理那些===显得不够严格的边缘情况。

在哪些场景下，Object.is会是你的首选比较工具？

虽然Object.is在日常开发中可能不像===那样高频出现，但在一些特定且关键的场景下，它确实能派上大用场，甚至可以说，它是解决某些问题的“最佳实践”。

1. 精确判断NaN值： 这是Object.is最常见的用例之一。当你的程序可能产生NaN（比如数学运算失败、解析字符串为数字失败等），并且你需要精确地知道一个变量是否就是NaN本身时，Object.is(value, NaN)比其他方法更可靠。比如，你从一个API获取了一个可能无效的数值，或者在处理用户输入时，想知道用户输入的是否真的是一个“非数字”的值。传统的isNaN()函数会把字符串'hello'也判断为true，这在某些情况下可能不是你想要的。

function isExactlyNaN(val) {
  return Object.is(val, NaN);
}

console.log(isExactlyNaN(0 / 0));      // true
console.log(isExactlyNaN(parseInt('abc'))); // true
console.log(isExactlyNaN('hello'));    // false (而 isNaN('hello') 是 true)

2. 区分+0和-0的数值逻辑： 这听起来可能有点钻牛角尖，但有时候，正是这些看似微不足道的细节，决定了代码的健壮性。在一些涉及浮点数运算、图形渲染（比如SVG路径的绘制方向）、物理模拟或金融计算的场景中，+0和-0可能携带了方向或状态信息。例如，一个表示速度的零值，其符号可能指示了物体是从哪个方向停止的。

function processZeroValue(value) {
  if (Object.is(value, -0)) {
    console.log("处理负零：可能表示从负方向趋近于零或特定边界条件。");
  } else if (Object.is(value, +0)) {
    console.log("处理正零：可能表示从正方向趋近于零或标准零。");
  } else {
    console.log("这不是一个零值。");
  }
}

processZeroValue(0);  // 处理正零
processZeroValue(-0); // 处理负零

3. 框架和库的内部状态管理： 一些高级的JavaScript框架或库，特别是在实现响应式系统或虚拟DOM diff算法时，可能会在内部使用Object.is来判断一个值是否真的发生了变化，从而决定是否需要重新渲染或触发更新。这种精确的比较可以避免不必要的计算和性能开销，尤其是在处理那些可能出现NaN或带符号零的复杂数据结构时。它能确保只有当数据真正“不同”时才执行操作。

所以，当你需要对值的“身份”进行极度精确的匹配，尤其是在处理数值的边缘情况时，Object.is就是那个能让你代码更严谨、更可靠的工具。

Object.is的兼容性如何？使用时有什么需要注意的“陷阱”吗？

Object.is是一个非常实用的特性，但就像任何工具一样，了解它的兼容性和潜在的“陷阱”是至关重要的，这样才能避免踩坑。

兼容性方面：

Object.is是在ES6（ECMAScript 2015）中引入的。这意味着，对于现代的JavaScript开发环境，它的兼容性是相当不错的。

• 现代浏览器： Chrome、Firefox、Safari、Edge等主流浏览器的最新版本都完全支持Object.is。

• Node.js： Node.js环境也从很早的版本就开始支持Object.is。

• IE浏览器： Internet Explorer 11及以下版本不支持Object.is。不过，考虑到IE的市场份额已经非常小，并且很多现代Web应用已经不再支持IE，这通常不是一个大问题。

• Polyfill： 如果你确实需要兼容非常老的浏览器环境，可以通过polyfill来引入Object.is的功能。一个简单的polyfill实现可能看起来像这样（仅为示例，实际使用请选择成熟的polyfill库）：

  if (!Object.is) {
    Object.is = function(x, y) {
      if (x === y) {
        // 处理 +0 === -0 的情况
        return x !== 0 || 1 / x === 1 / y;
      } else {
        // 处理 NaN === NaN 的情况
        return x !== x && y !== y;
      }
    };
  }

总的来说，在绝大多数现代Web开发项目中，你可以放心地使用Object.is，而无需过多担心兼容性问题。

使用时的“陷阱”：

尽管Object.is很强大，但它并不是一个可以随意替换===的万能钥匙。以下是一些你可能需要注意的“陷阱”：

1. 不是===的完全替代品： 这是最需要强调的一点。Object.is只是在NaN和带符号零的特定情况下比===更严格。在其他所有情况下，它们的行为是相同的。如果你不需要区分+0和-0，也不需要NaN和NaN相等，那么继续使用===可能更符合你的直觉，也更简洁。无脑地将所有===替换为Object.is，不仅可能导致不必要的性能开销（尽管微乎其微），也可能让代码的意图变得不那么清晰。

2. 对象比较依然是引用比较： 很多人会误以为Object.is能进行对象的深层值比较，但事实并非如此。就像===一样，Object.is在比较非原始值（对象、数组、函数等）时，仍然只比较它们的引用是否指向同一个内存地址。

   const obj1 = { a: 1 };
   const obj2 = { a: 1 };
   console.log(Object.is(obj1, obj2)); // false (不同引用)
   console.log(Object.is(obj1, obj1)); // true (相同引用)

   如果你需要进行深层比较，你需要自己实现一个递归比较函数，或者使用lodash等库提供的工具。

3. 性能考量（通常可忽略）： Object.is是一个函数调用，而===是一个运算符。理论上，函数调用会比直接的运算符操作带来微小的性能开销。但在绝大多数实际应用中，这种差异几乎可以忽略不计，除非你在一个极度性能敏感的循环中每秒执行数百万次比较。所以，不要因为这个原因而放弃在需要时使用Object.is。

4. 过度使用可能降低可读性： 如果你的业务逻辑根本不关心+0和-0的区别，也不需要NaN的特殊处理，那么坚持使用===会让代码更符合“最小惊讶原则”。使用Object.is反而可能让读者疑惑，是不是这里有什么特别的数值处理需求。

总之，Object.is是一个精准的工具，它解决了===在特定边缘情况下的不足。理解它的设计意图和适用场景，能帮助你编写出更健壮、更精确的JavaScript代码。

本篇关于《Object.is如何实现严格比较详解》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！