JavaScript 相等运算符：== 与 === 的区别及 Object.is

判断“是否相等”的两种方式

JavaScript 提供了两个相等运算符：===（严格）和 ==（宽松）。它们看起来几乎一样，行为却大不相同。

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

console.log(1 == 1);       // true
console.log(1 == "1");     // true

=== 检查两个操作数是否类型相同并且值相同。== 会先把操作数转换为同一种类型，然后再比较。这种转换，也就是类型强制转换，正是 JavaScript 相等比较“名声在外”的主要原因。

简短的结论是：默认使用 ===。长一点的解释值得读一遍，这样你就知道自己放弃了什么。

严格相等：你多半想要的那个

只有当两边的类型和值都一致时，=== 才返回 true。没有强制转换，也没有意外：

console.log(42 === 42);           // true
console.log("hi" === "hi");       // true
console.log(true === true);       // true

console.log(42 === "42");         // false - different types
console.log(0 === false);         // false - different types
console.log(null === undefined);  // false - different types

如果类型不一致，结果立刻就是 false。如果类型一致，JavaScript 再比较值。对原始值来说，比较的是值；对对象来说，比较的是引用（稍后会详细讲）。

!== 是严格不相等运算符，规则相同，结果相反。

宽松相等：伪装起来的类型转换

== 允许两边的类型不同。比较之前，它会经过一系列强制转换，试图让两边的类型一致：

console.log(1 == "1");        // true - string becomes number
console.log(0 == false);      // true - boolean becomes number
console.log("" == 0);         // true - string becomes number
console.log(null == undefined); // true - special-cased
console.log("0" == false);    // true - both become 0

确切的规则写在规范里，其实也没那么糟，但调试到一半时要想起它们就是另一回事了。"0" == false 为 true 这一点，连有经验的开发者都会中招。[] == false 也一样（结果同样是 true，因为数组会被转换为 ""，而 "" 又被转换为 0）。

这就是为什么大多数代码风格指南，以及 ESLint 的 eqeqeq 规则，都要求默认使用 ===。多打一个字符，换来的是你真正记得住的规则。

唯一实用的 == 写法

有一个宽松相等的惯用法值得了解：当 x 为 null 或 undefined 时，x == null 返回 true，其他情况都返回 false。

function greet(name) {
    if (name == null) {
        return "Hello, stranger";
    }
    return `Hello, ${name}`;
}

console.log(greet());           // Hello, stranger
console.log(greet(null));       // Hello, stranger
console.log(greet("Rosa"));     // Hello, Rosa
console.log(greet(0));          // Hello, 0 - not treated as missing

对应的严格写法是 x === null || x === undefined，也能用，但读起来更啰嗦。很多代码库把 == null 当作唯一被认可的例外。选定一条规则，然后始终如一地执行。

对象按引用比较

对于对象、数组和函数，=== 和 == 问的是同一个问题：“两边是否指向内存中的同一个对象？”而不是“它们的内容是否相同？”

const a = { name: "Ada" };
const b = { name: "Ada" };
const c = a;

console.log(a === b);  // false - different objects
console.log(a === c);  // true - same reference
console.log(a == b);   // false - still different objects

两个内容完全相同的对象字面量，仍然是两个不同的对象。每个人都至少会在这里栽一次。

要按值比较，你可以自己写一个辅助函数，使用库（lodash.isequal），或者对简单的普通对象用 JSON.stringify 序列化后比较：

const a = { x: 1, y: 2 };
const b = { x: 1, y: 2 };

console.log(JSON.stringify(a) === JSON.stringify(b)); // true

JSON.stringify 只适用于简单数据：它会忽略函数、undefined 和 symbol，而且对于某些结构，它不能保证不同引擎中键的顺序一致。它只是一种快速检查，而不是通用的解决方案。

NaN 不等于任何值

当数值运算没有有意义的结果时，JavaScript 会返回 NaN（“不是一个数字”），比如 0/0、Number("abc")、Math.sqrt(-1)。只要任意一边是 NaN，两个相等运算符都返回 false，两边都是 NaN 时也一样：

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

const result = Number("oops");
console.log(result);              // NaN
console.log(result === NaN);      // false - doesn't work
console.log(Number.isNaN(result)); // true - this is the check

要检测 NaN，使用 Number.isNaN(value)。不要使用较老的全局函数 isNaN：它会先对参数进行强制转换，所以 isNaN("hello") 会返回 true，这几乎从来都不是你想要的。

Object.is：几乎就是 ===，修正了两处

Object.is(a, b) 的行为与 === 相同，只有两种边界情况例外：

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

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

大多数时候你想要的是 ===。只有当你确实需要让 NaN 等于它自己，或者区分 +0 和 -0 时，才用 Object.is。这两种情况都很少见，但在数值计算代码和框架内部偶尔很重要（React 就用 Object.is 来比较状态）。

不相等运算符同样分为两种

!== 是严格的，!= 是宽松的，建议也一样：

console.log(1 !== "1");  // true  - different types
console.log(1 != "1");   // false - coerced, values match

console.log(null !== undefined); // true
console.log(null != undefined);  // false

默认使用 !==。如果你已经允许了 == null，也可以允许与之对应的 != null，用来检查“既不是 null 也不是 undefined”。

比较值的检查清单

需要比较两个值时，按下面的顺序过一遍：

• 原始值，预期类型相同？ 用 ===。
• 检查 null 或 undefined？ 如果你的风格指南允许，x == null 没问题；否则用 x === null || x === undefined。
• 检查 NaN？ 用 Number.isNaN(x)。
• 按引用比较对象？ === 正好满足需求。
• 按内容比较对象？ 写一个辅助函数、使用库，或者序列化。内置运算符帮不上忙。

坚持使用 ===，只在 == null 这种场景下把 == 当作特殊工具，你就能避开那些塞满 JavaScript 常见问题列表的相等比较怪癖。

下一步：运算符

相等运算只是 JavaScript 运算符中的一部分。下一篇文档会讲解其余的运算符：算术运算符、逻辑运算符、赋值运算符，以及日常代码中经常用到的简写运算符。