比较 JavaScript 中的事物 [详细解释]

曾经被困在想知道你是否需要......

a == b

或者

a === b

或者

isLooselyEqual(a, b)

或者

7.2.2 IsArray（参数）

---

抽象操作 IsArray 采用参数 argument。调用时它执行以下步骤：

1. 1. 如果Type（参数）不是 Object，则返回 false。

2. 2. 如果参数是一个Array 奇异对象，则返回 true。

3. 3. 如果参数是一个Proxy 外来对象，那么

   1. A。如果 argument.[[ProxyHandler]] 为 null，则抛出 TypeError 异常。

   2. b. 令目标为参数。[[ProxyTarget]]。

   3. C。返回 ？ IsArray（目标）。

4. 4.返回错误。

---

7.2.3 IsCallable（参数）

---

抽象操作 IsCallable 采用参数 argument （ECMAScript 语言值）。它确定参数是否是具有 [[Call]] 内部方法的可调用函数。调用时它执行以下步骤：

1. 1. 如果Type（参数）不是 Object，则返回 false。

2. 2. 如果参数有 [[Call]] 内部方法，则返回 true。

3. 3.返回错误。

---

7.2.4 IsConstructor（参数）

---

抽象操作 IsConstructor 采用参数 argument （ECMAScript 语言值）。它确定参数是否是具有 [[Construct]] 内部方法的函数对象。调用时它执行以下步骤：

1. 1. 如果Type（参数）不是 Object，则返回 false。

2. 2. 如果参数有 [[Construct]] 内部方法，则返回 true。

3. 3.返回错误。

---

7.2.5 是否可扩展 (O)

---

抽象操作 IsExtensible 采用参数 O（对象）。它返回一个完成记录，如果其 [[Type]] 正常，则具有一个布尔值 [[Value]]。它用于确定是否可以向 O 添加附加属性。调用时它执行以下步骤：

1. 1.断言：类型(O) 是对象。

2. 2.返回？O.[[IsExtensible]]()。

---

7.2.6 IsIntegralNumber（参数）

---

抽象操作 IsIntegralNumber 采用参数 argument。它确定参数是否是有限整数值。调用时它执行以下步骤：

1. 1. 如果Type（参数）不是 Number，则返回 false。

2. 2. 如果参数为 NaN、+∞ 或 -∞，则返回 false。

3. 3.如果floor ( abs ( ℝ (参数)))≠ abs ( ℝ (参数))，则返回false。

4. 4.返回真。

---

7.2.7 IsPropertyKey（参数）

---

抽象操作 IsPropertyKey 采用参数 argument （ECMAScript 语言值）。它确定参数是否是可用作属性键的值。调用时它执行以下步骤：

1. 1. 如果类型（参数）为字符串，则返回 true。

2. 2. 如果类型（参数）是符号，则返回 true。

3. 3.返回错误。

---

7.2.8 IsRegExp（参数）

---

抽象操作 IsRegExp 采用参数 argument。调用时它执行以下步骤：

1. 1. 如果Type（参数）不是 Object，则返回 false。

2. 2. 设匹配器为 ? 获取（参数，@@match）。

3. 3. 如果matcher不是未定义的，则返回！ ToBoolean（匹配器）。

4. 4. 如果参数有 [[RegExpMatcher]] 内部槽，则返回 true。

5. 5.返回错误。

---

7.2.9 IsStringPrefix(p,q)

---

抽象操作 IsStringPrefix 采用参数 p（字符串）和 q（字符串）。它确定 p 是否是 q 的前缀。调用时它执行以下步骤：

1. 1.断言：类型(p) 是字符串。

2. 2.断言：类型(q) 是字符串。

3. 3. 如果 q 可以是p 和其他字符串 r 的字符串连接，则返回 true。否则，返回 false。

Note

Any String is a prefix of itself, because r may be the empty String.

---

7.2.10 相同值（x，y）

---

抽象操作 SameValue 采用参数 x（ECMAScript 语言值）和 y（ECMAScript 语言值）。它返回一条完成记录，其 [[Type]] 为普通值，其 [[Value]] 为布尔值。调用时它执行以下步骤：

1. 1. 如果Type (x) 与Type (y)不同，则返回 false。

2. 2. 如果Type (x) 是 Number 或 BigInt，则

   1. A。返回 ！ 类型(x)::sameValue(x, y)。

3. 3.返回！ SameValueNonNumeric (x, y)。

Note

