JavaScript比较参数的底层执行过程是怎样的

一、参数求值顺序与表达式副作用保证

在探讨类型转换之前，很多人容易忽略参数的求值时序（Evaluation Order）。在 ECMAScript 规范中，二元比较表达式 LeftHandSideExpression < RightHandSideExpression 的底层算法第一步，并不是检查类型，而是严格按照从左到右的顺序计算两个表达式的实际值。

规范明确要求：无论后续的具体比较算法如何运转（即使在 > 比较中，规范底层会将比较谓词倒转为 <），左操作数表达式总是先于右操作数表达式求值并调用内部的 GetValue 解析引用。这意味着表达式若包含函数调用或递增变量等副作用，左侧副作用必然先于右侧发生。

let counter = 0;
function getA() { counter += 10; return counter; }
function getB() { counter *= 2;  return counter; }

// 严格先计算 getA() 得到 10（counter 变为 10）
// 再计算 getB() 得到 20（counter 变为 20）
console.log(getA() < getB()); // true (10 < 20)

// 即便使用大于号：仍然先执行 getA()，再执行 getB()
// 规范在完成双方表达式求值后，才将运算转换为 IsLessThan(B, A, false)
counter = 0;
console.log(getA() > getB()); // false (10 > 20 为假)

二、底层拆箱核心：ToPrimitive 抽象操作的执行流

当比较参数包含复合类型（如 Object、Array、Date、RegExp）时，JavaScript 引擎无法直接度量内存引用与基本数值之间的大小，必须调用规范内置的抽象操作 ToPrimitive(input [, preferredType]) 将其降维拆箱为原始值（Primitive）。

该抽象操作的底层判定逻辑具有严密的层次顺序：

1. 原始类型守卫：若 Type(input) 本身就不是 Object（如已经是 Number、String、Boolean、Symbol 或 BigInt），直接原样返回该值。
2. 检查自定义拆箱符号：查找对象上是否存在 [Symbol.toPrimitive] 属性。若存在且是可调用函数，则直接以当前 hint 调用该方法。若返回值是原始类型则采纳；若返回仍然是对象，引擎将立即中断执行并抛出 TypeError。
3. 传统回退流水线：若未定义 [Symbol.toPrimitive]，引擎依据提示符 preferredType 决定回退方法的尝试顺序：
   • 若 hint 为 "string"：优先调用 toString()，若返回原始值则采用；否则再调用 valueOf()。
   • 若 hint 为 "number" 或未指定（"default"）：优先调用 valueOf()，若返回原始值则采用；否则再调用 toString()。
4. 异常中断：若两次方法调用后得到的值仍然是对象，引擎将抛出 TypeError: Cannot convert object to primitive value。

在比较运算中，不同运算符传入的 preferredType 具有重要差异：

• 关系比较（<, >, <=, >=）：默认传给 ToPrimitive 的 hint 严格为 "number"。
• 宽松相等（==）：传给 ToPrimitive 的 hint 为 "default"。在 ECMAScript 规范中，除了 Date 对象将 "default" 视为 "string" 外，所有常规 JavaScript 对象（包括 Array、普通 Object）均将 "default" 视同 "number" 处理。

这也解释了为什么普通数组 [2] 会依次经历：检查 [Symbol.toPrimitive]（无）→ 调用 [2].valueOf()（返回自身数组对象，非原始类型）→ 调用 [2].toString()（得到字符串 "2"，是原始类型），最终成功拆箱为 "2"。

三、抽象关系比较（IsLessThan）底层决策树与衍生映射

当开发者执行关系比较（如 a < b）时，JavaScript 引擎底层调用的是规范中的 抽象关系比较算法（Abstract Relational Comparison / IsLessThan）。该算法的底层流程决定了所有大小比较的最终命运。

1. 算法执行四步走

1. 拆箱两端参数：分别对左右操作数调用 px = ToPrimitive(x, number) 与 py = ToPrimitive(y, number)。
2. 双字符串分支：如果 px 和 py 的类型均为 String，算法不会将它们转为数字，而是直接按 UTF-16 码元序列（Code Unit Value）进行字典序逐字符对比。这就是 "11" < "2" 结果为 true 的根源，因为字符 '1' 的码元 49 小于 '2' 的码元 50。
3. 强制数值化转换：如果至少有一个参数不是 String，算法将调用 ToNumeric（在常规情况下即 ToNumber）将两者强制转换为数值：nx = ToNumeric(px)，ny = ToNumeric(py)。
4. IEEE 754 规则裁定：
   • NaN 传染判定：如果 nx 或 ny 中有任意一个是 NaN，算法返回 undefined（注意不是 false）。外层运算符接收到 undefined 后统一折算为 false。
   • 零值判定：+0 与 -0 在数值上视为相等，比对返回 false。
   • 无穷大判定：+Infinity 大于除自身外的所有实数，-Infinity 小于除自身外的所有实数。

2. 衍生运算符的本质映射

ECMAScript 规范并未为 >、<=、>= 分别设计独立的比对引擎，而是全部映射到底层的 IsLessThan：

