7 抽象操作

这些操作不是 ECMAScript 语言的一部分；它们在此定义仅用于辅助规定 ECMAScript 语言的语义。本规范中还定义了其他更专门的抽象操作。

7.1 类型转换

ECMAScript 语言会根据需要隐式执行自动类型转换。为了阐明某些构造的语义，定义一组转换抽象操作是有用的。这些转换抽象操作是多态的；它们可以接受任何 ECMAScript 语言类型的值。但这些操作不使用其他规范类型。

BigInt 类型在 ECMAScript 语言中没有隐式转换；程序员必须显式调用 BigInt 来转换来自其他类型的值。

7.1.1 ToPrimitive ( input [ , preferredType ] )

The abstract operation ToPrimitive takes argument input (an ECMAScript language value) and optional argument preferredType (string or number) and returns either a normal completion containing an ECMAScript language value or a throw completion. 它将其 input 实参转换为非 Object 类型。如果对象能够转换为不止一种原始类型，它可以使用可选提示 preferredType 来偏向该类型。 It performs the following steps when called:

  1. 如果 input 是 Object，则
    1. 令 exoticToPrimitive 为 ? GetMethod(input, %Symbol.toPrimitive%)。
    2. 如果 exoticToPrimitive 不是 undefined，则
      1. 如果 preferredType 不存在，则
        1. 令 hint 为 "default"。
      2. 否则如果 preferredType 是 string，则
        1. 令 hint 为 "string"。
      3. 否则，
        1. 断言：preferredType 是 number。
        2. 令 hint 为 "number"。
      4. 令 result 为 ? Call(exoticToPrimitive, input, « hint »)。
      5. 如果 result 不是 Object，则返回 result。
      6. 抛出 TypeError 异常。
    3. 如果 preferredType 不存在，则将 preferredType 设置为 number。
    4. 返回 ? OrdinaryToPrimitive(input, preferredType)。
  2. 返回 input。
 Note

当调用 ToPrimitive 时没有提示，它通常表现得好像提示为 number。然而，对象可以通过定义 %Symbol.toPrimitive% 方法来覆盖此行为。在本规范中定义的对象中，只有 Dates（参见 21.4.4.45）和 Symbol 对象（参见 20.4.3.5）会覆盖默认的 ToPrimitive 行为。Dates 将不存在提示视为提示为 string。

7.1.1.1 OrdinaryToPrimitive ( obj, hint )

The abstract operation OrdinaryToPrimitive takes arguments obj (an Object) and hint (string or number) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. 如果 hint 是 string，则
    1. 令 methodNames 为 « "toString", "valueOf" »。
  2. 否则，
    1. 令 methodNames 为 « "valueOf", "toString" »。
  3. 对 methodNames 的每个元素 name，执行：
    1. 令 method 为 ? Get(obj, name)。
    2. 如果 IsCallable(method) 是 true，则
      1. 令 result 为 ? Call(method, obj)。
      2. 如果 result 不是 Object，则返回 result。
  4. 抛出 TypeError 异常。

7.1.2 ToBoolean ( arg )

The abstract operation ToBoolean takes argument arg (an ECMAScript language value) and returns a Boolean. 它将 arg 转换为 Boolean 类型的值。 It performs the following steps when called:

  1. 如果 arg 是 Boolean，则返回 arg。
  2. 如果 arg 是 undefined、null、+0𝔽、-0𝔽、NaN、0ℤ 或空 String 之一，则返回 false。
  3. Normative Optional
    如果宿主是 Web 浏览器，或以其他方式支持 [[IsHTMLDDA]] 内部槽，则
    1. 如果 arg 是 Object 且 arg 具有 [[IsHTMLDDA]] 内部槽，则返回 false。
  4. 返回 true。

7.1.3 ToNumeric ( arg )

The abstract operation ToNumeric takes argument arg (an ECMAScript language value) and returns either a normal completion containing either a Number or a BigInt, or a throw completion. 它返回转换为 Number 或 BigInt 的 arg。 It performs the following steps when called:

  1. 令 primitiveValue 为 ? ToPrimitive(arg, number)。
  2. 如果 primitiveValue 是 BigInt，则返回 primitiveValue。
  3. 返回 ? ToNumber(primitiveValue)。

7.1.4 ToNumber ( arg )

The abstract operation ToNumber takes argument arg (an ECMAScript language value) and returns either a normal completion containing a Number or a throw completion. 它将 arg 转换为 Number 类型的值。 It performs the following steps when called:

  1. 如果 arg 是 Number，则返回 arg。
  2. 如果 arg 是 Symbol 或 BigInt，则抛出 TypeError 异常。
  3. 如果 arg 是 undefined，则返回 NaN。
  4. 如果 arg 是 null 或 false，则返回 +0𝔽。
  5. 如果 arg 是 true，则返回 1𝔽。
  6. 如果 arg 是 String，则返回 StringToNumber(arg)。
  7. 断言：arg 是 Object。
  8. 令 primitiveValue 为 ? ToPrimitive(arg, number)。
  9. 断言：primitiveValue 不是 Object。
  10. 返回 ? ToNumber(primitiveValue)。

7.1.4.1 应用于 String 类型的 ToNumber

抽象操作 StringToNumber 规定如何使用以下文法将 String 值转换为 Number 值。

语法

StringNumericLiteral ::: StrWhiteSpaceopt StrWhiteSpaceopt StrNumericLiteral StrWhiteSpaceopt StrWhiteSpace ::: StrWhiteSpaceChar StrWhiteSpaceopt StrWhiteSpaceChar ::: WhiteSpace LineTerminator StrNumericLiteral ::: StrDecimalLiteral NonDecimalIntegerLiteral[~Sep] StrDecimalLiteral ::: StrUnsignedDecimalLiteral + StrUnsignedDecimalLiteral - StrUnsignedDecimalLiteral StrUnsignedDecimalLiteral ::: Infinity DecimalDigits[~Sep] . DecimalDigits[~Sep]opt ExponentPart[~Sep]opt . DecimalDigits[~Sep] ExponentPart[~Sep]opt DecimalDigits[~Sep] ExponentPart[~Sep]opt

上面未显式定义的所有文法符号均具有数值字面量的词法文法（12.9.3）中所用的定义

Note

应注意 StringNumericLiteral 与 NumericLiteral 的语法之间存在一些差异：

7.1.4.1.1 StringToNumber ( string )

The abstract operation StringToNumber takes argument string (a String) and returns a Number. It performs the following steps when called:

  1. 令 literal 为 ParseText(string, StringNumericLiteral)。
  2. 如果 literal 是错误的 List，则返回 NaN。
  3. 返回 literal 的 StringNumericValue。

7.1.4.1.2 Runtime Semantics: StringNumericValue

The syntax-directed operation StringNumericValue takes no arguments and returns a Number.

Note

将 StringNumericLiteral 转换为 Number 值，整体上类似于确定 NumericLiteral 的 NumericValue（参见 12.9.3），但某些细节有所不同。

It is defined piecewise over the following productions:

StringNumericLiteral ::: StrWhiteSpaceopt
  1. 返回 +0𝔽。
 StringNumericLiteral ::: StrWhiteSpaceopt StrNumericLiteral StrWhiteSpaceopt
  1. 返回 StrNumericLiteral 的 StringNumericValue。
 StrNumericLiteral ::: NonDecimalIntegerLiteral
  1. 返回 𝔽(NonDecimalIntegerLiteral 的 MV)。
 StrDecimalLiteral ::: - StrUnsignedDecimalLiteral
  1. 令 a 为 StrUnsignedDecimalLiteral 的 StringNumericValue。
  2. 如果 a 是 +0𝔽，则返回 -0𝔽。
  3. 返回 -a。
 StrUnsignedDecimalLiteral ::: Infinity
  1. 返回 +∞𝔽。
 StrUnsignedDecimalLiteral ::: DecimalDigits . DecimalDigitsopt ExponentPartopt
  1. 令 a 为第一个 DecimalDigits 的 MV。
  2. 如果第二个 DecimalDigits 存在，则
    1. 令 b 为第二个 DecimalDigits 的 MV。
    2. 令 n 为第二个 DecimalDigits 中码点的数量。
  3. 否则，
    1. 令 b 为 0。
    2. 令 n 为 0。
  4. 如果 ExponentPart 存在，则令 e 为 ExponentPart 的 MV；否则令 e 为 0。
  5. 返回 RoundMVResult((a + (b × 10-n)) × 10e)。
 StrUnsignedDecimalLiteral ::: . DecimalDigits ExponentPartopt
  1. 令 b 为 DecimalDigits 的 MV。
  2. 如果 ExponentPart 存在，则令 e 为 ExponentPart 的 MV；否则令 e 为 0。
  3. 令 n 为 DecimalDigits 中码点的数量。
  4. 返回 RoundMVResult(b × 10e - n)。
 StrUnsignedDecimalLiteral ::: DecimalDigits ExponentPartopt
  1. 令 a 为 DecimalDigits 的 MV。
  2. 如果 ExponentPart 存在，则令 e 为 ExponentPart 的 MV；否则令 e 为 0。
  3. 返回 RoundMVResult(a × 10e)。

7.1.4.1.3 RoundMVResult ( n )

The abstract operation RoundMVResult takes argument n (a mathematical value) and returns a Number. 它以实现定义的方式将 n 转换为 Number。就此抽象操作而言，如果一个数字不是零，或者其左侧存在非零数字且其右侧存在非零数字，则该数字是有效的。就此抽象操作而言，一个数学值表示的“所表示的数学值”是一个数学值“的十进制表示”的逆。 It performs the following steps when called:

  1. 如果 n 的十进制表示具有 20 个或更少的有效数字，则返回 𝔽(n)。
  2. 令 option1 为将 n 的十进制表示中第 20 个之后的每个有效数字替换为数字 0 后所得结果所表示的数学值。
  3. 令 option2 为将 n 的十进制表示中第 20 个之后的每个有效数字替换为数字 0，然后在第 20 个位置将其递增（必要时进位）后所得结果所表示的数学值。
  4. 令 chosen 为 option1 或 option2 的实现定义选择。
  5. 返回 𝔽(chosen)。

7.1.5 ToIntegerOrInfinity ( arg )