This algorithm differs from the [IsStrictlyEqual](https://tc39.es/ecma262/#sec-isstrictlyequal) Algorithm in its treatment of signed zeroes and NaNs.

---

7.2.11 SameValueZero ( x, y )

---

抽象操作 SameValueZero 采用参数 x（ECMAScript 语言值）和 y（ECMAScript 语言值）。它返回一条完成记录，其 [[Type]] 为普通值，其 [[Value]] 为布尔值。调用时它执行以下步骤：

1. 1. 如果Type (x) 与Type (y)不同，则返回 false。

2. 2. 如果Type (x) 是 Number 或 BigInt，则

   1. A。返回 ！ 类型(x)::sameValueZero(x, y)。

3. 3.返回！ SameValueNonNumeric (x, y)。

Note

SameValueZero differs from [SameValue](https://tc39.es/ecma262/#sec-samevalue) only in its treatment of +0 and \-0.

---

7.2.12 SameValueNonNumeric ( x, y )

---

抽象操作 SameValueNonNumeric 采用参数 x（ECMAScript 语言值）和 y（ECMAScript 语言值）。它返回一条完成记录，其 [[Type]] 为普通值，其 [[Value]] 为布尔值。调用时它执行以下步骤：

1. 1.断言：类型(x) 不是 Number 或 BigInt。

2. 2.断言：类型(x) 与类型(y)相同。

3. 3. 如果Type (x) 未定义，则返回 true。

4. 4. 如果Type (x) 为 Null，则返回 true。

5. 5. 如果Type (x) 是 String，则

   1. A。如果 x 和 y 是完全相同的代码单元序列（相同长度且相应索引处的代码单元相同），则返回 true；否则，返回 false。

6. 6. 如果类型(x) 是布尔值，则

   1. A。如果 x 和 y 均为 true 或均为 false，则返回 true；否则，返回 false。

7. 7. 如果类型(x) 是符号，则

   1. A。如果x和y都是相同的Symbol值，则返回true；否则，返回 false。

8. 8. 如果 x 和 y 是相同的 Object 值，则返回 true。否则，返回 false。

---

7.2.13 IsLessThan ( x, y, LeftFirst )

---

抽象操作 IsLessThan 采用参数 x（ECMAScript 语言值）、y（ECMAScript 语言值）和 LeftFirst（布尔值）。它提供了比较 x < y 的语义，返回 true、false 或未定义（这表明至少有一个操作数为 NaN）。LeftFirst 标志用于控制对 x 和 y 执行具有潜在可见副作用的操作的顺序。这是必要的，因为 ECMAScript 指定表达式从左到右的求值。如果 LeftFirst 为 true，则 x 参数对应于出现在 y 参数的相应表达式左侧的表达式。如果 LeftFirst 为 false，则情况相反，并且必须在 x 之前对 y 执行操作。调用时它执行以下步骤：

1. 1. 如果 LeftFirst 标志为 true，则

   1. A。设 px 为 ? ToPrimitive (x, 数字)。

   2. b. 让 py 成为 ? ToPrimitive (y, 数字)。

2. 2.否则，

   1. A。注意：需要颠倒求值顺序以保留从左到右的求值。

   2. b. 让 py 成为 ? ToPrimitive (y, 数字)。

   3. C。设 px 为 ? ToPrimitive (x, 数字)。

3. 3.如果Type (px)是String，Type (py)是String，那么

   1. A。如果IsStringPrefix (py, px) 为 true，则返回 false。

   2. b. 如果IsStringPrefix (px, py) 为 true，则返回 true。

   3. C。令 k 为最小非负整数，使得 px 内索引 k 处的代码单元不同于 py 内索引 k 处的代码单元。（一定有这样的 ak，因为两个字符串都不是另一个字符串的前缀。）

   4. d. 令 m 为整数，即 px 内索引 k 处的代码单元的数值。

   5. e. 令 n 为整数，即 py 中索引 k 处的代码单元的数值。

   6. F。如果 m < n，则返回 true。否则，返回 false。

4. 4.否则，

   1. 我。让nx成为吧！ 字符串到大整数(px)。

   2. 二. 如果 nx 为 NaN，则返回 undefined。

   3. 三. 返回BigInt::lessThan (nx, py)。

   4. 我。让尼吧！ 字符串到大整数(py)。

   5. 二. 如果 ny 为 NaN，则返回 undefined。

   6. 三. 返回BigInt::lessThan (px, ny)。

   7. A。如果Type (px) 为 BigInt，Type (py) 为 String，则

   8. b. 如果类型(px) 是 String 并且类型(py) 是 BigInt，则

   9. C。注意：由于 px 和 py 是原始值，因此计算顺序并不重要。

   10. d. 让 nx 为 ? 转为数字(px)。

   11. e. 让尼吧？ 转为数值(py)。

   12. F。如果Type (nx) 与Type (ny)相同，则返回Type (nx)::lessThan(nx, ny)。

   13. G。断言：Type (nx) 是 BigInt，Type (ny) 是 Number，或者Type (nx) 是 Number，Type (ny) 是 BigInt。

   14. H。如果 nx 或 ny 为 NaN，则返回 undefined。

   15. 我。如果 nx 为 -∞ 或 ny 为 +∞，则返回 true。

   16. j。如果 nx 为 +∞ 或 ny 为 -∞，则返回 false。

   17. k. 如果ℝ (nx) < ℝ (ny)，返回 true；否则返回 false。

Note 1

Step [3](https://tc39.es/ecma262/#step-arc-string-check) differs from step [2.c](https://tc39.es/ecma262/#step-binary-op-string-check) in the algorithm that handles the addition operator `+` ([13.15.3](https://tc39.es/ecma262/#sec-applystringornumericbinaryoperator)) by using the logical-and operation instead of the logical-or operation.

Note 2

The comparison of Strings uses a simple lexicographic ordering on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore String values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form. Also, note that for strings containing supplementary characters, lexicographic ordering on sequences of UTF-16 code unit values differs from that on sequences of code point values.

---

7.2.14 松散相等 ( x, y )

---

抽象操作 IsLooselyEqual 采用参数 x（ECMAScript 语言值）和 y（ECMAScript 语言值）。它提供比较 x == y 的语义，返回 true 或 false。调用时它执行以下步骤：

1. 1. 如果Type (x) 与Type (y) 相同，则

   1. A。返回IsStrictlyEqual (x, y)。

2. 2. 如果 x 为 null 并且 y 未定义，则返回 true。

3. 3. 如果 x 未定义且 y 为 null，则返回 true。

4. 4. 注意：此步骤在B.3.6.2节中被替换。

5. 5. 如果Type (x) 为 Number，Type (y) 为 String，则返回IsLooselyEqual (x, !  ToNumber (y))。

6. 6. 如果Type (x) 为 String，Type (y) 为 Number，则返回IsLooselyEqual (! ToNumber (x), y)。

7. 7.如果Type (x)是BigInt并且Type (y)是String，那么

   1. A。让n成为！ 字符串转大整型(y)。

   2. b. 如果 n 为 NaN，则返回 false。

   3. C。返回IsLooselyEqual (x, n)。

8. 8. 如果Type (x) 为 String，Type (y) 为 BigInt，则返回IsLooselyEqual (y, x)。

9. 9. 如果Type (x) 为 Boolean，则返回IsLooselyEqual (! ToNumber (x), y)。

10. 10. 如果Type (y) 为 Boolean，则返回IsLooselyEqual (x, !  ToNumber (y))。

11. 11. 如果Type (x) 是 String、Number、BigInt 或 Symbol 并且Type (y) 是 Object，则返回IsLooselyEqual (x, ?  ToPrimitive (y))。

12. 12. 如果Type (x) 是 Object 并且Type (y) 是 String、Number、BigInt 或 Symbol，则返回IsLooselyEqual (? ToPrimitive (x), y)。

13. 13. 如果Type (x) 是 BigInt 并且Type (y) 是 Number，或者如果Type (x) 是 Number 并且Type (y) 是 BigInt，则

    1. A。如果 x 或 y 是 NaN、+∞ 或 -∞ 中的任何一个，则返回 false。

    2. b. 如果ℝ (x) = ℝ (y)，返回 true；否则返回 false。

14. 14.返回错误。

---

7.2.15 IsStrictlyEqual(x,y)

---

抽象操作 IsStrictlyEqual 采用参数 x（ECMAScript 语言值）和 y（ECMAScript 语言值）。它提供比较 x === y 的语义，返回 true 或 false。调用时它执行以下步骤：

1. 1. 如果Type (x) 与Type (y)不同，则返回 false。

2. 2. 如果Type (x) 是 Number 或 BigInt，则

   1. A。返回 ！ 输入(x)::equal(x, y)。

3. 3.返回！ SameValueNonNumeric (x, y)。

笔记

该算法与SameValue算法的不同之处在于它对有符号零和 NaN 的处理。