JavaScript中Object.is()与===比较字符串有何不同

作者:闭包旅人时间:2026-11-20 10:38:56浏览:245

深入解析JavaScript中Object.is()与全等运算符===在比较字符串时的异同。从ECMAScript规范的SameValue与IsStrictlyEqual算法出发,结合字面量、拼接、Unicode规范化与包装对象等典型场景,阐述底层判定机制与实践选型建议。

JavaScript 核心规范解析
JavaScript中Object.is()与===比较字符串有何不同
图 0:Object.is 与 === 在核心属性与字符串比较基础上的横向概览
核心结论先行:在 JavaScript 中,对于原始字符串类型(Primitive String),Object.is(strA, strB) 与全等运算符 strA === strB 的比较结果和判定逻辑没有任何不同。两者在底层均执行严格的字符序列对比(逐一校验长度与对应位置的 UTF-16 码元值)。哪怕包含空字符、特殊转义字符、Emoji 或未规范化的多字节组合,两者的布尔输出完全保持一致。

一、为什么开发者会产生“两者可能不同”的疑惑

在日常开发与前端面试中,许多开发者都知道 ES6 新增的 Object.is() 被称为“更严格的相等性判定”。其主要原因在于它修复了全等运算符 === 遗留的历史特殊行为:

  • 在 === 下,NaN === NaN 的结果为 false,而 Object.is(NaN, NaN) 的结果为 true;
  • 在 === 下,+0 === -0 的结果为 true,而 Object.is(+0, -0) 的结果为 false。

正因为 Object.is() 在数字类型上的特殊处理,容易引发一种思维惯性:“既然 Object.is 比 === 更严谨,那它在比较字符串时是否也存在额外处理?”例如是否会做 Unicode 字符归一化?是否能区分字面量与包装对象?是否会处理内存地址差异?

另外,Java、C# 等面向对象语言的背景也加深了这种误解。在 Java 中,== 用于比较对象引用地址,而 equals() 比较字符串实际内容。但 JavaScript 的原始字符串并不是堆内存对象引用,=== 本身就是直接比对值内容的。

JavaScript中Object.is()与===比较字符串有何不同
图 1:ECMAScript 规范中处理字符串比较时的具体步骤与分支流向

二、ECMAScript 规范底层原理解析

要确凿证明两者毫无不同,最直接的方法是查阅 ECMAScript 官方规范中对两个操作的算法定义:

1. 全等运算符采用的 IsStrictlyEqual(x, y) 算法

当执行 x === y 时,JavaScript 引擎会调用规范中的 IsStrictlyEqual 抽象操作:

  1. 如果 Type(x) 与 Type(y) 类型不同,返回 false。
  2. 如果 Type(x) 是 Number,执行特定数值比较(包括 NaN !== NaN、+0 === -0 等规则)。
  3. 如果 Type(x) 是 String: “如果 x 和 y 是完全相同的代码单元序列(长度相同,且对应索引处的代码单元完全相同),返回 true;否则返回 false。”
  4. 如果 Type(x) 是 Boolean、BigInt、Symbol,按相应值判定。
  5. 如果 Type(x) 是 Object,当且仅当两者指向同一个对象内存地址时返回 true。

2. Object.is 采用的 SameValue(x, y) 算法

当执行 Object.is(x, y) 时,底层调用的是 SameValue 抽象操作:

  1. 如果 Type(x) 与 Type(y) 类型不同,返回 false。
  2. 如果 Type(x) 是 Number,区分 +0 与 -0,并将两个 NaN 视为相等。
  3. 如果 Type(x) 是 String: “如果 x 和 y 是完全相同的代码单元序列(长度相同,且对应索引处的代码单元完全相同),返回 true;否则返回 false。”
  4. 其他类型的处理规则与严格全等完全相同。

对比规范可以发现:第 3 步关于 String 类型的描述,在两个算法中的字面表述一字不差。这就从语言规范层面上证明了:两者对待原始字符串没有任何区别。

JavaScript中Object.is()与===比较字符串有何不同
图 2:跨场景实测对比矩阵,直观反映 Object.is 与 === 的完全一致性

三、实测与场景代码验证

为了验证上述结论,我们可以运行以下代码,覆盖常规开发与边缘情况中的常见字符串形式:

// 1. 常规字面量与拼接字符串比较
const s1 = "javascript";
const s2 = "java" + "script";
const s3 = `java${"script"}`;

console.log(Object.is(s1, s2)); // true
console.log(s1 === s2);        // true
console.log(Object.is(s1, s3)); // true
console.log(s1 === s3);        // true

// 2. 空字符串与空白字符
console.log(Object.is("", ""));       // true
console.log("" === "");              // true
console.log(Object.is("", " "));      // false
console.log("" === " ");             // false