The abstract operation ToIntegerOrInfinity takes argument arg (an ECMAScript language value) and returns either a normal completion containing either an integer, +∞, or -∞, or a throw completion. 它将 arg 转换为表示其 Number 值并截断小数部分的整数；或者当该 Number 值为无穷时，转换为 +∞ 或 -∞。 It performs the following steps when called:

  1. 令 number 为 ? ToNumber(arg)。
  2. 如果 number 是 NaN、+0𝔽 或 -0𝔽 之一，则返回 0。
  3. 如果 number 是 +∞𝔽，则返回 +∞。
  4. 如果 number 是 -∞𝔽，则返回 -∞。
  5. 返回 truncate(ℝ(number))。
 Note
对任意值 x，𝔽(ToIntegerOrInfinity(x)) 永远不会返回 -0𝔽。小数部分的截断是在将 x 转换为数学值之后执行的。

7.1.6 ToFixedSizeInteger ( int, signed, bitWidth )

The abstract operation ToFixedSizeInteger takes arguments int (an integer, +∞, or -∞), signed (unsigned or signed), and bitWidth (a positive integer) and returns an integer. 它将 int 映射到 2bitWidth 个整数之一：如果 signed 是 unsigned，则在从 0 到 2bitWidth - 1 的闭区间内；如果 signed 是 signed，则在从 -2bitWidth - 1 到 2bitWidth - 1 - 1 的闭区间内。 It performs the following steps when called:

  1. 如果 int = +∞ 或 int = -∞，则返回 0。
  2. 令 fixedInt 为 int modulo 2bitWidth。
  3. 注记：以下步骤不会改变 fixedInt 的二进制补码表示。
  4. 如果 signed 是 signed 且 fixedInt ≥ 2bitWidth - 1，则将 fixedInt 设置为 fixedInt - 2bitWidth。
  5. 返回 fixedInt。
 Note

ToFixedSizeInteger 是幂等的：对于任意 ECMAScript 语言值 x，ToFixedSizeInteger(ToFixedSizeInteger(x, signed, bitWidth), signed, bitWidth) 与 ToFixedSizeInteger(x, signed, bitWidth) 相同。事实上，因为 +∞ 和 -∞ 会被映射为 0，即使反转 signed，该不变式也仍然成立（例如，ToFixedSizeInteger(ToFixedSizeInteger(x, signed, 32), unsigned, 32) 与 ToFixedSizeInteger(x, unsigned, 32) 相同）。

7.1.7 ToInt32 ( arg )

The abstract operation ToInt32 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 232 个 integral Number 值之一，这些值位于从 𝔽(-231) 到 𝔽(231 - 1) 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, signed, 32))。

7.1.8 ToUint32 ( arg )

The abstract operation ToUint32 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 232 个 integral Number 值之一，这些值位于从 +0𝔽 到 𝔽(232 - 1) 的闭区间内。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, unsigned, 32))。

7.1.9 ToInt16 ( arg )

The abstract operation ToInt16 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 216 个 integral Number 值之一，这些值位于从 𝔽(-215) 到 𝔽(215 - 1) 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, signed, 16))。

7.1.10 ToUint16 ( arg )

The abstract operation ToUint16 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 216 个 integral Number 值之一，这些值位于从 +0𝔽 到 𝔽(216 - 1) 的闭区间内。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, unsigned, 16))。

7.1.11 ToInt8 ( arg )

The abstract operation ToInt8 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 28 个 integral Number 值之一，这些值位于从 -128𝔽 到 127𝔽 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, signed, 8))。

7.1.12 ToUint8 ( arg )

The abstract operation ToUint8 takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 转换为 28 个 integral Number 值之一，这些值位于从 +0𝔽 到 255𝔽 的闭区间内。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 返回 𝔽(ToFixedSizeInteger(int, unsigned, 8))。

7.1.13 ToUint8Clamp ( arg )

The abstract operation ToUint8Clamp takes argument arg (an ECMAScript language value) and returns either a normal completion containing an integral Number or a throw completion. 它将 arg 钳制并舍入为 28 个 integral Number 值之一，这些值位于从 +0𝔽 到 255𝔽 的闭区间内。 It performs the following steps when called:

  1. 令 number 为 ? ToNumber(arg)。
  2. 如果 number 是 NaN，则返回 +0𝔽。
  3. 令 mv 为 number 的扩展数学值。
  4. 令 clamped 为将 mv 钳制在 0 和 255 之间的结果。
  5. 令 f 为 floor(clamped)。
  6. 如果 clamped < f + 0.5，则返回 𝔽(f)。
  7. 如果 clamped > f + 0.5，则返回 𝔽(f + 1)。
  8. 如果 f 是偶数，则返回 𝔽(f)。
  9. 返回 𝔽(f + 1)。
 Note

不同于大多数其他 ECMAScript 整数转换操作，ToUint8Clamp 会对非整数值进行舍入而不是截断。它还使用“舍入到最接近偶数”的平局决策方式，这不同于 Math.round 的“四舍五入”平局决策方式。

7.1.14 ToBigInt ( arg )

The abstract operation ToBigInt takes argument arg (an ECMAScript language value) and returns either a normal completion containing a BigInt or a throw completion. 它将 arg 转换为 BigInt 值；如果需要从 Number 进行隐式转换，则抛出。 It performs the following steps when called:

  1. 令 primitive 为 ? ToPrimitive(arg, number)。
  2. 返回 primitive 在 Table 12 中对应的值。
Table 12: BigInt 转换
实参类型 结果
Undefined 抛出 TypeError 异常。
Null 抛出 TypeError 异常。
Boolean 如果 primitive 是 true，则返回 1n；如果 primitive 是 false，则返回 0n。
BigInt 返回 primitive。
Number 抛出 TypeError 异常。
String
  1. 令 n 为 StringToBigInt(primitive)。
  2. 如果 n 是 undefined，则抛出 SyntaxError 异常。
  3. 返回 n。
Symbol 抛出 TypeError 异常。

7.1.15 StringToBigInt ( string )

The abstract operation StringToBigInt takes argument string (a String) and returns a BigInt or undefined. It performs the following steps when called:

  1. 令 literal 为 ParseText(string, StringIntegerLiteral)。
  2. 如果 literal 是错误的 List，则返回 undefined。
  3. 令 mv 为 literal 的 MV。
  4. 断言：mv 是整数。
  5. 返回 ℤ(mv)。

7.1.15.1 StringIntegerLiteral 文法

StringToBigInt 使用以下文法。

语法

StringIntegerLiteral ::: StrWhiteSpaceopt StrWhiteSpaceopt StrIntegerLiteral StrWhiteSpaceopt StrIntegerLiteral ::: SignedInteger[~Sep] NonDecimalIntegerLiteral[~Sep]

7.1.15.2 Runtime Semantics: MV

7.1.16 ToBigInt64 ( arg )

The abstract operation ToBigInt64 takes argument arg (an ECMAScript language value) and returns either a normal completion containing a BigInt or a throw completion. 它将 arg 转换为 264 个 BigInt 值之一，这些值位于从 ℤ(-263) 到 ℤ(263 - 1) 的闭区间内。 It performs the following steps when called:

  1. 令 int 为 ℝ(? ToBigInt(arg))。
  2. 返回 ℤ(ToFixedSizeInteger(int, signed, 64))。

7.1.17 ToBigUint64 ( arg )

The abstract operation ToBigUint64 takes argument arg (an ECMAScript language value) and returns either a normal completion containing a BigInt or a throw completion. 它将 arg 转换为 264 个 BigInt 值之一，这些值位于从 0ℤ 到 ℤ(264 - 1) 的闭区间内。 It performs the following steps when called:

  1. 令 int 为 ℝ(? ToBigInt(arg))。
  2. 返回 ℤ(ToFixedSizeInteger(int, unsigned, 64))。

7.1.18 ToString ( arg )

The abstract operation ToString takes argument arg (an ECMAScript language value) and returns either a normal completion containing a String or a throw completion. 它将 arg 转换为 String 类型的值。 It performs the following steps when called:

  1. 如果 arg 是 String，则返回 arg。
  2. 如果 arg 是 Symbol，则抛出 TypeError 异常。
  3. 如果 arg 是 undefined，则返回 "undefined"。
  4. 如果 arg 是 null，则返回 "null"。
  5. 如果 arg 是 true，则返回 "true"。
  6. 如果 arg 是 false，则返回 "false"。
  7. 如果 arg 是 Number，则返回 Number::toString(arg, 10)。
  8. 如果 arg 是 BigInt，则返回 BigInt::toString(arg, 10)。
  9. 断言：arg 是 Object。
  10. 令 primitiveValue 为 ? ToPrimitive(arg, string)。
  11. 断言：primitiveValue 不是 Object。
  12. 返回 ? ToString(primitiveValue)。

7.1.19 ToObject ( arg )

The abstract operation ToObject takes argument arg (an ECMAScript language value) and returns either a normal completion containing an Object or a throw completion. 它将 arg 转换为 Object 类型的值。 It performs the following steps when called:

  1. 如果 arg 是 undefined 或 null，则抛出 TypeError 异常。
  2. 如果 arg 是 Boolean，则返回一个新的 Boolean 对象，其 [[BooleanData]] 内部槽被设置为 arg。关于 Boolean 对象的描述，参见 20.3。
  3. 如果 arg 是 Number，则返回一个新的 Number 对象，其 [[NumberData]] 内部槽被设置为 arg。关于 Number 对象的描述，参见 21.1。
  4. 如果 arg 是 String，则返回一个新的 String 对象，其 [[StringData]] 内部槽被设置为 arg。关于 String 对象的描述，参见 22.1。
  5. 如果 arg 是 Symbol，则返回一个新的 Symbol 对象，其 [[SymbolData]] 内部槽被设置为 arg。关于 Symbol 对象的描述，参见 20.4。
  6. 如果 arg 是 BigInt，则返回一个新的 BigInt 对象，其 [[BigIntData]] 内部槽被设置为 arg。关于 BigInt 对象的描述，参见 21.2。
  7. 断言：arg 是 Object。
  8. 返回 arg。

7.1.20 ToPropertyKey ( arg )

The abstract operation ToPropertyKey takes argument arg (an ECMAScript language value) and returns either a normal completion containing a property key or a throw completion. 它将 arg 转换为可用作属性键的值。 It performs the following steps when called:

  1. 令 key 为 ? ToPrimitive(arg, string)。
  2. 如果 key 是 Symbol，则
    1. 返回 key。
  3. 返回 ! ToString(key)。

7.1.21 ToLength ( arg )