• x > y：等价于执行 IsLessThan(y, x, false)。
• x <= y：等价于执行 r = IsLessThan(y, x, true)。如果 r 为 true 或 undefined，则返回 false，否则返回 true。换言之，其语义为“非（y < x）”。
• x >= y：等价于执行 r = IsLessThan(x, y, true)。如果 r 为 true 或 undefined，则返回 false，否则返回 true。换言之，其语义为“非（x < y）”。

这个“非（小于）”的映射模型，是解释 JavaScript 诸多比较悖论的终极钥匙。

四、抽象相等（==）与严格相等（===）的参数比对机制

与关系比较不同，相等比较不关心大小，核心在于“等价性认定”。在 JavaScript 中存在两种主要的比较操作：严格相等（=== / IsStrictlyEqual）与抽象相等（== / IsLooselyEqual）。

1. 严格相等（===）的极速路径

IsStrictlyEqual(x, y) 不进行任何隐式类型转换：

• 若 Type(x) !== Type(y)，直接返回 false。
• 若两者均为 Number：NaN === NaN 永远为 false；+0 === -0 为 true；其余按实际数值比对。
• 若两者均为 Object：仅当两个操作数指向堆内存中的同一物理内存引用时才返回 true。

2. 抽象相等（==）的类型降维同化链

宽松相等 IsLooselyEqual(x, y) 会在类型不同时递归进行类型同化，其底层优先级如下：

1. 同类型直通：类型相同时，直接走严格相等判定。
2. 空值双雄闭环：null == undefined 返回 true。且规范中明确规定，null 与 undefined 不与其它任何类型相等（即它们在宽松相等中绝不转为数字 0 或布尔值）。
3. 布尔型优先数值化：只要有一方是 Boolean，规范强制先将该布尔值通过 ToNumber() 转为数值（true -> 1，false -> 0），然后再递归比较。
4. 字符串与数字同化：若一边是 String 另一边是 Number，调用 ToNumber(String) 将字符串解析为数值后比对。
5. 对象向原始值降维：若一边是 Object，另一边是 String、Number、BigInt 或 Symbol，调用 ToPrimitive(Object) 降维后再重新开始一轮比较。

五、经典反直觉案例深度推导与归因

通过掌握上述的底层规范流程，我们可以对 JavaScript 社区中广为人知的“未解之谜”建立完全确定性的推导。

1. null 与 0 的“薛定谔关系”

console.log(null > 0);  // false
console.log(null == 0); // false
console.log(null >= 0); // true

初学者常常困惑：既然 null 既不大于 0，也不等于 0，为什么 null >= 0 却偏偏是 true？

底层规范推导链：

• null > 0：触发关系比较 IsLessThan(0, null)。非全字符串，转为数字：ToNumeric(null) 得到 0。计算 0 < 0，数学上为假，返回 false。
• null == 0：触发宽松相等 IsLooselyEqual(null, 0)。对照规范规则：null 只与 undefined 宽松相等，绝不触发 ToNumber 转换。规则未命中，直接返回 false。
• null >= 0：前面提到，x >= y 在规范中的定义是 !(x < y)！引擎计算 null < 0：转数值 0 < 0 得到 false。外层取反：!false 得到 true！

因此，并非 JavaScript “把 null 变成了 0 又没有变成 0”，而是 >= 的本质是“求反运算”，两套不同规范算法（IsLessThan 与 IsLooselyEqual）的设计分支导致了表象上的割裂。

2. 神奇等式：[] == ![]

console.log([] == ![]); // true

一个空数组怎么可能等于它自身的逻辑非？

底层状态机逐帧解析：

1. 单目运算符先决求值：右侧是 ![]。在 JavaScript 中，所有 Object（包括空数组 []）在布尔上下文中均为真值（truthy），因此 ![] 计算为 false。表达式变为 [] == false。
2. 布尔型降维：规范规定宽松相等遇布尔值先转数值，ToNumber(false) 产生 0。表达式变为 [] == 0。
3. 对象拆箱：左侧为对象，右侧为数字，触发 ToPrimitive([], "default")。数组调用 valueOf() 返回数组自身；继续调用 [].toString() 得到空字符串 ""。表达式变为 "" == 0。
4. 字符串数值化：字符串与数字比较，触发 ToNumber("")，空字符串被转为 0。表达式变为 0 == 0。
5. 数值等价终审：同类型数值比对，0 === 0 毫无疑问返回 true。

3. 数组字符串陷阱：[2] > [11]

console.log([2] > [11]);  // true
console.log([2] > 11);    // false

推导过程：

• 比较 [2] > [11]：双方均为对象，关系比较进行 ToPrimitive，分别得到 "2" 与 "11"。此时双方均为 String，直接进入字符串字典序判定！比较首字符 "2" 与 "1" 的码元，"2" > "1" 成立，因而返回 true。
• 比较 [2] > 11：左侧拆箱为 "2"，右侧为数字 11。此时非全字符串，触发 ToNumber("2") -> 2，最终执行数学比对 2 > 11，正确返回 false。

六、工程实践规范与避坑原则

理解了底层的严密执行链条后，在日常工程研发中应当遵循以下最佳实践：

总而言之，JavaScript 的比较操作绝非不可预测的“魔法”，其背后是 ECMAScript 规范定义的一整套高度严谨、状态完备的底层算法。掌握自左向右求值、ToPrimitive 拆箱优先级、IsLessThan 决策树以及衍生反转模型，便能透彻掌控代码运行时的真实行为。