ECMA262比较操作

September 10, 2024November 3, 2024

ecma262

截止编写日期，下面引用来源为：ECMAScript® 2025 Language Specification

等式运算符

等式运算符作为二元运算符，但注意等式两边不满足等价关系。因为其满足自反性、对称性，但不满足传递性。

根据 ECMA262 给出的 4 个注释，我们可以再加以解释：

以下命题为真
凭此可强制使用字符串比较：`${a}` == `${b}`
凭此可强制使用数值比较：+a == +b
凭此可强制使用布尔值比较： !a == !b
以下命题为真
A != B 等价于 !(A == B)
A == B 等价于 B == A ，当然， A 与 B 的执行顺序除外
不满足传递性是因为存在特例，例如
new String("a") == "a" 和 "a" == new String("a") 都为 true
new String("a") == new String("a") 为 false
字符串比较对代码单元值序列使用简单的相等性测试。没有尝试使用 Unicode 规范中定义的更复杂、面向语义的字符或字符串相等性和排序顺序定义。因此，根据 Unicode 标准，规范上相等的字符串值可能被测试为不相等。实际上，该算法假设两个字符串都已处于规范化形式。

IsStrictlyEqual(x, y)

若 SameType(x, y) 为 false，返回 false。

即按顺序判断是否都是 undefined, null, Boolean, Number, BigInt, Symbol, String, Object 类型
若 x 是 Number，则

注意 NaN 也属于 Number
1. 返回 Number::equal(x, y)。
  
  与 IEEE754 一致，即 NaN!=NaN，+0=-0
返回 SameValueNonNumber(x, y)。

此操作实际上就是将比较操作委托到具体类型。但注意由于输入参数已经是同类型，当 x 为 undefined 或 null 时直接返回 true

IsLooselyEqual(x, y)

若 SameType(x, y) 为 true, 则 1. 返回 IsStrictlyEqual(x, y).

类型相同时，完全等同于严格比较
若 x 为 null 且 y 为 undefined, 返回 true.
若 x 为 undefined 且 y 为 null, 返回 true.

这两步是对称的，表示 null 与 undefined 松散相等
NOTE: This step is replaced in section B.3.6.2.
若 x 是一个 Number 且 y 是一个 String, 返回 ! IsLooselyEqual(x, ! ToNumber(y)).
若 x 是一个 String 且 y 是一个 Number, 返回 ! IsLooselyEqual(! ToNumber(x), y).

这两步是对称的，对于字符串与数字的比较，字符串总是转为数字
若 x 是一个 BigInt 且 y 是一个 String, 则
1. 令 n 为 StringToBigInt(y).
2. 若 n 是 undefined, 返回 false.
3. Return ! IsLooselyEqual(x, n).
若 x 是一个 String 且 y 是一个 BigInt, 返回 ! IsLooselyEqual(y, x).

这两步和上两步一致
若 x 是一个 Boolean, 返回 ! IsLooselyEqual(! ToNumber(x), y).
若 y 是一个 Boolean, 返回 ! IsLooselyEqual(x, ! ToNumber(y)).

这两步是对称的，对于与布尔值的比较，总是转为数字再与布尔值比较
若 x 为 String, Number, BigInt, 或 Symbol 中的一个且 y 是一个 Object, 返回 ! IsLooselyEqual(x, ? ToPrimitive(y)).
若 x 是一个 Object 且 y 是 String, Number, BigInt, 或 Symbol 中的一个, 返回 ! IsLooselyEqual(? ToPrimitive(x), y).

这两步是对称的，对于与对象的比较，对象总是会通过 ToPrimitive 抽象操作转为原始值
若 x 是一个 BigInt 且 y 是一个 Number, 或若 x 是一个 Number 且 y 是一个 BigInt, 则
1. 若 x 不是 finite 或 y 不是 finite, 返回 false.
2. 若 ℝ(x) = ℝ(y), 返回 true; 否则返回 false.

可以发现，原始值之间的比较几乎就是将双方转为数字（ToNumber）再比较。
若包含对象，对象也是先转为原始值（ToPrimitive），最后其实还是要转为数字来比较。

ToPrimitive(input [,preferredType])

If input is an Object, then
1. Let exoticToPrim be ? GetMethod(input, %Symbol.toPrimitive%).
2. If exoticToPrim is not undefined, then
  1. If preferredType is not present, then
    1. Let hint be "default".
  2. Else if preferredType is string, then
    1. Let hint be "string".
  3. Else,
    1. Assert: preferredType is number.
    2. Let hint be "number".
  4. Let result be ? Call(exoticToPrim, input, « hint »).
  5. If result is not an Object, return result.
  6. Throw a TypeError exception.
3. If preferredType is not present, let preferredType be number.
4. Return ? OrdinaryToPrimitive(input, preferredType).
Return input.

Object.is(value1, value2)

返回 SameValue(value1, value2).

Object.is 就是暴露了 SameValue 抽象操作，见下

SameValue(x, y)

本质上就是为了区别于 IsStrictlyEqual(x, y) 抽象操作，它视 NaN 与 NaN 相等，+0 与 -0 不相等（这与 IsStrictlyEqual 得到的结果正好相反）。

可以看出，唯一区别就是对 Number 类型的处理有差异，其余步骤是完全一致的。

若 SameType(x, y) 是 false, 返回 false.
若 x 是 Number, 则
返回 Number::sameValue(x, y).
返回 SameValueNonNumber(x, y).