// 3. 转义字符与不可见字符
const t1 = "line1\nline2";
const t2 = `line1\nline2`;
console.log(Object.is(t1, t2)); // true
console.log(t1 === t2);        // true

四、容易引发混淆的两个进阶场景

尽管两者的判断规则相同,但在处理以下两个特殊字符串场景时,常常会产生令人意外的比较结果。需要明确的是,这些“陷阱”是由 JavaScript 字符串本身的设计机制引起的,并非 Object.is() 与 === 之间的差异。

1. Unicode 组合字符与视觉等价性

在 Unicode 编码中,带有重音符号的字符(如法文字母 é)有两种完全合法的表示方式:

  • 单码元预合成字符(NFC 形式):\u00e9(对应字符 é,长度为 1);
  • 多码元组合字符(NFD 形式):e\u0301(基础字母 e 紧跟组合尖音符 \u0301,长度为 2)。

在屏幕渲染时,这两种形式的外观完全一致。但无论是 Object.is() 还是 ===,它们都只做二进制 UTF-16 码元比对,不会自动执行 Unicode 归一化。

JavaScript中Object.is()与===比较字符串有何不同
图 3:Unicode 视觉一致但码元不同的对比过程与 normalize 归一化方案
// Unicode 规范化示例代码
const strA = "caf\u00e9";  // NFC 预合成字符: "café"
const strB = "cafe\u0301"; // NFD 组合字符: "café"

// 直接比对:两者均判定为 false
console.log(Object.is(strA, strB)); // false
console.log(strA === strB);        // false

// 经过 NFC 归一化后再比对:两者均判定为 true
const normalizedA = strA.normalize("NFC");
const normalizedB = strB.normalize("NFC");
console.log(Object.is(normalizedA, normalizedB)); // true
console.log(normalizedA === normalizedB);        // true

2. 原始字符串与 String 包装对象(Wrapper Objects)

在 JavaScript 中,可以通过 "hello" 创建原始字符串,也可以通过 new String("hello") 创建字符串包装对象。此时的比较结果同样高度一致:

  • 原始字符串与包装对象比较:由于 typeof "hello" === 'string' 而 typeof new String("hello") === 'object',类型不同,Object.is 与 === 均判定为 false;
  • 两个包装对象之间比较:因为两者均是引用类型,比较的是对象在堆内存中的引用地址,即使包装的内容完全一样,各自通过 new 创建的对象引用不同,Object.is 与 === 均返回 false。
const primitiveStr = "test";
const objectStr1 = new String("test");
const objectStr2 = new String("test");

// 原始类型与包装对象对比
console.log(Object.is(primitiveStr, objectStr1)); // false
console.log(primitiveStr === objectStr1);        // false

// 两个独立包装对象对比
console.log(Object.is(objectStr1, objectStr2));   // false
console.log(objectStr1 === objectStr2);          // false

// 指向同一引用的对象对比
const objectRef = objectStr1;
console.log(Object.is(objectStr1, objectRef));    // true
console.log(objectStr1 === objectRef);           // true
JavaScript中Object.is()与===比较字符串有何不同
图 4:实际编码中的比较方法决策路径与最佳实践归纳

五、工程实践中的选型与性能建议

在明确了两者的异同与原理后,在实际工程项目中应该如何做选择?

1. 为什么字符串比较一律推荐使用 ===

  • 执行性能更高:全等运算符 === 是 JavaScript 语言的原生语法结构,在 V8、JavaScriptCore 等现代 JS 引擎中会直接被编译为机器指令级别的内联操作;而 Object.is(...) 是挂载在标准全局对象上的函数调用,虽然引擎进行了大量优化,但依旧存在函数查找与调用的轻微开销。
  • 符合代码规范与团队习惯:绝大多数前端代码规范(如 ESLint 推荐的 eqeqeq 规则)都倡导使用 === 进行常规相等性判断。直接使用 === 更加简洁直观,降低团队阅读成本。
  • 语义完全自洽:因为字符串比较不涉及 NaN 或 +0/-0,Object.is() 所带来的扩展特性在字符串领域完全处于“无用武之地”的状态。

2. 核心要点速查清单

比较维度 strA === strB Object.is(strA, strB) 结论说明
原始字符串值比较 逐码元严格相等 逐码元严格相等 完全一致
空字符串与拼接 内容相同即相等 内容相同即相等 完全一致
Unicode 未归一化多码元 返回 false 返回 false 完全一致(均需自行 normalize)
String 包装对象与原始值 类型不同,返回 false 类型不同,返回 false 完全一致(不触发类型转换)
执行开销 语法级操作,性能最高 函数调用,开销略高 推荐在字符串场景下使用 ===
作者最新文章
相关文章
更多