7 抽象操作

这些操作不是 ECMAScript 语言的一部分；它们在这里只是为了帮助描述 ECMAScript 语言语义的规范而定义的。本规范的其他部分还定义了更多、更专门的抽象操作。

7.1 类型转换

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

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

7.1.1 ToPrimitive ( input [ , preferredType ] )

The abstract operation ToPrimitive takes argument input (一个 ECMAScript 语言值，) and optional argument preferredType (string 或 number，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 它将其参数 input 转换为非 Object 类型。若某个对象能够转换为多种原始类型，则它可以使用可选提示 preferredType 来优先选择该类型。 It performs the following steps when called:

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

当不带提示调用 ToPrimitive 时，它通常表现得如同提示为 number。不过，对象可以通过定义 %Symbol.toPrimitive% 方法来覆盖这一行为。在本规范定义的对象中，只有 Date（见 21.4.4.45）和 Symbol 对象（见 20.4.3.5）覆盖了默认的 ToPrimitive 行为。Date 会将缺少提示视为提示是 string。

7.1.1.1 OrdinaryToPrimitive ( obj, hint )

The abstract operation OrdinaryToPrimitive takes arguments obj (一个 Object，) and hint (string 或 number，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 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 ( argument )

The abstract operation ToBoolean takes argument argument (一个 ECMAScript 语言值，) and returns 一个 Boolean. 它将 argument 转换为 Boolean 类型的值。 It performs the following steps when called:

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

7.1.3 ToNumeric ( value )

The abstract operation ToNumeric takes argument value (一个 ECMAScript 语言值，) and returns 要么是包含 Number 或 BigInt 的正常完成，要么是抛出完成. 它返回转换为 Number 或 BigInt 的 value。 It performs the following steps when called:

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

7.1.4 ToNumber ( argument )

The abstract operation ToNumber takes argument argument (一个 ECMAScript 语言值，) and returns 要么是包含 Number 的正常完成，要么是抛出完成. 它将 argument 转换为 Number 类型的值。 It performs the following steps when called:

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

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 ( str )

The abstract operation StringToNumber takes argument str (一个 String，) and returns 一个 Number. It performs the following steps when called:

  1. 令 literal 为 ParseText(str, StringNumericLiteral)。
  2. 如果 literal 是一个错误列表，返回 NaN。
  3. 返回 literal 的 StringNumericValue。

7.1.4.1.2 Runtime Semantics: StringNumericValue

The syntax-directed operation StringNumericValue takes no arguments and returns 一个 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 (一个数学值，) and returns 一个 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 ( argument )

The abstract operation ToIntegerOrInfinity takes argument argument (一个 ECMAScript 语言值，) and returns 要么是包含整数、+∞ 或 -∞ 的正常完成，要么是抛出完成. 它将 argument 转换为一个整数，该整数表示其 Number 值去掉小数部分后的结果；如果该 Number 值是无穷大，则转换为 +∞ 或 -∞。 It performs the following steps when called:

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

7.1.6 ToFixedSizeInteger ( int, signed, bitWidth )

The abstract operation ToFixedSizeInteger takes arguments int (一个整数、+∞ 或 -∞), signed (unsigned 或 signed), and bitWidth (一个正整数) and returns 一个整数. 它将 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 模 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 ( argument )

The abstract operation ToInt32 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 232 个整数 Number 值之一，该值位于从 𝔽(-231) 到 𝔽(231 - 1) 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

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

7.1.8 ToUint32 ( argument )

The abstract operation ToUint32 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 232 个整数 Number 值之一，该值位于从 +0𝔽 到 𝔽(232 - 1) 的闭区间内。 It performs the following steps when called:

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

7.1.9 ToInt16 ( argument )

The abstract operation ToInt16 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 216 个整数 Number 值之一，该值位于从 𝔽(-215) 到 𝔽(215 - 1) 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

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

7.1.10 ToUint16 ( argument )

The abstract operation ToUint16 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 216 个整数 Number 值之一，该值位于从 +0𝔽 到 𝔽(216 - 1) 的闭区间内。 It performs the following steps when called:

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

7.1.11 ToInt8 ( argument )

The abstract operation ToInt8 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 28 个整数 Number 值之一，该值位于从 -128𝔽 到 127𝔽 的闭区间内，不包括 -0𝔽。 It performs the following steps when called:

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

7.1.12 ToUint8 ( argument )

The abstract operation ToUint8 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 28 个整数 Number 值之一，该值位于从 +0𝔽 到 255𝔽 的闭区间内。 It performs the following steps when called:

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

7.1.13 ToUint8Clamp ( argument )

The abstract operation ToUint8Clamp takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 钳制并舍入为 28 个整数 Number 值之一，该值位于从 +0𝔽 到 255𝔽 的闭区间内。 It performs the following steps when called:

  1. 令 number 为 ? ToNumber(argument)。
  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 ( argument )

The abstract operation ToBigInt takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含 BigInt 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 BigInt 值；如果需要从 Number 进行隐式转换，则抛出异常。 It performs the following steps when called:

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

7.1.15 StringToBigInt ( str )

The abstract operation StringToBigInt takes argument str (一个 String) and returns 一个 BigInt 或 undefined. It performs the following steps when called:

  1. 令 literal 为 ParseText(str, StringIntegerLiteral)。
  2. 如果 literal 是一个错误列表，则返回 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 运行时语义：MV

7.1.16 ToBigInt64 ( argument )

The abstract operation ToBigInt64 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含 BigInt 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 264 个 BigInt 值之一，该值位于从 ℤ(-263) 到 ℤ(263 - 1) 的闭区间内。 It performs the following steps when called:

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

7.1.17 ToBigUint64 ( argument )

The abstract operation ToBigUint64 takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含 BigInt 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 264 个 BigInt 值之一，该值位于从 0ℤ 到 ℤ(264 - 1) 的闭区间内。 It performs the following steps when called:

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

7.1.18 ToString ( argument )

The abstract operation ToString takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含 String 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 String 类型的值。 It performs the following steps when called:

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

7.1.19 ToObject ( argument )

The abstract operation ToObject takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含 Object 的正常完成，要么是一个 throw 完成. 它将 argument 转换为 Object 类型的值。 It performs the following steps when called:

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

7.1.20 ToPropertyKey ( argument )

The abstract operation ToPropertyKey takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含属性键的正常完成，要么是一个 throw 完成. 它将 argument 转换为可用作属性键的值。 It performs the following steps when called:

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

7.1.21 ToLength ( argument )

The abstract operation ToLength takes argument argument (一个 ECMAScript 语言值) and returns 要么是一个包含非负整数 Number 的正常完成，要么是一个 throw 完成. 它将 argument 钳制并截断为适合用作类数组对象长度的非负整数 Number。 It performs the following steps when called:

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

7.1.22 CanonicalNumericIndexString ( argument )

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

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

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

7.1.23 ToIndex ( value )

The abstract operation ToIndex takes argument value (一个 ECMAScript 语言值，) and returns 要么是包含非负整数的正常完成，要么是抛出完成. 它将 value 转换为整数，并且如果该整数是非负且对应于一个整数索引，则返回该整数。否则，抛出异常。 It performs the following steps when called:

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

7.2 测试与比较操作

7.2.1 RequireObjectCoercible ( argument )

The abstract operation RequireObjectCoercible takes argument argument (一个 ECMAScript 语言值，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 如果 argument 是一个无法使用 ToObject 转换为 Object 的值，它就抛出错误。 It performs the following steps when called:

  1. 如果 argument 是 undefined 或 null 之一，抛出一个 TypeError 异常。
  2. 返回 unused。

7.2.2 IsArray ( argument )

The abstract operation IsArray takes argument argument (一个 ECMAScript 语言值，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.2.3 IsCallable ( argument )

The abstract operation IsCallable takes argument argument (一个 ECMAScript 语言值，) and returns 一个 Boolean. 它判定 argument 是否为具有 [[Call]] 内部方法的可调用函数。 It performs the following steps when called:

  1. 如果 argument 不是一个 Object，返回 false。
  2. 如果 argument 拥有 [[Call]] 内部方法，返回 true。
  3. 返回 false。

7.2.4 IsConstructor ( argument )

The abstract operation IsConstructor takes argument argument (一个 ECMAScript 语言值，) and returns 一个 Boolean. 它判定 argument 是否为具有 [[Construct]] 内部方法的函数对象。 It performs the following steps when called:

  1. 如果 argument 不是一个 Object，返回 false。
  2. 如果 argument 拥有 [[Construct]] 内部方法，返回 true。
  3. 返回 false。

7.2.5 IsExtensible ( obj )

The abstract operation IsExtensible takes argument obj (一个 Object，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于确定是否可以向 obj 添加额外属性。 It performs the following steps when called:

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

7.2.6 IsRegExp ( argument )

The abstract operation IsRegExp takes argument argument (一个 ECMAScript 语言值，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.2.7 Static Semantics: IsStringWellFormedUnicode ( string )

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

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

7.2.8 SameType ( x, y )

The abstract operation SameType takes arguments x (一个 ECMAScript 语言值，) and y (一个 ECMAScript 语言值，) and returns 一个 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 (一个 ECMAScript 语言值，) and y (一个 ECMAScript 语言值，) and returns 一个 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 (一个 ECMAScript 语言值，) and y (一个 ECMAScript 语言值，) and returns 一个 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 (一个 ECMAScript 语言值，但不是 Number，) and y (一个 ECMAScript 语言值，但不是 Number，) and returns 一个 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 (一个 ECMAScript 语言值，), y (一个 ECMAScript 语言值，), and leftFirst (一个 Boolean，) and returns 要么是包含 Boolean 或 undefined 的正常完成，要么是抛出完成. 它为比较 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

String 的比较使用 UTF-16 码元值序列上的简单字典序排序。它不会尝试使用 Unicode 规范中定义的更复杂、面向语义的字符或字符串相等性与排序规则定义。因此，根据 Unicode 标准在规范上相等但不处于同一规范化形式的 String 值，测试结果可能会是不相等。还要注意，按码元的字典序与按码点的排序，对于包含代理对的 String 来说是不同的。

7.2.13 IsLooselyEqual ( x, y )

The abstract operation IsLooselyEqual takes arguments x (一个 ECMAScript 语言值，) and y (一个 ECMAScript 语言值，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它提供 == 运算符的语义。 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
    如果宿主是网页浏览器，或以其他方式支持 [[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 (一个 ECMAScript 语言值，) and y (一个 ECMAScript 语言值，) and returns 一个 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 算法的不同之处在于它对有符号零和 NaN 的处理。

7.3 对象上的操作

7.3.1 MakeBasicObject ( internalSlotsList )

The abstract operation MakeBasicObject takes argument internalSlotsList (一个内部槽名称的 List，) and returns 一个 Object. 它是一切通过算法创建的 ECMAScript 对象的来源，包括普通对象和异质对象。它提取了创建所有对象时都会用到的共同步骤，并集中处理对象创建。 It performs the following steps when called:

  1. 将 internalSlotsList 设为 internalSlotsList 与 « [[PrivateElements]] » 的列表连接。
  2. 令 obj 为一个新创建的对象，其对 internalSlotsList 中每个名称都具有一个内部槽。
  3. 注：如 对象内部方法和内部槽 所述，除非另有规定，每个这类内部槽的初始值都是 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 (一个 Object，) and propertyKey (一个属性键，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 它用于获取对象某个特定属性的值。 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 (一个 ECMAScript 语言值，) and propertyKey (一个属性键，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 它用于获取某个 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 (一个 Object，), propertyKey (一个属性键，), value (一个 ECMAScript 语言值，), and throw (一个 Boolean，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 它用于设置对象某个特定属性的值。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 (一个 Object，), propertyKey (一个属性键，), and value (一个 ECMAScript 语言值，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于创建对象的一个新的自有属性。 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 (一个 Object，), propertyKey (一个属性键，), and value (一个 ECMAScript 语言值，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 它用于创建对象的一个新的自有属性。如果所请求的属性更新无法执行，它会抛出 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 (一个 Object，), propertyKey (一个属性键，), and value (一个 ECMAScript 语言值，) 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, desc )

The abstract operation DefinePropertyOrThrow takes arguments obj (一个 Object，), propertyKey (一个属性键，), and desc (一个 Property Descriptor，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 它用于以一种在所请求的属性更新无法执行时会抛出 TypeError 异常的方式，调用对象的 [[DefineOwnProperty]] 内部方法。 It performs the following steps when called:

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

7.3.9 DeletePropertyOrThrow ( obj, propertyKey )

The abstract operation DeletePropertyOrThrow takes arguments obj (一个 Object，) and propertyKey (一个属性键，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 它用于移除对象的一个特定自有属性。如果该属性不可配置，它会抛出异常。 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 (一个 ECMAScript 语言值，) and propertyKey (一个属性键，) and returns 要么是包含函数对象或 undefined 的正常完成，要么是抛出完成. 它用于在期望属性值为函数时，获取某个 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 (一个 Object，) and propertyKey (一个属性键，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于判定对象是否具有指定属性键的属性。该属性可以是自有属性，也可以是继承属性。 It performs the following steps when called:

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

7.3.12 HasOwnProperty ( obj, propertyKey )

The abstract operation HasOwnProperty takes arguments obj (一个 Object，) and propertyKey (一个属性键，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于判定对象是否具有指定属性键的自有属性。 It performs the following steps when called:

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

7.3.13 Call ( func, thisValue [ , argumentsList ] )

The abstract operation Call takes arguments func (一个 ECMAScript 语言值，) and thisValue (一个 ECMAScript 语言值，) and optional argument argumentsList (一个 ECMAScript 语言值的 List，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 它用于调用函数对象的 [[Call]] 内部方法。func 是函数对象，thisValue 是一个 ECMAScript 语言值，它是 [[Call]] 的 this 值，而 argumentsList 是传给该内部方法对应参数的值。如果 argumentsList 不存在，则使用一个新的空 List 作为其值。 It performs the following steps when called:

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

7.3.14 Construct ( constructor [ , argumentsList [ , newTarget ] ] )

The abstract operation Construct takes argument constructor (一个构造器，) and optional arguments argumentsList (一个 ECMAScript 语言值的 List，) and newTarget (一个构造器，) and returns 要么是包含 Object 的正常完成，要么是抛出完成. 它用于调用函数对象的 [[Construct]] 内部方法。argumentsList 和 newTarget 是要作为内部方法对应参数传入的值。如果 argumentsList 不存在，则使用一个新的空 List 作为其值。如果 newTarget 不存在，则使用 constructor 作为其值。 It performs the following steps when called:

  1. 如果 newTarget 不存在，将 newTarget 设为 constructor。
  2. 如果 argumentsList 不存在，将 argumentsList 设为一个新的空 List。
  3. 返回 ? constructor.[[Construct]](argumentsList, newTarget)。
 Note

如果 newTarget 不存在，那么该操作等价于：new F(...argumentsList)

7.3.15 SetIntegrityLevel ( obj, level )

The abstract operation SetIntegrityLevel takes arguments obj (一个 Object，) and level (sealed 或 frozen，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于固定一个对象的自有属性集合。 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. 令 desc 为 PropertyDescriptor { [[Configurable]]: false }。
        2. 否则，
          1. 令 desc 为 PropertyDescriptor { [[Configurable]]: false, [[Writable]]: false }。
        3. 执行 ? DefinePropertyOrThrow(obj, key, desc)。
  6. 返回 true。

7.3.16 TestIntegrityLevel ( obj, level )

The abstract operation TestIntegrityLevel takes arguments obj (一个 Object，) and level (sealed 或 frozen，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它用于判定对象的自有属性集合是否已经固定。 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 (一个 ECMAScript 语言值的 List，) and returns 一个 Array. 它用于创建一个 Array，其元素由 elements 提供。 It performs the following steps when called:

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

7.3.18 LengthOfArrayLike ( obj )

The abstract operation LengthOfArrayLike takes argument obj (一个 Object，) and returns 要么是包含非负整数的正常完成，要么是抛出完成. 它返回类数组对象的 "length" 属性值。 It performs the following steps when called:

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

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

Note 1
通常，类数组对象也会有一些以整数索引名称命名的属性。不过，这不是该定义的要求。
Note 2
Array 和 String 对象都是类数组对象的例子。

7.3.19 CreateListFromArrayLike ( obj [ , validElementTypes ] )

The abstract operation CreateListFromArrayLike takes argument obj (一个 ECMAScript 语言值，) and optional argument validElementTypes (all 或 property-key，) and returns 要么是包含 ECMAScript 语言值的 List 的正常完成，要么是抛出完成. 它用于创建一个 List，其元素由 obj 的索引属性提供。validElementTypes 指示哪些类型的值允许作为元素。 It performs the following steps when called:

  1. 如果 validElementTypes 不存在，将 validElementTypes 设为 all。
  2. 如果 obj 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 len 为 ? LengthOfArrayLike(obj)。
  4. 令 list 为一个新的空 List。
  5. 令 index 为 0。
  6. 重复，当 index < len 时，
    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 [ , argumentsList ] )

The abstract operation Invoke takes arguments value (一个 ECMAScript 语言值，) and propertyKey (一个属性键，) and optional argument argumentsList (一个 ECMAScript 语言值的 List，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 它用于调用某个 ECMAScript 语言值的方法属性。value 同时充当该属性的查找起点和调用时的 this 值。argumentsList 是传给该方法的参数值列表。如果 argumentsList 不存在，则使用一个新的空 List 作为其值。 It performs the following steps when called:

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

7.3.21 OrdinaryHasInstance ( constructor, instance )

The abstract operation OrdinaryHasInstance takes arguments constructor (一个 ECMAScript 语言值，) and instance (一个 ECMAScript 语言值，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. 它实现默认算法，用于判定 instance 是否继承自由 constructor 提供的实例对象继承路径。 It performs the following steps when called:

  1. 如果 IsCallable(constructor) 是 false，返回 false。
  2. 如果 constructor 拥有 [[BoundTargetFunction]] 内部槽，那么
    1. 令 boundConstructor 为 constructor.[[BoundTargetFunction]]。
    2. 返回 ? InstanceofOperator(instance, boundConstructor)。
  3. 如果 instance 不是一个 Object，返回 false。
  4. 令 proto 为 ? Get(constructor, "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, defaultConstructor )

The abstract operation SpeciesConstructor takes arguments obj (一个 Object，) and defaultConstructor (一个构造器，) and returns 要么是包含构造器的正常完成，要么是抛出完成. 它用于获取应当用来创建派生自 obj 的新对象的构造器。如果从 obj 开始无法找到构造器的 %Symbol.species% 属性，则使用 defaultConstructor 作为构造器。 It performs the following steps when called:

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

7.3.23 EnumerableOwnProperties ( obj, kind )

The abstract operation EnumerableOwnProperties takes arguments obj (一个 Object，) and kind (key、value 或 key+value，) and returns 要么是包含 ECMAScript 语言值的 List 的正常完成，要么是抛出完成. It performs the following steps when called:

  1. 令 ownKeys 为 ? obj.[[OwnPropertyKeys]]()。
  2. 令 results 为一个新的空 List。
  3. 对 ownKeys 中的每个元素 key，执行
    1. 如果 key 是一个 String，那么
      1. 令 desc 为 ? obj.[[GetOwnProperty]](key)。
      2. 如果 desc 不是 undefined 且 desc.[[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 (一个函数对象，) and returns 要么是包含 Realm Record 的正常完成，要么是抛出完成. It performs the following steps when called:

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

步骤 4 仅会在 func 是不具有 [[Realm]] 内部槽的非标准函数异质对象时被执行到。

7.3.25 CopyDataProperties ( target, source, excludedItems )

The abstract operation CopyDataProperties takes arguments target (一个 Object，), source (一个 ECMAScript 语言值，), and excludedItems (一个属性键的 List，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 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 中的每个元素 e，执行
      1. 如果 SameValue(e, nextKey) 是 true，那么
        1. 将 excluded 设为 true。
    3. 如果 excluded 是 false，那么
      1. 令 desc 为 ? from.[[GetOwnProperty]](nextKey)。
      2. 如果 desc 不是 undefined 且 desc.[[Enumerable]] 是 true，那么
        1. 令 propValue 为 ? Get(from, nextKey)。
        2. 执行 ! CreateDataPropertyOrThrow(target, nextKey, propValue)。
  5. 返回 unused。
 Note

这里传入的 target 始终是一个新创建的对象，因此在抛出错误的情况下它不能被直接访问。

7.3.26 PrivateElementFind ( obj, privateName )

The abstract operation PrivateElementFind takes arguments obj (一个 Object，) and privateName (一个 Private Name，) and returns 一个 PrivateElement 或 empty. It performs the following steps when called:

  1. 如果 obj.[[PrivateElements]] 包含某个 PrivateElement pe，且 pe.[[Key]] 是 privateName，那么
    1. 返回 pe。
  2. 返回 empty。

7.3.27 PrivateFieldAdd ( obj, privateName, value )

The abstract operation PrivateFieldAdd takes arguments obj (一个 Object，), privateName (一个 Private Name，), and value (一个 ECMAScript 语言值，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. It performs the following steps when called:

  1. 如果宿主是网页浏览器，那么
    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 (一个 Object，) and method (一个 PrivateElement，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. It performs the following steps when called:

  1. 断言：method.[[Kind]] 是 method 或 accessor 之一。
  2. 如果宿主是网页浏览器，那么
    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 (一个 Object，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 它允许宿主环境阻止向特定宿主定义的异质对象添加私有元素。

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

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

该抽象操作只会被作为网页浏览器的 ECMAScript 宿主调用。

7.3.30 PrivateGet ( obj, privateName )

The abstract operation PrivateGet takes arguments obj (一个 Object，) and privateName (一个 Private Name，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. 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 (一个 Object，), privateName (一个 Private Name，), and value (一个 ECMAScript 语言值，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 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 (一个 Object，) and fieldRecord (一个 ClassFieldDefinition Record，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. 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, constructor )

The abstract operation InitializeInstanceElements takes arguments obj (一个 Object，) and constructor (一个 ECMAScript 函数对象或内建函数对象，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.3.34 AddValueToKeyedGroup ( groups, key, value )

The abstract operation AddValueToKeyedGroup takes arguments groups (一个 Record 的 List，这些 Record 具有 [[Key]]（一个 ECMAScript 语言值）和 [[Elements]]（一个 ECMAScript 语言值的 List）字段，), key (一个 ECMAScript 语言值，), and value (一个 ECMAScript 语言值，) 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 (一个 ECMAScript 语言值，), callback (一个 ECMAScript 语言值，), and keyCoercion (property 或 collection，) and returns 要么是包含 Record 的 List 的正常完成，这些 Record 具有 [[Key]]（一个 ECMAScript 语言值）和 [[Elements]]（一个 ECMAScript 语言值的 List）字段，要么是抛出完成. 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 (一个 ECMAScript 语言值，) and returns 要么是包含 Object 的正常完成，要么是抛出完成. 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 (一个 ECMAScript 语言值，), home (一个 Object，), propertyKey (一个属性键，), and value (一个 ECMAScript 语言值，) and returns 要么是包含 unused 的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.4 迭代器对象上的操作

参见公共迭代接口（27.1）。

7.4.1 Iterator Record

Iterator Record 是一种 Record 值，用于封装一个迭代器或异步迭代器及其 next 方法。

Iterator Record 具有 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 (一个 Object，) and returns 要么是包含 Iterator Record 的正常完成，要么是抛出完成. 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 (一个 ECMAScript 语言值，) and method (一个函数对象，) and returns 要么是包含 Iterator Record 的正常完成，要么是抛出完成. 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 (一个 ECMAScript 语言值，) and kind (sync 或 async，) and returns 要么是包含 Iterator Record 的正常完成，要么是抛出完成. 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 (一个 ECMAScript 语言值，) and primitiveHandling (iterate-string-primitives 或 reject-primitives，) and returns 要么是包含 Iterator Record 的正常完成，要么是抛出完成. 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 (一个 Iterator Record，) and optional argument value (一个 ECMAScript 语言值，) and returns 要么是包含 Object 的正常完成，要么是抛出完成. 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 是一个抛出完成，那么
    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 (一个 Object，) and returns 要么是包含 Boolean 的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.4.8 IteratorValue ( iteratorResult )

The abstract operation IteratorValue takes argument iteratorResult (一个 Object，) and returns 要么是包含 ECMAScript 语言值的正常完成，要么是抛出完成. It performs the following steps when called:

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

7.4.9 IteratorStep ( iteratorRecord )

The abstract operation IteratorStep takes argument iteratorRecord (一个 Iterator Record，) and returns 要么是包含 Object 或 done 的正常完成，要么是抛出完成. 它通过调用 iteratorRecord.[[NextMethod]] 向 iteratorRecord.[[Iterator]] 请求下一个值；如果迭代器已经到达末尾，则返回 done，否则如果存在下一个值，则返回 IteratorResult 对象。 It performs the following steps when called:

  1. 令 result 为 ? IteratorNext(iteratorRecord)。
  2. 令 done 为 Completion(IteratorComplete(result))。
  3. 如果 done 是一个抛出完成，那么
    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 (一个 Iterator Record，) and returns 要么是包含 ECMAScript 语言值或 done 的正常完成，要么是抛出完成. 它通过调用 iteratorRecord.[[NextMethod]] 向 iteratorRecord.[[Iterator]] 请求下一个值；如果迭代器已经到达末尾，则返回 done，否则如果存在下一个值，则返回 IteratorResult 对象中的 value。 It performs the following steps when called:

  1. 令 result 为 ? IteratorStep(iteratorRecord)。
  2. 如果 result 是 done，那么
    1. 返回 done。
  3. 令 value 为 Completion(IteratorValue(result))。
  4. 如果 value 是一个抛出完成，那么
    1. 将 iteratorRecord.[[Done]] 设为 true。
  5. 返回 ? value。

7.4.11 IteratorClose ( iteratorRecord, completion )

The abstract operation IteratorClose takes arguments iteratorRecord (一个 Iterator Record，) and completion (一个 Completion Record，) and returns 一个 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 是一个正常完成，那么
    1. 令 return 为 innerResult.[[Value]]。
    2. 如果 return 是 undefined，返回 ? completion。
    3. 将 innerResult 设为 Completion(Call(return, iterator))。
  5. 如果 completion 是一个抛出完成，返回 ? completion。
  6. 如果 innerResult 是一个抛出完成，返回 ? innerResult。
  7. 如果 innerResult.[[Value]] 不是一个 Object，抛出一个 TypeError 异常。
  8. 返回 ? completion。

7.4.12 IteratorCloseAll ( iters, completion )

The abstract operation IteratorCloseAll takes arguments iters (一个 Iterator Record 的 List，) and completion (一个 Completion Record，) and returns 一个 Completion Record. It performs the following steps when called:

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

7.4.13 IfAbruptCloseIterator ( value, iteratorRecord )

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

  1. IfAbruptCloseIterator(value, iteratorRecord)。

其含义等同于：

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

7.4.14 AsyncIteratorClose ( iteratorRecord, completion )

The abstract operation AsyncIteratorClose takes arguments iteratorRecord (一个 Iterator Record，) and completion (一个 Completion Record，) and returns 一个 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 是一个正常完成，那么
    1. 令 return 为 innerResult.[[Value]]。
    2. 如果 return 是 undefined，返回 ? completion。
    3. 将 innerResult 设为 Completion(Call(return, iterator))。
    4. 如果 innerResult 是一个正常完成，将 innerResult 设为 Completion(Await(innerResult.[[Value]]))。
  5. 如果 completion 是一个抛出完成，返回 ? completion。
  6. 如果 innerResult 是一个抛出完成，返回 ? innerResult。
  7. 如果 innerResult.[[Value]] 不是一个 Object，抛出一个 TypeError 异常。
  8. 返回 ? completion。

7.4.15 IfAbruptCloseAsyncIterator ( value, iteratorRecord )

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

  1. IfAbruptCloseAsyncIterator(value, iteratorRecord)。

其含义等同于：

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

7.4.16 CreateIteratorResultObject ( value, done )

The abstract operation CreateIteratorResultObject takes arguments value (一个 ECMAScript 语言值，) and done (一个 Boolean，) and returns 一个符合 IteratorResult 接口的 Object. 它创建一个符合 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.17 CreateListIteratorRecord ( list )

The abstract operation CreateListIteratorRecord takes argument list (一个 ECMAScript 语言值的 List，) and returns 一个 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

该列表迭代器对象永远不会被 ECMAScript 代码直接访问到。

7.4.18 IteratorToList ( iteratorRecord )

The abstract operation IteratorToList takes argument iteratorRecord (一个 Iterator Record，) and returns 要么是包含 ECMAScript 语言值的 List 的正常完成，要么是抛出完成. It performs the following steps when called:

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