The abstract operation ToLength takes argument arg (an ECMAScript language value) and returns either a normal completion containing a non-negative integral Number or a throw completion. 它将 arg 钳制并截断为适合用作类数组对象长度的非负 integral Number。 It performs the following steps when called:

  1. 令 length 为 ? ToIntegerOrInfinity(arg)。
  2. 如果 length ≤ 0，则返回 +0𝔽。
  3. 返回 𝔽(min(length, 253 - 1))。

7.1.22 CanonicalNumericIndexString ( arg )

The abstract operation CanonicalNumericIndexString takes argument arg (a String) and returns a Number or undefined. 如果 arg 是 "-0"，或与某个 Number 值 n 的 ToString(n) 完全匹配，则它返回相应的 Number 值。否则，它返回 undefined。 It performs the following steps when called:

  1. 如果 arg 是 "-0"，则返回 -0𝔽。
  2. 令 n 为 ! ToNumber(arg)。
  3. 如果 ! ToString(n) 是 arg，则返回 n。
  4. 返回 undefined。

规范数值字符串是任何使 CanonicalNumericIndexString 抽象操作不返回 undefined 的 String。

7.1.23 ToIndex ( arg )

The abstract operation ToIndex takes argument arg (an ECMAScript language value) and returns either a normal completion containing a non-negative integer or a throw completion. 它将 arg 转换为整数，并在该整数为非负且对应于整数索引时返回该整数。否则，它抛出异常。 It performs the following steps when called:

  1. 令 int 为 ? ToIntegerOrInfinity(arg)。
  2. 如果 int 不在从 0 到 253 - 1 的闭区间内，则抛出 RangeError 异常。
  3. 返回 int。

7.2 测试和比较操作

7.2.1 RequireObjectCoercible ( arg )

The abstract operation RequireObjectCoercible takes argument arg (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. 如果 arg 是无法使用 ToObject 转换为 Object 的值，则它抛出错误。 It performs the following steps when called:

  1. 如果 arg 是 undefined 或 null，则抛出 TypeError 异常。
  2. 返回 unused。

7.2.2 IsArray ( arg )

The abstract operation IsArray takes argument arg (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

  1. 如果 arg 不是 Object，则返回 false。
  2. 如果 arg 是 Array 异质对象，则返回 true。
  3. 如果 arg 是 Proxy 异质对象，则
    1. 执行 ? ValidateNonRevokedProxy(arg)。
    2. 令 proxyTarget 为 arg.[[ProxyTarget]]。
    3. 返回 ? IsArray(proxyTarget)。
  4. 返回 false。

7.2.3 IsCallable ( arg )

The abstract operation IsCallable takes argument arg (an ECMAScript language value) and returns a Boolean. 它确定 arg 是否是具有 [[Call]] 内部方法的可调用函数。 It performs the following steps when called:

  1. 如果 arg 不是 Object，则返回 false。
  2. 如果 arg 具有 [[Call]] 内部方法，则返回 true。
  3. 返回 false。

7.2.4 IsConstructor ( arg )

The abstract operation IsConstructor takes argument arg (an ECMAScript language value) and returns a Boolean. 它确定 arg 是否是具有 [[Construct]] 内部方法的函数对象。 It performs the following steps when called:

  1. 如果 arg 不是 Object，则返回 false。
  2. 如果 arg 具有 [[Construct]] 内部方法，则返回 true。
  3. 返回 false。

7.2.5 IsExtensible ( obj )

The abstract operation IsExtensible takes argument obj (an Object) and returns either a normal completion containing a Boolean or a throw completion. 它用于确定是否可以向 obj 添加额外属性。 It performs the following steps when called:

  1. 返回 ? obj.[[IsExtensible]]()。

7.2.6 IsRegExp ( arg )

The abstract operation IsRegExp takes argument arg (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

  1. 如果 arg 不是 Object，则返回 false。
  2. 令 matcher 为 ? Get(arg, %Symbol.match%)。
  3. 如果 matcher 不是 undefined，则返回 ToBoolean(matcher)。
  4. 如果 arg 具有 [[RegExpMatcher]] 内部槽，则返回 true。
  5. 返回 false。

7.2.7 Static Semantics: IsStringWellFormedUnicode ( string )

The abstract operation IsStringWellFormedUnicode takes argument string (a String) and returns a Boolean. 它按照 6.1.4 中所述，将 string 解释为 UTF-16 编码码点序列，并确定它是否是格式良好的 UTF-16 序列。 It performs the following steps when called:

  1. 令 length 为 string 的长度。
  2. 令 k 为 0。
  3. 重复，当 k < length 时：
    1. 令 codePoint 为 CodePointAt(string, k)。
    2. 如果 codePoint.[[IsUnpairedSurrogate]] 是 true，则返回 false。
    3. 将 k 设置为 k + codePoint.[[CodeUnitCount]]。
  4. 返回 true。

7.2.8 SameType ( x, y )

The abstract operation SameType takes arguments x (an ECMAScript language value) and y (an ECMAScript language value) and returns a Boolean. 它确定两个实参是否属于同一类型。 It performs the following steps when called:

  1. 如果 x 是 undefined 且 y 是 undefined，则返回 true。
  2. 如果 x 是 null 且 y 是 null，则返回 true。
  3. 如果 x 是 Boolean 且 y 是 Boolean，则返回 true。
  4. 如果 x 是 Number 且 y 是 Number，则返回 true。
  5. 如果 x 是 BigInt 且 y 是 BigInt，则返回 true。
  6. 如果 x 是 Symbol 且 y 是 Symbol，则返回 true。
  7. 如果 x 是 String 且 y 是 String，则返回 true。
  8. 如果 x 是 Object 且 y 是 Object，则返回 true。
  9. 返回 false。

7.2.9 SameValue ( x, y )

The abstract operation SameValue takes arguments x (an ECMAScript language value) and y (an ECMAScript language value) and returns a Boolean. 它确定两个实参是否为同一值。 It performs the following steps when called:

  1. 如果 SameType(x, y) 是 false，则返回 false。
  2. 如果 x 是 Number，则
    1. 返回 Number::sameValue(x, y)。
  3. 返回 SameValueNonNumber(x, y)。
 Note

此算法与 IsStrictlyEqual 算法的不同之处在于，它将所有 NaN 值视为等价，并且区分 +0𝔽 与 -0𝔽。

7.2.10 SameValueZero ( x, y )

The abstract operation SameValueZero takes arguments x (an ECMAScript language value) and y (an ECMAScript language value) and returns a Boolean. 它确定两个实参是否为同一值（忽略 +0𝔽 与 -0𝔽 之间的差异）。 It performs the following steps when called:

  1. 如果 SameType(x, y) 是 false，则返回 false。
  2. 如果 x 是 Number，则
    1. 返回 Number::sameValueZero(x, y)。
  3. 返回 SameValueNonNumber(x, y)。
 Note

SameValueZero 与 SameValue 的不同仅在于，它将 +0𝔽 和 -0𝔽 视为等价。

7.2.11 SameValueNonNumber ( x, y )

The abstract operation SameValueNonNumber takes arguments x (an ECMAScript language value, but not a Number) and y (an ECMAScript language value, but not a Number) and returns a Boolean. It performs the following steps when called:

  1. 断言：SameType(x, y) 是 true。
  2. 如果 x 是 undefined 或 null，则返回 true。
  3. 如果 x 是 BigInt，则
    1. 返回 BigInt::equal(x, y)。
  4. 如果 x 是 String，则
    1. 如果 x 和 y 具有相同长度并且相同位置具有相同码元，则返回 true。
    2. 返回 false。
  5. 如果 x 是 Boolean，则
    1. 如果 x 是 true 且 y 是 true，则返回 true。
    2. 如果 x 是 false 且 y 是 false，则返回 true。
    3. 返回 false。
  6. 注记：所有其他 ECMAScript 语言值均按身份进行比较。
  7. 如果 x 是 y，则返回 true。
  8. 返回 false。
 Note 1
出于说明目的，此算法中单独处理了一些情况，即使这样做并非必要。
Note 2
“x 是 y”具体意味着什么，详见 5.2.8。

7.2.12 IsLessThan ( x, y, leftFirst )

The abstract operation IsLessThan takes arguments x (an ECMAScript language value), y (an ECMAScript language value), and leftFirst (a Boolean) and returns either a normal completion containing either a Boolean or undefined, or a throw completion. 它提供比较 x < y 的语义，返回 true、false 或 undefined（表示操作数无法被强制转换为同一数值类型的可比较值）。leftFirst 标志用于控制对 x 和 y 执行可能具有可见副作用的操作的顺序。它是必要的，因为 ECMAScript 指定表达式按从左到右的顺序求值。如果 leftFirst 是 true，则 x 形参对应于出现在 y 形参对应表达式左侧的表达式。如果 leftFirst 是 false，则情况相反，必须先对 y 执行操作，再对 x 执行操作。 It performs the following steps when called:

  1. 如果 leftFirst 是 true，则
    1. 令 px 为 ? ToPrimitive(x, number)。
    2. 令 py 为 ? ToPrimitive(y, number)。
  2. 否则，
    1. 注记：为了保留从左到右的求值顺序，需要反转求值顺序。
    2. 令 py 为 ? ToPrimitive(y, number)。
    3. 令 px 为 ? ToPrimitive(x, number)。
  3. 如果 px 是 String 且 py 是 String，则
    1. 令 lx 为 px 的长度。
    2. 令 ly 为 py 的长度。
    3. 对每个满足 0 ≤ i < min(lx, ly) 的整数 i，按升序执行：
      1. 令 cx 为 px 内索引 i 处码元的数值。
      2. 令 cy 为 py 内索引 i 处码元的数值。
      3. 如果 cx < cy，则返回 true。
      4. 如果 cx > cy，则返回 false。
    4. 如果 lx < ly，则返回 true。
    5. 返回 false。
  4. 如果 px 是 BigInt 且 py 是 String，则
    1. 令 ny 为 StringToBigInt(py)。
    2. 如果 ny 是 undefined，则返回 undefined。
    3. 返回 BigInt::lessThan(px, ny)。
  5. 如果 px 是 String 且 py 是 BigInt，则
    1. 令 nx 为 StringToBigInt(px)。
    2. 如果 nx 是 undefined，则返回 undefined。
    3. 返回 BigInt::lessThan(nx, py)。
  6. 注记：因为 px 和 py 是原始值，求值顺序并不重要。
  7. 令 nx 为 ? ToNumeric(px)。
  8. 令 ny 为 ? ToNumeric(py)。
  9. 如果 SameType(nx, ny) 是 true，则
    1. 如果 nx 是 Number，则返回 Number::lessThan(nx, ny)。
    2. 断言：nx 是 BigInt。
    3. 返回 BigInt::lessThan(nx, ny)。
  10. 断言：nx 是 BigInt 且 ny 是 Number，或 nx 是 Number 且 ny 是 BigInt。
  11. 如果 nx 是 NaN 或 ny 是 NaN，则返回 undefined。
  12. 如果 nx 是 -∞𝔽 或 ny 是 +∞𝔽，则返回 true。
  13. 如果 nx 是 +∞𝔽 或 ny 是 -∞𝔽，则返回 false。
  14. 如果 ℝ(nx) < ℝ(ny)，则返回 true。
  15. 返回 false。
 Note 1

步骤 3 与处理加法运算符 + 的算法（13.15.3）中的步骤 1.c 不同，它使用逻辑与操作而不是逻辑或操作。

 Note 2

Strings 的比较使用对 UTF-16 码元值序列的简单字典序排序。不会尝试使用 Unicode 规范中定义的更复杂、面向语义的字符或字符串相等性及排序顺序定义。因此，按照 Unicode 标准规范等价但不处于同一规范化形式的 String 值，可能测试为不相等。还要注意，对于包含代理对的 Strings，按码元排序不同于按码点排序。

7.2.13 IsLooselyEqual ( x, y )

The abstract operation IsLooselyEqual takes arguments x (an ECMAScript language value) and y (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. 它提供 == 运算符的语义。 It performs the following steps when called:

  1. 如果 SameType(x, y) 是 true，则
    1. 返回 IsStrictlyEqual(x, y)。
  2. 如果 x 是 null 且 y 是 undefined，则返回 true。
  3. 如果 x 是 undefined 且 y 是 null，则返回 true。
  4. Normative Optional
    如果宿主是 Web 浏览器，或以其他方式支持 [[IsHTMLDDA]] 内部槽，则
    1. 如果 x 是 Object，x 具有 [[IsHTMLDDA]] 内部槽，且 y 是 undefined 或 null，则返回 true。
    2. 如果 x 是 undefined 或 null，y 是 Object，且 y 具有 [[IsHTMLDDA]] 内部槽，则返回 true。
  5. 如果 x 是 Number 且 y 是 String，则返回 ! IsLooselyEqual(x, ! ToNumber(y))。
  6. 如果 x 是 String 且 y 是 Number，则返回 ! IsLooselyEqual(! ToNumber(x), y)。
  7. 如果 x 是 BigInt 且 y 是 String，则
    1. 令 n 为 StringToBigInt(y)。
    2. 如果 n 是 undefined，则返回 false。
    3. 返回 ! IsLooselyEqual(x, n)。
  8. 如果 x 是 String 且 y 是 BigInt，则返回 ! IsLooselyEqual(y, x)。
  9. 如果 x 是 Boolean，则返回 ! IsLooselyEqual(! ToNumber(x), y)。
  10. 如果 y 是 Boolean，则返回 ! IsLooselyEqual(x, ! ToNumber(y))。
  11. 如果 x 是 String、Number、BigInt 或 Symbol，且 y 是 Object，则返回 ! IsLooselyEqual(x, ? ToPrimitive(y))。
  12. 如果 x 是 Object，且 y 是 String、Number、BigInt 或 Symbol，则返回 ! IsLooselyEqual(? ToPrimitive(x), y)。
  13. 如果 x 是 BigInt 且 y 是 Number，或如果 x 是 Number 且 y 是 BigInt，则
    1. 如果 x 不是有限的或 y 不是有限的，则返回 false。
    2. 如果 ℝ(x) = ℝ(y)，则返回 true。
    3. 返回 false。
  14. 返回 false。

7.2.14 IsStrictlyEqual ( x, y )

The abstract operation IsStrictlyEqual takes arguments x (an ECMAScript language value) and y (an ECMAScript language value) and returns a Boolean. 它提供 === 运算符的语义。 It performs the following steps when called:

  1. 如果 SameType(x, y) 是 false，则返回 false。
  2. 如果 x 是 Number，则
    1. 返回 Number::equal(x, y)。
  3. 返回 SameValueNonNumber(x, y)。
 Note

此算法与 SameValue 算法的不同之处在于其对有符号零和 NaNs 的处理。

7.3 对象上的操作

7.3.1 MakeBasicObject ( internalSlotsList )

The abstract operation MakeBasicObject takes argument internalSlotsList (a List of internal slot names) and returns an Object. 它是所有通过算法创建的 ECMAScript 对象的来源，包括普通对象和异质对象。它抽取了创建所有对象时使用的公共步骤，并集中化对象创建。 It performs the following steps when called:

  1. 将 internalSlotsList 设置为 internalSlotsList 与 « [[PrivateElements]] » 的列表连接。
  2. 令 obj 为一个新创建的对象，它为 internalSlotsList 中的每个名称都有一个内部槽。
  3. 注记：如 Object 内部方法和内部槽 中所述，除非另有指定，否则每个这类内部槽的初始值都是 undefined。
  4. 将 obj.[[PrivateElements]] 设置为新的空 List。
  5. 将 obj 的基本内部方法设置为 10.1 中指定的默认普通对象定义。
  6. 断言：如果调用方不会重写 obj 的 [[GetPrototypeOf]] 和 [[SetPrototypeOf]] 两个基本内部方法，则 internalSlotsList 包含 [[Prototype]]。
  7. 断言：如果调用方不会重写 obj 的 [[SetPrototypeOf]]、[[IsExtensible]] 和 [[PreventExtensions]] 所有基本内部方法，则 internalSlotsList 包含 [[Extensible]]。
  8. 如果 internalSlotsList 包含 [[Extensible]]，则将 obj.[[Extensible]] 设置为 true。
  9. 返回 obj。
 Note

在本规范中，异质对象在诸如 ArrayCreate 和 BoundFunctionCreate 这样的抽象操作中创建，方法是先调用 MakeBasicObject 以获得一个基本的、基础性的对象，然后重写该对象的一些或全部内部方法。为了封装异质对象的创建，对象的基本内部方法绝不会在这些操作之外被修改。

7.3.2 Get ( obj, propertyKey )

The abstract operation Get takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing an ECMAScript language value or a throw completion. 它用于取回对象的特定属性的值。 It performs the following steps when called:

  1. 返回 ? obj.[[Get]](propertyKey, obj)。

7.3.3 GetV ( value, propertyKey )

The abstract operation GetV takes arguments value (an ECMAScript language value) and propertyKey (a property key) and returns either a normal completion containing an ECMAScript language value or a throw completion. 它用于取回 ECMAScript 语言值的特定属性的值。如果该值不是对象，则使用适合该值类型的包装对象执行属性查找。 It performs the following steps when called:

  1. 令 obj 为 ? ToObject(value)。
  2. 返回 ? obj.[[Get]](propertyKey, value)。

7.3.4 Set ( obj, propertyKey, value, throw )

The abstract operation Set takes arguments obj (an Object), propertyKey (a property key), value (an ECMAScript language value), and throw (a Boolean) and returns either a normal completion containing unused or a throw completion. 它用于设置对象的特定属性的值。value 是该属性的新值。 It performs the following steps when called:

  1. 令 success 为 ? obj.[[Set]](propertyKey, value, obj)。
  2. 如果 success 是 false 且 throw 是 true，则抛出 TypeError 异常。
  3. 返回 unused。

7.3.5 CreateDataProperty ( obj, propertyKey, value )

The abstract operation CreateDataProperty takes arguments obj (an Object), propertyKey (a property key), and value (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. 它用于创建对象的一个新自有属性。 It performs the following steps when called:

  1. 令 newDesc 为 PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }。
  2. 返回 ? obj.[[DefineOwnProperty]](propertyKey, newDesc)。
 Note

此抽象操作创建一个属性，其特性被设置为与 ECMAScript 语言赋值运算符创建的属性所使用的默认值相同。通常，该属性尚不存在。如果它确实存在且不可配置，或者 obj 不可扩展，则 [[DefineOwnProperty]] 将返回 false。

7.3.6 CreateDataPropertyOrThrow ( obj, propertyKey, value )

The abstract operation CreateDataPropertyOrThrow takes arguments obj (an Object), propertyKey (a property key), and value (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. 它用于创建对象的一个新自有属性。如果所请求的属性更新不能执行，则抛出 TypeError 异常。 It performs the following steps when called:

  1. 令 success 为 ? CreateDataProperty(obj, propertyKey, value)。
  2. 如果 success 是 false，则抛出 TypeError 异常。
  3. 返回 unused。
 Note

此抽象操作创建一个属性，其特性被设置为与 ECMAScript 语言赋值运算符创建的属性所使用的默认值相同。通常，该属性尚不存在。如果它确实存在且不可配置，或者 obj 不可扩展，则 [[DefineOwnProperty]] 将返回 false，导致此操作抛出 TypeError 异常。

7.3.7 CreateNonEnumerableDataPropertyOrThrow ( obj, propertyKey, value )

The abstract operation CreateNonEnumerableDataPropertyOrThrow takes arguments obj (an Object), propertyKey (a property key), and value (an ECMAScript language value) and returns unused. 它用于创建普通对象的一个新的不可枚举自有属性。 It performs the following steps when called:

  1. 断言：obj 是一个普通、可扩展且没有不可配置属性的对象。
  2. 令 newDesc 为 PropertyDescriptor { [[Value]]: value, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }。
  3. 执行 ! DefinePropertyOrThrow(obj, propertyKey, newDesc)。
  4. 返回 unused。
 Note

此抽象操作创建一个属性，其特性被设置为与 ECMAScript 语言赋值运算符创建的属性所使用的默认值相同，只是它不可枚举。通常，该属性尚不存在。如果它确实存在，则 DefinePropertyOrThrow 保证正常完成。

7.3.8 DefinePropertyOrThrow ( obj, propertyKey, propertyDesc )

The abstract operation DefinePropertyOrThrow takes arguments obj (an Object), propertyKey (a property key), and propertyDesc (a Property Descriptor) and returns either a normal completion containing unused or a throw completion. 它用于调用对象的 [[DefineOwnProperty]] 内部方法，调用方式为：如果所请求的属性更新不能执行，则会抛出 TypeError 异常。 It performs the following steps when called:

  1. 令 success 为 ? obj.[[DefineOwnProperty]](propertyKey, propertyDesc)。
  2. 如果 success 是 false，则抛出 TypeError 异常。
  3. 返回 unused。

7.3.9 DeletePropertyOrThrow ( obj, propertyKey )

The abstract operation DeletePropertyOrThrow takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing unused or a throw completion. 它用于移除对象的特定自有属性。如果该属性不可配置，则抛出异常。 It performs the following steps when called:

  1. 令 success 为 ? obj.[[Delete]](propertyKey)。
  2. 如果 success 是 false，则抛出 TypeError 异常。
  3. 返回 unused。

7.3.10 GetMethod ( value, propertyKey )

The abstract operation GetMethod takes arguments value (an ECMAScript language value) and propertyKey (a property key) and returns either a normal completion containing either a function object or undefined, or a throw completion. 当预期某个 ECMAScript 语言值的特定属性的值是函数时，它用于获取该属性的值。 It performs the following steps when called:

  1. 令 func 为 ? GetV(value, propertyKey)。
  2. 如果 func 是 undefined 或 null，则返回 undefined。
  3. 如果 IsCallable(func) 是 false，则抛出 TypeError 异常。
  4. 返回 func。

7.3.11 HasProperty ( obj, propertyKey )

The abstract operation HasProperty takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. 它用于确定对象是否具有指定属性键的属性。该属性可以是自有属性或继承属性。 It performs the following steps when called:

  1. 返回 ? obj.[[HasProperty]](propertyKey)。

7.3.12 HasOwnProperty ( obj, propertyKey )

The abstract operation HasOwnProperty takes arguments obj (an Object) and propertyKey (a property key) and returns either a normal completion containing a Boolean or a throw completion. 它用于确定对象是否具有指定属性键的自有属性。 It performs the following steps when called:

  1. 令 propertyDesc 为 ? obj.[[GetOwnProperty]](propertyKey)。
  2. 如果 propertyDesc 是 undefined，则返回 false。
  3. 返回 true。

7.3.13 Call ( func, thisValue [ , argList ] )

The abstract operation Call takes arguments func (an ECMAScript language value) and thisValue (an ECMAScript language value) and optional argument argList (a List of ECMAScript language values) and returns either a normal completion containing an ECMAScript language value or a throw completion. 它用于调用函数对象的 [[Call]] 内部方法。func 是函数对象，thisValue 是作为 [[Call]] 的 this 值的 ECMAScript 语言值，argList 是传递给该内部方法对应实参的值。如果 argList 不存在，则使用新的空 List 作为其值。 It performs the following steps when called:

  1. 如果 argList 不存在，则将 argList 设置为新的空 List。
  2. 如果 IsCallable(func) 是 false，则抛出 TypeError 异常。
  3. 返回 ? func.[[Call]](thisValue, argList)。

7.3.14 Construct ( ctor [ , argList [ , newTarget ] ] )

The abstract operation Construct takes argument ctor (a constructor) and optional arguments argList (a List of ECMAScript language values) and newTarget (a constructor) and returns either a normal completion containing an Object or a throw completion. 它用于调用函数对象的 [[Construct]] 内部方法。argList 和 newTarget 是要作为该内部方法对应实参传递的值。如果 argList 不存在，则使用新的空 List 作为其值。如果 newTarget 不存在，则使用 ctor 作为其值。 It performs the following steps when called:

  1. 如果 newTarget 不存在，则将 newTarget 设置为 ctor。
  2. 如果 argList 不存在，则将 argList 设置为新的空 List。
  3. 返回 ? ctor.[[Construct]](argList, newTarget)。
 Note

如果 newTarget 不存在，则此操作等价于：new F(...argumentsList)

7.3.15 SetIntegrityLevel ( obj, level )

The abstract operation SetIntegrityLevel takes arguments obj (an Object) and level (sealed or frozen) and returns either a normal completion containing a Boolean or a throw completion. 它用于固定对象的自有属性集合。 It performs the following steps when called:

  1. 令 status 为 ? obj.[[PreventExtensions]]()。
  2. 如果 status 是 false，则返回 false。
  3. 令 keys 为 ? obj.[[OwnPropertyKeys]]()。
  4. 如果 level 是 sealed，则
    1. 对 keys 的每个元素 key，执行：
      1. 执行 ? DefinePropertyOrThrow(obj, key, PropertyDescriptor { [[Configurable]]: false })。
  5. 否则，
    1. 断言：level 是 frozen。
    2. 对 keys 的每个元素 key，执行：
      1. 令 currentDesc 为 ? obj.[[GetOwnProperty]](key)。
      2. 如果 currentDesc 不是 undefined，则
        1. 如果 IsAccessorDescriptor(currentDesc) 是 true，则
          1. 令 propertyDesc 为 PropertyDescriptor { [[Configurable]]: false }。
        2. 否则，
          1. 令 propertyDesc 为 PropertyDescriptor { [[Configurable]]: false, [[Writable]]: false }。
        3. 执行 ? DefinePropertyOrThrow(obj, key, propertyDesc)。
  6. 返回 true。

7.3.16 TestIntegrityLevel ( obj, level )

The abstract operation TestIntegrityLevel takes arguments obj (an Object) and level (sealed or frozen) and returns either a normal completion containing a Boolean or a throw completion. 它用于确定对象的自有属性集合是否已固定。 It performs the following steps when called:

  1. 令 extensible 为 ? IsExtensible(obj)。
  2. 如果 extensible 是 true，则返回 false。
  3. 注记：如果对象是可扩展的，则不会检查其任何属性。
  4. 令 keys 为 ? obj.[[OwnPropertyKeys]]()。
  5. 对 keys 的每个元素 key，执行：
    1. 令 currentDesc 为 ? obj.[[GetOwnProperty]](key)。
    2. 如果 currentDesc 不是 undefined，则
      1. 如果 currentDesc.[[Configurable]] 是 true，则返回 false。
      2. 如果 level 是 frozen 且 IsDataDescriptor(currentDesc) 是 true，则
        1. 如果 currentDesc.[[Writable]] 是 true，则返回 false。
  6. 返回 true。

7.3.17 CreateArrayFromList ( elements )

The abstract operation CreateArrayFromList takes argument elements (a List of ECMAScript language values) and returns an Array. 它用于创建一个 Array，其元素由 elements 提供。 It performs the following steps when called:

  1. 令 array 为 ! ArrayCreate(0)。
  2. 令 n 为 0。
  3. 对 elements 的每个元素 element，执行：
    1. 执行 ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(n)), element)。
    2. 将 n 设置为 n + 1。
  4. 返回 array。

7.3.18 LengthOfArrayLike ( obj )

The abstract operation LengthOfArrayLike takes argument obj (an Object) and returns either a normal completion containing a non-negative integer or a throw completion. 它返回类数组对象的 "length" 属性的值。 It performs the following steps when called:

  1. 返回 ℝ(? ToLength(? Get(obj, "length")))。

类数组对象是使此操作返回正常完成的任何对象。

Note 1
通常，类数组对象还会具有一些以整数索引为名称的属性。然而，这并不是此定义的要求。
Note 2
Arrays 和 String 对象是类数组对象的例子。

7.3.19 CreateListFromArrayLike ( obj [ , validElementTypes ] )

The abstract operation CreateListFromArrayLike takes argument obj (an ECMAScript language value) and optional argument validElementTypes (all or property-key) and returns either a normal completion containing a List of ECMAScript language values or a throw completion. 它用于创建一个 List 值，其元素由 obj 的索引属性提供。validElementTypes 指示允许作为元素的值的类型。 It performs the following steps when called:

  1. 如果 validElementTypes 不存在，则将 validElementTypes 设置为 all。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 length 为 ? LengthOfArrayLike(obj)。
  4. 令 list 为新的空 List。
  5. 令 index 为 0。
  6. 重复，当 index < length 时：
    1. 令 indexName 为 ! ToString(𝔽(index))。
    2. 令 next 为 ? Get(obj, indexName)。
    3. 如果 validElementTypes 是 property-key 且 next 不是属性键，则抛出 TypeError 异常。
    4. 将 next 追加到 list。
    5. 将 index 设置为 index + 1。
  7. 返回 list。

7.3.20 Invoke ( value, propertyKey [ , argList ] )

The abstract operation Invoke takes arguments value (an ECMAScript language value) and propertyKey (a property key) and optional argument argList (a List of ECMAScript language values) and returns either a normal completion containing an ECMAScript language value or a throw completion. 它用于调用 ECMAScript 语言值的方法属性。value 同时作为属性的查找点和该调用的 this 值。argList 是传递给该方法的实参值列表。如果 argList 不存在，则使用新的空 List 作为其值。 It performs the following steps when called:

  1. 如果 argList 不存在，则将 argList 设置为新的空 List。
  2. 令 func 为 ? GetV(value, propertyKey)。
  3. 返回 ? Call(func, value, argList)。

7.3.21 OrdinaryHasInstance ( ctor, instance )

The abstract operation OrdinaryHasInstance takes arguments ctor (an ECMAScript language value) and instance (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. 它实现默认算法，用于确定 instance 是否继承自 ctor 提供的实例对象继承路径。 It performs the following steps when called:

  1. 如果 IsCallable(ctor) 是 false，则返回 false。
  2. 如果 ctor 具有 [[BoundTargetFunction]] 内部槽，则
    1. 令 boundCtor 为 ctor.[[BoundTargetFunction]]。
    2. 返回 ? InstanceofOperator(instance, boundCtor)。
  3. 如果 instance 不是 Object，则返回 false。
  4. 令 proto 为 ? Get(ctor, "prototype")。
  5. 如果 proto 不是 Object，则抛出 TypeError 异常。
  6. 重复：
    1. 将 instance 设置为 ? instance.[[GetPrototypeOf]]()。
    2. 如果 instance 是 null，则返回 false。
    3. 如果 SameValue(proto, instance) 是 true，则返回 true。

7.3.22 SpeciesConstructor ( obj, defaultCtor )

The abstract operation SpeciesConstructor takes arguments obj (an Object) and defaultCtor (a constructor) and returns either a normal completion containing a constructor or a throw completion. 它用于取回应当用来创建派生自 obj 的新对象的构造函数。defaultCtor 是在从 obj 开始无法找到构造函数的 %Symbol.species% 属性时要使用的构造函数。 It performs the following steps when called:

  1. 令 ctor 为 ? Get(obj, "constructor")。
  2. 如果 ctor 是 undefined，则返回 defaultCtor。
  3. 如果 ctor 不是 Object，则抛出 TypeError 异常。
  4. 令 species 为 ? Get(ctor, %Symbol.species%)。
  5. 如果 species 是 undefined 或 null，则返回 defaultCtor。
  6. 如果 IsConstructor(species) 是 true，则返回 species。
  7. 抛出 TypeError 异常。

7.3.23 EnumerableOwnProperties ( obj, kind )

The abstract operation EnumerableOwnProperties takes arguments obj (an Object) and kind (key, value, or key+value) and returns either a normal completion containing a List of ECMAScript language values or a throw completion. It performs the following steps when called:

  1. 令 ownKeys 为 ? obj.[[OwnPropertyKeys]]()。
  2. 令 results 为新的空 List。
  3. 对 ownKeys 的每个元素 key，执行：
    1. 如果 key 是 String，则
      1. 令 propertyDesc 为 ? obj.[[GetOwnProperty]](key)。
      2. 如果 propertyDesc 不是 undefined 且 propertyDesc.[[Enumerable]] 是 true，则
        1. 如果 kind 是 key，则
          1. 将 key 追加到 results。
        2. 否则，
          1. 令 value 为 ? Get(obj, key)。
          2. 如果 kind 是 value，则
            1. 将 value 追加到 results。
          3. 否则，
            1. 断言：kind 是 key+value。
            2. 令 entry 为 CreateArrayFromList(« key, value »)。
            3. 将 entry 追加到 results。
  4. 返回 results。

7.3.24 GetFunctionRealm ( func )

The abstract operation GetFunctionRealm takes argument func (a function object) and returns either a normal completion containing a Realm Record or a throw completion. It performs the following steps when called:

  1. 如果 func 具有 [[Realm]] 内部槽，则
    1. 返回 func.[[Realm]]。
  2. 如果 func 是绑定函数异质对象，则
    1. 令 boundTargetFunc 为 func.[[BoundTargetFunction]]。
    2. 返回 ? GetFunctionRealm(boundTargetFunc)。
  3. 如果 func 是 Proxy 异质对象，则
    1. 执行 ? ValidateNonRevokedProxy(func)。
    2. 令 proxyTarget 为 func.[[ProxyTarget]]。
    3. 断言：proxyTarget 是函数对象。
    4. 返回 ? GetFunctionRealm(proxyTarget)。
  4. 返回当前 Realm Record。
 Note

只有当 func 是一个非标准函数异质对象且没有 [[Realm]] 内部槽时，才会到达步骤 4。

7.3.25 CopyDataProperties ( target, source, excludedItems )

The abstract operation CopyDataProperties takes arguments target (an Object), source (an ECMAScript language value), and excludedItems (a List of property keys) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 如果 source 是 undefined 或 null，则返回 unused。
  2. 令 from 为 ! ToObject(source)。
  3. 令 keys 为 ? from.[[OwnPropertyKeys]]()。
  4. 对 keys 的每个元素 nextKey，执行：
    1. 令 excluded 为 false。
    2. 对 excludedItems 的每个元素 element，执行：
      1. 如果 SameValue(element, nextKey) 是 true，则
        1. 将 excluded 设置为 true。
    3. 如果 excluded 是 false，则
      1. 令 propertyDesc 为 ? from.[[GetOwnProperty]](nextKey)。
      2. 如果 propertyDesc 不是 undefined 且 propertyDesc.[[Enumerable]] 是 true，则
        1. 令 propertyValue 为 ? Get(from, nextKey)。
        2. 执行 ! CreateDataPropertyOrThrow(target, nextKey, propertyValue)。
  5. 返回 unused。
 Note

这里传入的 target 始终是新创建的对象，在抛出错误的情况下无法直接访问。

7.3.26 PrivateElementFind ( obj, privateName )

The abstract operation PrivateElementFind takes arguments obj (an Object) and privateName (a Private Name) and returns a PrivateElement or empty. It performs the following steps when called:

  1. 如果 obj.[[PrivateElements]] 包含一个 PrivateElement entry，使得 entry.[[Key]] 是 privateName，则
    1. 返回 entry。
  2. 返回 empty。

7.3.27 PrivateFieldAdd ( obj, privateName, value )

The abstract operation PrivateFieldAdd takes arguments obj (an Object), privateName (a Private Name), and value (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 如果宿主是 Web 浏览器，则
    1. 执行 ? HostEnsureCanAddPrivateElement(obj)。
  2. 令 entry 为 PrivateElementFind(obj, privateName)。
  3. 如果 entry 不是 empty，则抛出 TypeError 异常。
  4. 将 PrivateElement { [[Key]]: privateName, [[Kind]]: field, [[Value]]: value } 追加到 obj.[[PrivateElements]]。
  5. 返回 unused。

7.3.28 PrivateMethodOrAccessorAdd ( obj, method )

The abstract operation PrivateMethodOrAccessorAdd takes arguments obj (an Object) and method (a PrivateElement) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 断言：method.[[Kind]] 是 method 或 accessor。
  2. 如果宿主是 Web 浏览器，则
    1. 执行 ? HostEnsureCanAddPrivateElement(obj)。
  3. 令 entry 为 PrivateElementFind(obj, method.[[Key]])。
  4. 如果 entry 不是 empty，则抛出 TypeError 异常。
  5. 将 method 追加到 obj.[[PrivateElements]]。
  6. 返回 unused。
 Note

私有方法和访问器的值在实例之间共享。此操作不会创建方法或访问器的新副本。

7.3.29 HostEnsureCanAddPrivateElement ( obj )

The host-defined abstract operation HostEnsureCanAddPrivateElement takes argument obj (an Object) and returns either a normal completion containing unused or a throw completion. 它允许宿主环境阻止向特定宿主定义的异质对象添加私有元素。

HostEnsureCanAddPrivateElement 的实现必须符合以下要求：

HostEnsureCanAddPrivateElement 的默认实现是返回 NormalCompletion(unused)。

此抽象操作只由作为 Web 浏览器的 ECMAScript 宿主调用。

7.3.30 PrivateGet ( obj, privateName )

The abstract operation PrivateGet takes arguments obj (an Object) and privateName (a Private Name) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. 令 entry 为 PrivateElementFind(obj, privateName)。
  2. 如果 entry 是 empty，则抛出 TypeError 异常。
  3. 如果 entry.[[Kind]] 是 field 或 method，则
    1. 返回 entry.[[Value]]。
  4. 断言：entry.[[Kind]] 是 accessor。
  5. 如果 entry.[[Get]] 是 undefined，则抛出 TypeError 异常。
  6. 令 getter 为 entry.[[Get]]。
  7. 返回 ? Call(getter, obj)。

7.3.31 PrivateSet ( obj, privateName, value )

The abstract operation PrivateSet takes arguments obj (an Object), privateName (a Private Name), and value (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 令 entry 为 PrivateElementFind(obj, privateName)。
  2. 如果 entry 是 empty，则抛出 TypeError 异常。
  3. 如果 entry.[[Kind]] 是 method，则抛出 TypeError 异常。
  4. 如果 entry.[[Kind]] 是 field，则
    1. 将 entry.[[Value]] 设置为 value。
  5. 否则，
    1. 断言：entry.[[Kind]] 是 accessor。
    2. 如果 entry.[[Set]] 是 undefined，则抛出 TypeError 异常。
    3. 令 setter 为 entry.[[Set]]。
    4. 执行 ? Call(setter, obj, « value »)。
  6. 返回 unused。

7.3.32 DefineField ( receiver, fieldRecord )

The abstract operation DefineField takes arguments receiver (an Object) and fieldRecord (a ClassFieldDefinition Record) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 令 fieldName 为 fieldRecord.[[Name]]。
  2. 令 initializer 为 fieldRecord.[[Initializer]]。
  3. 如果 initializer 不是 empty，则
    1. 令 initValue 为 ? Call(initializer, receiver)。
  4. 否则，
    1. 令 initValue 为 undefined。
  5. 如果 fieldName 是 Private Name，则
    1. 执行 ? PrivateFieldAdd(receiver, fieldName, initValue)。
  6. 否则，
    1. 断言：fieldName 是属性键。
    2. 执行 ? CreateDataPropertyOrThrow(receiver, fieldName, initValue)。
  7. 返回 unused。

7.3.33 InitializeInstanceElements ( obj, ctor )

The abstract operation InitializeInstanceElements takes arguments obj (an Object) and ctor (an ECMAScript function object or a built-in function object) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 令 methods 为 ctor.[[PrivateMethods]]。
  2. 对 methods 的每个 PrivateElement method，执行：
    1. 执行 ? PrivateMethodOrAccessorAdd(obj, method)。
  3. 令 fields 为 ctor.[[Fields]]。
  4. 对 fields 的每个元素 fieldRecord，执行：
    1. 执行 ? DefineField(obj, fieldRecord)。
  5. 返回 unused。

7.3.34 AddValueToKeyedGroup ( groups, key, value )

The abstract operation AddValueToKeyedGroup takes arguments groups (a List of Records with fields [[Key]] (an ECMAScript language value) and [[Elements]] (a List of ECMAScript language values)), key (an ECMAScript language value), and value (an ECMAScript language value) and returns unused. It performs the following steps when called:

  1. 对 groups 的每个 Record { [[Key]], [[Elements]] } group，执行：
    1. 如果 SameValue(group.[[Key]], key) 是 true，则
      1. 断言：groups 中恰有一个元素满足此条件。
      2. 将 value 追加到 group.[[Elements]]。
      3. 返回 unused。
  2. 令 group 为 Record { [[Key]]: key, [[Elements]]: « value » }。
  3. 将 group 追加到 groups。
  4. 返回 unused。

7.3.35 GroupBy ( items, callback, keyCoercion )

The abstract operation GroupBy takes arguments items (an ECMAScript language value), callback (an ECMAScript language value), and keyCoercion (property or collection) and returns either a normal completion containing a List of Records with fields [[Key]] (an ECMAScript language value) and [[Elements]] (a List of ECMAScript language values), or a throw completion. It performs the following steps when called:

  1. 执行 ? RequireObjectCoercible(items)。
  2. 如果 IsCallable(callback) 是 false，则抛出 TypeError 异常。
  3. 令 groups 为新的空 List。
  4. 令 iteratorRecord 为 ? GetIterator(items, sync)。
  5. 令 k 为 0。
  6. 重复：
    1. 如果 k ≥ 253 - 1，则
      1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
      2. 返回 ? IteratorClose(iteratorRecord, error)。
    2. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    3. 如果 next 是 done，则
      1. 返回 groups。
    4. 令 value 为 next。
    5. 令 key 为 Completion(Call(callback, undefined, « value, 𝔽(k) »))。
    6. IfAbruptCloseIterator(key, iteratorRecord)。
    7. 如果 keyCoercion 是 property，则
      1. 将 key 设置为 Completion(ToPropertyKey(key))。
      2. IfAbruptCloseIterator(key, iteratorRecord)。
    8. 否则，
      1. 断言：keyCoercion 是 collection。
      2. 将 key 设置为 CanonicalizeKeyedCollectionKey(key)。
    9. 执行 AddValueToKeyedGroup(groups, key, value)。
    10. 将 k 设置为 k + 1。

7.3.36 GetOptionsObject ( options )

The abstract operation GetOptionsObject takes argument options (an ECMAScript language value) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

  1. 如果 options 是 undefined，则
    1. 返回 OrdinaryObjectCreate(null)。
  2. 如果 options 是 Object，则
    1. 返回 options。
  3. 抛出 TypeError 异常。

7.3.37 SetterThatIgnoresPrototypeProperties ( thisValue, home, propertyKey, value )

The abstract operation SetterThatIgnoresPrototypeProperties takes arguments thisValue (an ECMAScript language value), home (an Object), propertyKey (a property key), and value (an ECMAScript language value) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 如果 thisValue 不是 Object，则
    1. 抛出 TypeError 异常。
  2. 如果 SameValue(thisValue, home) 是 true，则
    1. 注记：在此处抛出会模拟在严格模式代码中对 home 对象上的不可写数据属性赋值。
    2. 抛出 TypeError 异常。
  3. 令 propertyDesc 为 ? thisValue.[[GetOwnProperty]](propertyKey)。
  4. 如果 propertyDesc 是 undefined，则
    1. 执行 ? CreateDataPropertyOrThrow(thisValue, propertyKey, value)。
  5. 否则，
    1. 执行 ? Set(thisValue, propertyKey, value, true)。
  6. 返回 unused。

7.4 迭代器对象上的操作

参见通用迭代接口（27.1）。

7.4.1 Iterator Records

Iterator Record 是用于封装迭代器或异步迭代器以及 next 方法的 Record 值。

Iterator Records 具有 Table 13 中列出的字段。

Table 13: Iterator Record 字段
字段名 值 含义
[[Iterator]] Object 符合迭代器接口或异步迭代器接口的对象。
[[NextMethod]] ECMAScript 语言值 [[Iterator]] 对象的 next 方法。
[[Done]] Boolean 迭代器是否已经完成或已被关闭。

7.4.2 GetIteratorDirect ( obj )

The abstract operation GetIteratorDirect takes argument obj (an Object) and returns either a normal completion containing an Iterator Record or a throw completion. It performs the following steps when called:

  1. 令 nextMethod 为 ? Get(obj, "next")。
  2. 令 iteratorRecord 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: nextMethod, [[Done]]: false }。
  3. 返回 iteratorRecord。

7.4.3 GetIteratorFromMethod ( obj, method )

The abstract operation GetIteratorFromMethod takes arguments obj (an ECMAScript language value) and method (a function object) and returns either a normal completion containing an Iterator Record or a throw completion. It performs the following steps when called:

  1. 令 iterator 为 ? Call(method, obj)。
  2. 如果 iterator 不是 Object，则抛出 TypeError 异常。
  3. 返回 ? GetIteratorDirect(iterator)。

7.4.4 GetIterator ( obj, kind )

The abstract operation GetIterator takes arguments obj (an ECMAScript language value) and kind (sync or async) and returns either a normal completion containing an Iterator Record or a throw completion. It performs the following steps when called:

  1. 如果 kind 是 async，则
    1. 令 method 为 ? GetMethod(obj, %Symbol.asyncIterator%)。
    2. 如果 method 是 undefined，则
      1. 令 syncMethod 为 ? GetMethod(obj, %Symbol.iterator%)。
      2. 如果 syncMethod 是 undefined，则抛出 TypeError 异常。
      3. 令 syncIteratorRecord 为 ? GetIteratorFromMethod(obj, syncMethod)。
      4. 返回 CreateAsyncFromSyncIterator(syncIteratorRecord)。
  2. 否则，
    1. 令 method 为 ? GetMethod(obj, %Symbol.iterator%)。
  3. 如果 method 是 undefined，则抛出 TypeError 异常。
  4. 返回 ? GetIteratorFromMethod(obj, method)。

7.4.5 GetIteratorFlattenable ( obj, primitiveHandling )

The abstract operation GetIteratorFlattenable takes arguments obj (an ECMAScript language value) and primitiveHandling (iterate-string-primitives or reject-primitives) and returns either a normal completion containing an Iterator Record or a throw completion. It performs the following steps when called:

  1. 如果 obj 不是 Object，则
    1. 如果 primitiveHandling 是 reject-primitives，则抛出 TypeError 异常。
    2. 断言：primitiveHandling 是 iterate-string-primitives。
    3. 如果 obj 不是 String，则抛出 TypeError 异常。
  2. 令 method 为 ? GetMethod(obj, %Symbol.iterator%)。
  3. 如果 method 是 undefined，则
    1. 令 iterator 为 obj。
  4. 否则，
    1. 令 iterator 为 ? Call(method, obj)。
  5. 如果 iterator 不是 Object，则抛出 TypeError 异常。
  6. 返回 ? GetIteratorDirect(iterator)。

7.4.6 IteratorNext ( iteratorRecord [ , value ] )

The abstract operation IteratorNext takes argument iteratorRecord (an Iterator Record) and optional argument value (an ECMAScript language value) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

  1. 如果 value 不存在，则
    1. 令 result 为 Completion(Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]))。
  2. 否则，
    1. 令 result 为 Completion(Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « value »))。
  3. 如果 result 是 throw 完成，则
    1. 将 iteratorRecord.[[Done]] 设置为 true。
    2. 返回 ? result。
  4. 将 result 设置为 ! result。
  5. 如果 result 不是 Object，则
    1. 将 iteratorRecord.[[Done]] 设置为 true。
    2. 抛出 TypeError 异常。
  6. 返回 result。

7.4.7 IteratorComplete ( iteratorResult )

The abstract operation IteratorComplete takes argument iteratorResult (an Object) and returns either a normal completion containing a Boolean or a throw completion. It performs the following steps when called:

  1. 返回 ToBoolean(? Get(iteratorResult, "done"))。

7.4.8 IteratorValue ( iteratorResult )

The abstract operation IteratorValue takes argument iteratorResult (an Object) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. 返回 ? Get(iteratorResult, "value")。

7.4.9 IteratorStep ( iteratorRecord )

The abstract operation IteratorStep takes argument iteratorRecord (an Iterator Record) and returns either a normal completion containing either an Object or done, or a throw completion. 它通过调用 iteratorRecord.[[NextMethod]] 从 iteratorRecord.[[Iterator]] 请求下一个值，并返回 done 或 IteratorResult 对象；done 表示该迭代器已到达其末尾，IteratorResult 对象表示下一个值可用。 It performs the following steps when called:

  1. 令 result 为 ? IteratorNext(iteratorRecord)。
  2. 令 done 为 Completion(IteratorComplete(result))。
  3. 如果 done 是 throw 完成，则
    1. 将 iteratorRecord.[[Done]] 设置为 true。
    2. 返回 ? done。
  4. 将 done 设置为 ! done。
  5. 如果 done 是 true，则
    1. 将 iteratorRecord.[[Done]] 设置为 true。
    2. 返回 done。
  6. 返回 result。

7.4.10 IteratorStepValue ( iteratorRecord )

The abstract operation IteratorStepValue takes argument iteratorRecord (an Iterator Record) and returns either a normal completion containing either an ECMAScript language value or done, or a throw completion. 它通过调用 iteratorRecord.[[NextMethod]] 从 iteratorRecord.[[Iterator]] 请求下一个值，并返回 done 或 IteratorResult 对象中的值；done 表示该迭代器已到达其末尾，值表示下一个值可用。 It performs the following steps when called:

  1. 令 result 为 ? IteratorStep(iteratorRecord)。
  2. 如果 result 是 done，则
    1. 返回 done。
  3. 令 value 为 Completion(IteratorValue(result))。
  4. 如果 value 是 throw 完成，则
    1. 将 iteratorRecord.[[Done]] 设置为 true。
  5. 返回 ? value。

7.4.11 IteratorClose ( iteratorRecord, completion )

The abstract operation IteratorClose takes arguments iteratorRecord (an Iterator Record) and completion (a Completion Record) and returns a Completion Record. 它用于通知迭代器应执行其在到达完成状态时通常会执行的任何动作。 It performs the following steps when called:

  1. 断言：iteratorRecord.[[Iterator]] 是 Object。
  2. 令 iterator 为 iteratorRecord.[[Iterator]]。
  3. 令 innerResult 为 Completion(GetMethod(iterator, "return")).
  4. 如果 innerResult 是 normal 完成，则
    1. 令 return 为 innerResult.[[Value]]。
    2. 如果 return 是 undefined，则返回 ? completion。
    3. 将 innerResult 设置为 Completion(Call(return, iterator))。
  5. 如果 completion 是 throw 完成，则返回 ? completion。
  6. 如果 innerResult 是 throw 完成，则返回 ? innerResult。
  7. 如果 innerResult.[[Value]] 不是 Object，则抛出 TypeError 异常。
  8. 返回 ? completion。

7.4.12 IteratorCloseAll ( iterators, completion )

The abstract operation IteratorCloseAll takes arguments iterators (a List of Iterator Records) and completion (a Completion Record) and returns a Completion Record. It performs the following steps when called:

  1. 对 iterators 的每个元素 iterator，按 List 的逆序，执行：
    1. 将 completion 设置为 Completion(IteratorClose(iterator, completion))。
  2. 返回 ? completion。

7.4.13 IfAbruptCloseIterator ( value, iteratorRecord )

IfAbruptCloseIterator 是一系列使用 Iterator Record 的算法步骤的简写。形如以下形式的算法步骤：

  1. IfAbruptCloseIterator(value, iteratorRecord).

与以下内容含义相同：

  1. 断言：value 是 Completion Record。
  2. 如果 value 是 abrupt 完成，则返回 ? IteratorClose(iteratorRecord, value)。
  3. 将 value 设置为 ! value。

7.4.14 IfAbruptCloseIterators ( value, iteratorRecords )

IfAbruptCloseIterators 是一系列使用 Iterator Records 列表的算法步骤的简写。形如以下形式的算法步骤：

  1. IfAbruptCloseIterators(value, iteratorRecords).

与以下内容含义相同：

  1. 断言：value 是 Completion Record。
  2. 如果 value 是 abrupt 完成，则返回 ? IteratorCloseAll(iteratorRecords, value)。
  3. 将 value 设置为 ! value。

7.4.15 AsyncIteratorClose ( iteratorRecord, completion )

The abstract operation AsyncIteratorClose takes arguments iteratorRecord (an Iterator Record) and completion (a Completion Record) and returns a Completion Record. 它用于通知异步迭代器应执行其在到达完成状态时通常会执行的任何动作。 It performs the following steps when called:

  1. 断言：iteratorRecord.[[Iterator]] 是 Object。
  2. 令 iterator 为 iteratorRecord.[[Iterator]]。
  3. 令 innerResult 为 Completion(GetMethod(iterator, "return")).
  4. 如果 innerResult 是 normal 完成，则
    1. 令 return 为 innerResult.[[Value]]。
    2. 如果 return 是 undefined，则返回 ? completion。
    3. 将 innerResult 设置为 Completion(Call(return, iterator))。
    4. 如果 innerResult 是 normal 完成，则将 innerResult 设置为 Completion(Await(innerResult.[[Value]]))。
  5. 如果 completion 是 throw 完成，则返回 ? completion。
  6. 如果 innerResult 是 throw 完成，则返回 ? innerResult。
  7. 如果 innerResult.[[Value]] 不是 Object，则抛出 TypeError 异常。
  8. 返回 ? completion。

7.4.16 IfAbruptCloseAsyncIterator ( value, iteratorRecord )

IfAbruptCloseAsyncIterator 是一系列使用 Iterator Record 的算法步骤的简写。形如以下形式的算法步骤：

  1. IfAbruptCloseAsyncIterator(value, iteratorRecord).

与以下内容含义相同：

  1. 断言：value 是 Completion Record。
  2. 如果 value 是 abrupt 完成，则返回 ? AsyncIteratorClose(iteratorRecord, value)。
  3. 将 value 设置为 ! value。

7.4.17 CreateIteratorResultObject ( value, done )

The abstract operation CreateIteratorResultObject takes arguments value (an ECMAScript language value) and done (a Boolean) and returns an Object that conforms to the IteratorResult interface. 它创建一个符合 IteratorResult 接口的对象。 It performs the following steps when called:

  1. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
  2. 执行 ! CreateDataPropertyOrThrow(obj, "value", value)。
  3. 执行 ! CreateDataPropertyOrThrow(obj, "done", done)。
  4. 返回 obj。

7.4.18 CreateListIteratorRecord ( list )

The abstract operation CreateListIteratorRecord takes argument list (a List of ECMAScript language values) and returns an Iterator Record. 它创建一个 Iterator Record，其 [[NextMethod]] 返回 list 的连续元素。 It performs the following steps when called:

  1. 令 closure 为一个不带形参的新 Abstract Closure，它捕获 list，并在被调用时执行以下步骤：
    1. 对 list 的每个元素 value，执行：
      1. 执行 ? GeneratorYield(CreateIteratorResultObject(value, false))。
    2. 返回 NormalCompletion(undefined)。
  2. 令 iterator 为 CreateIteratorFromClosure(closure, empty, %Iterator.prototype%)。
  3. 返回 Iterator Record { [[Iterator]]: iterator, [[NextMethod]]: %GeneratorPrototype.next%, [[Done]]: false }。
 Note

list 迭代器对象永远不会被 ECMAScript 代码直接访问。

7.4.19 IteratorToList ( iteratorRecord )

The abstract operation IteratorToList takes argument iteratorRecord (an Iterator Record) and returns either a normal completion containing a List of ECMAScript language values or a throw completion. It performs the following steps when called:

  1. 令 values 为新的空 List。
  2. 重复：
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 返回 values。
    3. 将 next 追加到 values。

7.5 对可处置对象的操作

参见通用资源管理接口（27.2.1）。

7.5.1 DisposableResource 记录

DisposableResource 记录是一个记录值，用于封装一个可处置对象以及用于处置该对象的方法。DisposableResource 记录由 CreateDisposableResource 抽象操作产生。

DisposableResource 记录具有 Table 14 中列出的字段：

Table 14: DisposableResource 记录字段
字段名 值 含义
[[ResourceValue]] 一个对象或 undefined 要被处置的值。
[[Kind]] sync-dispose 或 async-dispose 指示资源是由 using 声明或 DisposableStack 对象添加的（sync-dispose），还是由 await using 声明或 AsyncDisposableStack 对象添加的（async-dispose）。
[[DisposeMethod]] 一个函数对象或 undefined 当资源被处置时，将以 [[ResourceValue]] 作为其 this 值调用的函数对象。

7.5.2 AddDisposableResource ( disposableResourceStack, value, kind [ , method ] )

The abstract operation AddDisposableResource takes arguments disposableResourceStack (DisposableResource 记录的列表，), value (ECMAScript 语言值，), and kind (sync-dispose 或 async-dispose，) and optional argument method (函数对象，) and returns 含有 unused 的正常完成，或抛出完成. It performs the following steps when called:

  1. 如果存在 method，则
    1. 断言：value 是 undefined。
    2. 令 resource 为 ? CreateDisposableResource(undefined, kind, method)。
  2. 否则，
    1. 如果 value 是 null 或 undefined，且 kind 是 sync-dispose，则返回 unused。
    2. 注：当 value 是 null 或 undefined，且 kind 是 async-dispose 时，我们会记录该资源已被求值，以确保稍后处置资源时仍将执行 Await。
    3. 令 resource 为 ? CreateDisposableResource(value, kind)。
  3. 将 resource 追加到 disposableResourceStack。
  4. 返回 unused。

7.5.3 CreateDisposableResource ( value, kind [ , method ] )

The abstract operation CreateDisposableResource takes arguments value (ECMAScript 语言值，) and kind (sync-dispose 或 async-dispose，) and optional argument method (函数对象，) and returns 含有 DisposableResource 记录的正常完成，或抛出完成. It performs the following steps when called:

  1. 如果不存在 method，则
    1. 如果 value 是 null 或 undefined，则
      1. 将 value 设置为 undefined。
      2. 将 method 设置为 undefined。
    2. 否则，
      1. 将 method 设置为 ? GetDisposeMethod(value, kind)。
      2. 如果 method 是 undefined，则抛出 TypeError 异常。
  2. 返回 DisposableResource 记录 { [[ResourceValue]]: value, [[Kind]]: kind, [[DisposeMethod]]: method }。

7.5.4 GetDisposeMethod ( value, kind )

The abstract operation GetDisposeMethod takes arguments value (ECMAScript 语言值，) and kind (sync-dispose 或 async-dispose，) and returns 含有函数对象或 undefined 的正常完成，或抛出完成. It performs the following steps when called:

  1. 如果 value 不是对象，则抛出 TypeError 异常。
  2. 如果 kind 是 sync-dispose，则返回 ? GetMethod(value, %Symbol.dispose%)。
  3. 断言：kind 是 async-dispose。
  4. 令 asyncMethod 为 ? GetMethod(value, %Symbol.asyncDispose%)。
  5. 如果 asyncMethod 不是 undefined，则返回 asyncMethod。
  6. 令 syncMethod 为 ? GetMethod(value, %Symbol.dispose%)。
  7. 如果 syncMethod 是 undefined，则返回 undefined。
  8. 令 closure 为一个新的抽象闭包，该闭包没有参数，捕获 syncMethod，并在被调用时执行以下步骤：
    1. 令 obj 为 this 值。
    2. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
    3. 令 result 为 Completion(Call(syncMethod, obj))。
    4. IfAbruptRejectPromise(result, promiseCapability)。
    5. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « undefined »)。
    6. 返回 promiseCapability.[[Promise]]。
  9. 注：此函数对用户代码不可观察。它用于确保从同步 %Symbol.dispose% 方法返回的 Promise 不会被 awaited，并且同步异常会被转换为被拒绝的 Promise。
  10. 返回 CreateBuiltinFunction(closure, 0, "", « »)。

7.5.5 DisposeResources ( disposableResourceStack, completion )

The abstract operation DisposeResources takes arguments disposableResourceStack (DisposableResource 记录的列表，) and completion (含有 ECMAScript 语言值或 empty 的正常完成，或突兀完成，) and returns 含有 ECMAScript 语言值或 empty 的正常完成，或突兀完成. It performs the following steps when called:

  1. 令 needsAwait 为 false。
  2. 令 hasAwaited 为 false。
  3. 令 outputCompletion 为 completion。
  4. 对 disposableResourceStack 的每个元素 resource，按列表逆序执行
    1. 令 value 为 resource.[[ResourceValue]]。
    2. 令 kind 为 resource.[[Kind]]。
    3. 令 method 为 resource.[[DisposeMethod]]。
    4. 如果 kind 是 sync-dispose、needsAwait 是 true，并且 hasAwaited 是 false，则
      1. 执行 ! Await(undefined)。
      2. 将 needsAwait 设置为 false。
    5. 如果 method 不是 undefined，则
      1. 令 result 为 Completion(Call(method, value))。
      2. 如果 result 是正常完成且 kind 是 async-dispose，则
        1. 将 result 设置为 Completion(Await(result.[[Value]]))。
        2. 将 hasAwaited 设置为 true。
      3. 如果 result 是抛出完成，则
        1. 如果 outputCompletion 是抛出完成，则
          1. 将 result 设置为 result.[[Value]]。
          2. 令 suppressed 为 outputCompletion.[[Value]]。
          3. 令 error 为新创建的 SuppressedError 对象。
          4. 执行 CreateNonEnumerableDataPropertyOrThrow(error, "error", result)。
          5. 执行 CreateNonEnumerableDataPropertyOrThrow(error, "suppressed", suppressed)。
          6. 将 outputCompletion 设置为 ThrowCompletion(error)。
        2. 否则，
          1. 将 outputCompletion 设置为 result。
    6. 否则，
      1. 断言：kind 是 async-dispose。
      2. 将 needsAwait 设置为 true。
      3. 注：这只能表示 await using 声明的初始化值为 null 或 undefined 的情况。
  5. 如果 needsAwait 是 true 且 hasAwaited 是 false，则
    1. 执行 ! Await(undefined)。
  6. 注：此时 disposableResourceStack 将永远不会再被使用。在实现中可以丢弃 disposableResourceStack 的内容，例如通过垃圾回收。
  7. 返回 ? outputCompletion。