27 控制抽象对象

27.1 迭代

27.1.1 通用迭代接口

接口是其关联值符合特定规范的一组属性键。任何对象只要提供了接口规范中描述的全部属性，就符合该接口。一个接口不由单独的对象来表示。可能存在许多独立实现且符合同一接口的对象。单个对象也可以同时符合多个接口。

27.1.1.1 Iterable 接口

iterable interface 包含 Table 80 中描述的属性：

Table 80: Iterable 接口所需属性
属性 值 要求
%Symbol.iterator% 一个返回迭代器对象的函数 返回的对象必须符合 iterator 接口。

27.1.1.2 Iterator 接口

实现 iterator interface 的对象必须包含 Table 81 中的属性。此类对象也可以实现 Table 82 中的可选属性。

Table 81: Iterator 接口所需属性
属性 值 要求
"next" 一个返回 IteratorResult 对象的函数 返回的对象必须符合 IteratorResult 接口。如果之前对该迭代器的 next 方法的一次调用返回了 "done" 属性为 true 的 IteratorResult 对象，则后续对此对象的所有 next 调用也应当返回 "done" 属性为 true 的 IteratorResult 对象。然而，该要求不强制执行。
Note 1

可以向 next 函数传递参数，但其含义与合法性取决于目标迭代器。for-of 语句及其他常见迭代器使用者不会传递任何参数，所以期望以这种方式使用的迭代器对象必须准备好在无参数情况下被调用。
Table 82: Iterator 接口可选属性
属性 值 要求
"return" 一个返回 IteratorResult 对象的函数 返回的对象必须符合 IteratorResult 接口。调用此方法通知迭代器对象调用方不打算再进行任何 next 方法调用。返回的 IteratorResult 对象通常具有 "done" 属性值为 true，并且 "value" 属性为传给 return 方法的参数值。然而，这一要求不强制执行。
"throw" 一个返回 IteratorResult 对象的函数 返回的对象必须符合 IteratorResult 接口。调用此方法通知迭代器对象调用方检测到错误条件。该参数可用于标识错误条件，通常会是一个异常对象。典型响应是 throw 传入的参数值。如果该方法未 throw，返回的 IteratorResult 对象通常具有 "done" 属性值为 true。
Note 2

通常这些方法的调用方在调用前应检查其是否存在。包括 for-of、yield* 和数组解构在内的某些 ECMAScript 语言特性会在进行存在性检查后调用这些方法。大多数接受 iterable 对象作为参数的 ECMAScript 库函数也会有条件地调用它们。

27.1.1.3 Async Iterable 接口

async iterable interface 包含 Table 83 中描述的属性：

Table 83: Async Iterable 接口所需属性
属性 值 要求
%Symbol.asyncIterator% 一个返回 async 迭代器对象的函数 返回的对象必须符合 async iterator 接口。

27.1.1.4 Async Iterator 接口

实现 async iterator interface 的对象必须包含 Table 84 中的属性。此类对象也可以实现 Table 85 中的属性。

Table 84: Async Iterator 接口所需属性
属性 值 要求
"next" 一个返回 Promise（兑现为 IteratorResult 对象）的函数

返回的 promise 在兑现时，必须以符合 IteratorResult 接口的对象兑现。如果之前对某 async 迭代器的 next 方法的一次调用返回了一个其 "done" 属性为 true 的 IteratorResult 对象的 promise，则后续对该对象的所有 next 调用也应返回 "done" 属性为 true 的 IteratorResult 对象的 promise。然而，该要求不强制执行。

另外，作为兑现值的 IteratorResult 对象的 "value" 属性的值应当不是一个 promise（或 “thenable”）。不过，这一要求同样不强制执行。
Note 1

可以向 next 函数传递参数，但其解释与有效性取决于目标 async 迭代器。for-await-of 语句及其他常见 async 迭代器使用者不会传递任何参数，因此期望这样使用的 async 迭代器对象必须准备好在无参数情况下被调用。
Table 85: Async Iterator 接口可选属性
属性 值 要求
"return" 一个返回 Promise（兑现为 IteratorResult 对象）的函数

返回的 promise 在兑现时，必须以符合 IteratorResult 接口的对象兑现。调用此方法通知 async 迭代器对象调用方不打算再对该 async 迭代器进行更多 next 调用。返回的 promise 将兑现为 IteratorResult 对象，该对象通常具有 "done" 属性值为 true，以及 "value" 属性为传给 return 方法的参数值。然而，这一要求不强制执行。

另外，作为兑现值的 IteratorResult 对象的 "value" 属性应当不是一个 promise（或 “thenable”）。如果参数值按典型方式使用，且其为一个被拒绝的 promise，则应返回一个以相同原因拒绝的 promise；如果其为一个已兑现的 promise，则其兑现值应作为返回 promise 的 IteratorResult 对象的 "value" 属性。然而，这些要求同样不强制执行。
"throw" 一个返回 Promise（兑现为 IteratorResult 对象）的函数

返回的 promise 在兑现时，必须以符合 IteratorResult 接口的对象兑现。调用此方法通知 async 迭代器对象调用方已检测到错误条件。参数可用于标识该错误条件，并且通常为一个异常对象。典型响应是返回一个以该参数值拒绝的被拒绝 promise。

如果返回的 promise 被兑现，IteratorResult 对象兑现值通常具有 "done" 属性值为 true。此外，它应当具有 "value" 属性，其值不是一个 promise（或 “thenable”），但该要求不强制执行。
Note 2

通常这些方法的调用方在调用前应检查其是否存在。包括 for-await-of 和 yield* 在内的某些 ECMAScript 语言特性会在进行存在性检查后调用这些方法。

27.1.1.5 IteratorResult 接口

IteratorResult interface 包含 Table 86 中列出的属性：

Table 86: IteratorResult 接口属性
属性 值 要求
"done" 一个 Boolean 这是迭代器 next 方法调用的结果状态。如果已到达迭代器末尾，"done" 为 true。如果未到达末尾，"done" 为 false 且存在一个可用的值。如果不存在（自有或继承的）"done" 属性，则视为其值为 false。
"value" 一个 ECMAScript 语言值 如果 done 为 false，这是当前迭代元素值。如果 done 为 true，这是迭代器的返回值（如果提供）。若迭代器没有返回值，"value" 为 undefined。在此情况下，如果对象未继承显式的 "value" 属性，则可从符合规范的对象中省略该 "value" 属性。

27.1.2 迭代器辅助（Iterator Helper）对象

Iterator Helper object 是一个普通对象，表示对某个特定源迭代器对象的惰性转换。Iterator Helper 对象没有具名构造函数。相反，它们通过调用 Iterator 实例对象的特定方法创建。

27.1.2.1 %IteratorHelperPrototype% 对象

%IteratorHelperPrototype% 对象：

27.1.2.1.1 %IteratorHelperPrototype%.next ( )

  1. Return ? GeneratorResume(this value, undefined, "Iterator Helper").

27.1.2.1.2 %IteratorHelperPrototype%.return ( )

  1. 令 O 为 this 值。
  2. 执行 ? RequireInternalSlot(O, [[UnderlyingIterator]]).
  3. 断言：O 具有 [[GeneratorState]] 内部槽。
  4. 若 O.[[GeneratorState]] 为 suspended-start，则
    1. 设 O.[[GeneratorState]] 为 completed。
    2. 注：一旦生成器进入 completed 状态，它将不再离开该状态，且其关联的执行上下文不再被恢复。与 O 关联的任何执行状态此时都可被丢弃。
    3. 执行 ? IteratorClose(O.[[UnderlyingIterator]], NormalCompletion(unused)).
    4. 返回 CreateIteratorResultObject(undefined, true)。
  5. 令 C 为 ReturnCompletion(undefined)。
  6. 返回 ? GeneratorResumeAbrupt(O, C, "Iterator Helper").

27.1.2.1.3 %IteratorHelperPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串值 "Iterator Helper"。

此属性具有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.1.3 迭代器对象

27.1.3.1 Iterator 构造函数

Iterator 构造函数：

  • 是 %Iterator%。
  • 是全局对象 "Iterator" 属性的初始值。
  • 被设计为可子类化。它可用作类定义的 extends 子句的值。

27.1.3.1.1 Iterator ( )

当调用此函数时，执行以下步骤：

  1. 若 NewTarget 为 undefined 或为活动函数对象，抛出一个 TypeError 异常。
  2. 返回 ? OrdinaryCreateFromConstructor(NewTarget, "%Iterator.prototype%")。

27.1.3.2 Iterator 构造函数的属性

Iterator 构造函数：

27.1.3.2.1 Iterator.from ( O )

  1. 令 iteratorRecord 为 ? GetIteratorFlattenable(O, iterate-string-primitives)。
  2. 令 hasInstance 为 ? OrdinaryHasInstance(%Iterator%, iteratorRecord.[[Iterator]])。
  3. 若 hasInstance 为 true，则
    1. 返回 iteratorRecord.[[Iterator]]。
  4. 令 wrapper 为 OrdinaryObjectCreate(%WrapForValidIteratorPrototype%, « [[Iterated]] »)。
  5. 设 wrapper.[[Iterated]] 为 iteratorRecord。
  6. 返回 wrapper。

27.1.3.2.1.1 %WrapForValidIteratorPrototype% 对象

%WrapForValidIteratorPrototype% 对象：

27.1.3.2.1.1.1 %WrapForValidIteratorPrototype%.next ( )

  1. 令 O 为 this 值。
  2. 执行 ? RequireInternalSlot(O, [[Iterated]]).
  3. 令 iteratorRecord 为 O.[[Iterated]]。
  4. 返回 ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]])。

27.1.3.2.1.1.2 %WrapForValidIteratorPrototype%.return ( )

  1. 令 O 为 this 值。
  2. 执行 ? RequireInternalSlot(O, [[Iterated]]).
  3. 令 iterator 为 O.[[Iterated]].[[Iterator]]。
  4. 断言：iterator 是一个 Object。
  5. 令 returnMethod 为 ? GetMethod(iterator, "return")。
  6. 若 returnMethod 为 undefined，则
    1. 返回 CreateIteratorResultObject(undefined, true)。
  7. 返回 ? Call(returnMethod, iterator)。

27.1.3.2.2 Iterator.prototype

Iterator.prototype 的初始值是 Iterator 原型对象。

此属性具有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

27.1.4 Iterator 原型对象的属性

Iterator 原型对象：

Note

本规范中所有实现 iterator 接口的对象也都从 %Iterator.prototype% 继承。ECMAScript 代码也可以定义从 %Iterator.prototype% 继承的对象。%Iterator.prototype% 为可对所有迭代器对象适用的额外方法提供一个位置。

以下表达式是 ECMAScript 代码访问 %Iterator.prototype% 对象的一种方式：

Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))

27.1.4.1 Iterator.prototype.constructor

Iterator.prototype.constructor 是一个访问器属性，具有特性 { [[Enumerable]]: false, [[Configurable]]: true }。其 [[Get]] 和 [[Set]] 属性定义如下：

27.1.4.1.1 get Iterator.prototype.constructor

[[Get]] 属性的值是一个不需要参数的内置函数。被调用时执行以下步骤：

  1. 返回 %Iterator%。

27.1.4.1.2 set Iterator.prototype.constructor

[[Set]] 属性的值是一个接受参数 v 的内置函数。被调用时执行以下步骤：

  1. 执行 ? SetterThatIgnoresPrototypeProperties(this value, %Iterator.prototype%, "constructor", v)。
  2. 返回 undefined。
 Note

与大多数内置原型上的 "constructor" 属性不同，出于 web 兼容性原因，此属性必须是访问器。

27.1.4.2 Iterator.prototype.drop ( limit )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 令 numLimit 为 Completion(ToNumber(limit))。
  5. IfAbruptCloseIterator(numLimit, iterated)。
  6. 若 numLimit 为 NaN，则
    1. 令 error 为 ThrowCompletion(一个新建的 RangeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  7. 令 integerLimit 为 ! ToIntegerOrInfinity(numLimit)。
  8. 若 integerLimit < 0，则
    1. 令 error 为 ThrowCompletion(一个新建的 RangeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  9. 设 iterated 为 ? GetIteratorDirect(O)。
  10. 令 closure 为一个新的无参数抽象闭包，捕获 iterated 与 integerLimit，调用时执行：
    1. 令 remaining 为 integerLimit。
    2. 重复，当 remaining > 0，
      1. 若 remaining ≠ +∞，则
        1. 设 remaining 为 remaining - 1。
      2. 令 next 为 ? IteratorStep(iterated)。
      3. 若 next 为 done，返回 ReturnCompletion(undefined)。
    3. 重复，
      1. 令 value 为 ? IteratorStepValue(iterated)。
      2. 若 value 为 done，返回 ReturnCompletion(undefined)。
      3. 令 completion 为 Completion(Yield(value))。
      4. IfAbruptCloseIterator(completion, iterated)。
  11. 令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterator]] »)。
  12. 设 result.[[UnderlyingIterator]] 为 iterated。
  13. 返回 result。

27.1.4.3 Iterator.prototype.every ( predicate )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 counter 为 0。
  7. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 true。
    3. 令 result 为 Completion(Call(predicate, undefined, « value, 𝔽(counter) »))。
    4. IfAbruptCloseIterator(result, iterated)。
    5. 若 ToBoolean(result) 为 false，返回 ? IteratorClose(iterated, NormalCompletion(false))。
    6. 设 counter 为 counter + 1。

27.1.4.4 Iterator.prototype.filter ( predicate )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 closure 为一个新的无参数抽象闭包，捕获 iterated 与 predicate，调用时执行：
    1. 令 counter 为 0。
    2. 重复，
      1. 令 value 为 ? IteratorStepValue(iterated)。
      2. 若 value 为 done，返回 ReturnCompletion(undefined)。
      3. 令 selected 为 Completion(Call(predicate, undefined, « value, 𝔽(counter) »))。
      4. IfAbruptCloseIterator(selected, iterated)。
      5. 若 ToBoolean(selected) 为 true，则
        1. 令 completion 为 Completion(Yield(value))。
        2. IfAbruptCloseIterator(completion, iterated)。
      6. 设 counter 为 counter + 1。
  7. 令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterator]] »)。
  8. 设 result.[[UnderlyingIterator]] 为 iterated。
  9. 返回 result。

27.1.4.5 Iterator.prototype.find ( predicate )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 counter 为 0。
  7. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 undefined。
    3. 令 result 为 Completion(Call(predicate, undefined, « value, 𝔽(counter) »))。
    4. IfAbruptCloseIterator(result, iterated)。
    5. 若 ToBoolean(result) 为 true，返回 ? IteratorClose(iterated, NormalCompletion(value))。
    6. 设 counter 为 counter + 1。

27.1.4.6 Iterator.prototype.flatMap ( mapper )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(mapper) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 closure 为一个新的无参数抽象闭包，捕获 iterated 与 mapper，调用时执行：
    1. 令 counter 为 0。
    2. 重复，
      1. 令 value 为 ? IteratorStepValue(iterated)。
      2. 若 value 为 done，返回 ReturnCompletion(undefined)。
      3. 令 mapped 为 Completion(Call(mapper, undefined, « value, 𝔽(counter) »))。
      4. IfAbruptCloseIterator(mapped, iterated)。
      5. 令 innerIterator 为 Completion(GetIteratorFlattenable(mapped, reject-primitives))。
      6. IfAbruptCloseIterator(innerIterator, iterated)。
      7. 令 innerAlive 为 true。
      8. 重复，当 innerAlive 为 true，
        1. 令 innerValue 为 Completion(IteratorStepValue(innerIterator))。
        2. IfAbruptCloseIterator(innerValue, iterated)。
        3. 若 innerValue 为 done，则
          1. 设 innerAlive 为 false。
        4. 否则，
          1. 令 completion 为 Completion(Yield(innerValue))。
          2. 若 completion 是一个 abrupt completion，则
            1. 令 backupCompletion 为 Completion(IteratorClose(innerIterator, completion))。
            2. IfAbruptCloseIterator(backupCompletion, iterated)。
            3. 返回 ? IteratorClose(iterated, completion)。
      9. 设 counter 为 counter + 1。
  7. 令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterator]] »)。
  8. 设 result.[[UnderlyingIterator]] 为 iterated。
  9. 返回 result。

27.1.4.7 Iterator.prototype.forEach ( procedure )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(procedure) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 counter 为 0。
  7. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 undefined。
    3. 令 result 为 Completion(Call(procedure, undefined, « value, 𝔽(counter) »))。
    4. IfAbruptCloseIterator(result, iterated)。
    5. 设 counter 为 counter + 1。

27.1.4.8 Iterator.prototype.map ( mapper )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(mapper) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 closure 为一个新的无参数抽象闭包，捕获 iterated 与 mapper，调用时执行：
    1. 令 counter 为 0。
    2. 重复，
      1. 令 value 为 ? IteratorStepValue(iterated)。
      2. 若 value 为 done，返回 ReturnCompletion(undefined)。
      3. 令 mapped 为 Completion(Call(mapper, undefined, « value, 𝔽(counter) »))。
      4. IfAbruptCloseIterator(mapped, iterated)。
      5. 令 completion 为 Completion(Yield(mapped))。
      6. IfAbruptCloseIterator(completion, iterated)。
      7. 设 counter 为 counter + 1。
  7. 令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterator]] »)。
  8. 设 result.[[UnderlyingIterator]] 为 iterated。
  9. 返回 result。

27.1.4.9 Iterator.prototype.reduce ( reducer [ , initialValue ] )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(reducer) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 若 initialValue 不存在，则
    1. 令 accumulator 为 ? IteratorStepValue(iterated)。
    2. 若 accumulator 为 done，抛出一个 TypeError 异常。
    3. 令 counter 为 1。
  7. 否则，
    1. 令 accumulator 为 initialValue。
    2. 令 counter 为 0。
  8. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 accumulator。
    3. 令 result 为 Completion(Call(reducer, undefined, « accumulator, value, 𝔽(counter) »))。
    4. IfAbruptCloseIterator(result, iterated)。
    5. 设 accumulator 为 result。
    6. 设 counter 为 counter + 1。

27.1.4.10 Iterator.prototype.some ( predicate )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 若 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 设 iterated 为 ? GetIteratorDirect(O)。
  6. 令 counter 为 0。
  7. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 false。
    3. 令 result 为 Completion(Call(predicate, undefined, « value, 𝔽(counter) »))。
    4. IfAbruptCloseIterator(result, iterated)。
    5. 若 ToBoolean(result) 为 true，返回 ? IteratorClose(iterated, NormalCompletion(true))。
    6. 设 counter 为 counter + 1。

27.1.4.11 Iterator.prototype.take ( limit )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: O, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 令 numLimit 为 Completion(ToNumber(limit))。
  5. IfAbruptCloseIterator(numLimit, iterated)。
  6. 若 numLimit 为 NaN，则
    1. 令 error 为 ThrowCompletion(一个新建的 RangeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  7. 令 integerLimit 为 ! ToIntegerOrInfinity(numLimit)。
  8. 若 integerLimit < 0，则
    1. 令 error 为 ThrowCompletion(一个新建的 RangeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  9. 设 iterated 为 ? GetIteratorDirect(O)。
  10. 令 closure 为一个新的无参数抽象闭包，捕获 iterated 与 integerLimit，调用时执行：
    1. 令 remaining 为 integerLimit。
    2. 重复，
      1. 若 remaining = 0，则
        1. 返回 ? IteratorClose(iterated, ReturnCompletion(undefined))。
      2. 若 remaining ≠ +∞，则
        1. 设 remaining 为 remaining - 1。
      3. 令 value 为 ? IteratorStepValue(iterated)。
      4. 若 value 为 done，返回 ReturnCompletion(undefined)。
      5. 令 completion 为 Completion(Yield(value))。
      6. IfAbruptCloseIterator(completion, iterated)。
  11. 令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterator]] »)。
  12. 设 result.[[UnderlyingIterator]] 为 iterated。
  13. 返回 result。

27.1.4.12 Iterator.prototype.toArray ( )

当调用此方法时，执行以下步骤：

  1. 令 O 为 this 值。
  2. 如果 O 不是一个 Object，抛出一个 TypeError 异常。
  3. 令 iterated 为 ? GetIteratorDirect(O)。
  4. 令 items 为一个新的空 List。
  5. 重复，
    1. 令 value 为 ? IteratorStepValue(iterated)。
    2. 若 value 为 done，返回 CreateArrayFromList(items)。
    3. 将 value 追加至 items。

27.1.4.13 Iterator.prototype [ %Symbol.iterator% ] ( )

当调用此函数时，执行以下步骤：

  1. 返回 this 值。

此函数 "name" 属性的值为 "[Symbol.iterator]"。

27.1.4.14 Iterator.prototype [ %Symbol.toStringTag% ]

Iterator.prototype[%Symbol.toStringTag%] 是一个访问器属性，具有特性 { [[Enumerable]]: false, [[Configurable]]: true }。其 [[Get]] 和 [[Set]] 属性定义如下：

27.1.4.14.1 get Iterator.prototype [ %Symbol.toStringTag% ]

[[Get]] 属性的值是一个不需要参数的内置函数。被调用时执行以下步骤：

  1. 返回 "Iterator"。

27.1.4.14.2 set Iterator.prototype [ %Symbol.toStringTag% ]

[[Set]] 属性的值是一个接受参数 v 的内置函数。被调用时执行以下步骤：

  1. 执行 ? SetterThatIgnoresPrototypeProperties(this value, %Iterator.prototype%, %Symbol.toStringTag%, v)。
  2. 返回 undefined。
 Note

与大多数内置原型上的 %Symbol.toStringTag% 属性不同，出于 web 兼容性原因，此属性必须是访问器。

27.1.5 %AsyncIteratorPrototype% 对象

%AsyncIteratorPrototype% 对象：

Note

本规范中所有实现 async iterator 接口的对象也都从 %AsyncIteratorPrototype% 继承。ECMAScript 代码也可以定义从 %AsyncIteratorPrototype% 继承的对象。%AsyncIteratorPrototype% 对象为可对所有 async 迭代器对象适用的额外方法提供一个位置。

27.1.5.1 %AsyncIteratorPrototype% [ %Symbol.asyncIterator% ] ( )

当调用此函数时，执行以下步骤：

  1. 返回 this 值。

此函数 "name" 属性的值为 "[Symbol.asyncIterator]"。

27.1.6 Async-from-Sync 迭代器对象

Async-from-Sync Iterator object 是一个将特定同步迭代器适配为 async 迭代器的对象。Async-from-Sync Iterator 对象永远不会被 ECMAScript 代码直接访问。它们没有具名构造函数，而是按需通过 CreateAsyncFromSyncIterator 抽象操作创建。

27.1.6.1 CreateAsyncFromSyncIterator ( syncIteratorRecord )

The abstract operation CreateAsyncFromSyncIterator takes argument syncIteratorRecord (an Iterator Record) and returns an Iterator Record. 用于从一个同步 Iterator Record 创建一个 async Iterator Record。 It performs the following steps when called:

  1. 令 asyncIterator 为 OrdinaryObjectCreate(%AsyncFromSyncIteratorPrototype%, « [[SyncIteratorRecord]] »)。
  2. 设 asyncIterator.[[SyncIteratorRecord]] 为 syncIteratorRecord。
  3. 令 nextMethod 为 ! Get(asyncIterator, "next")。
  4. 令 iteratorRecord 为 Iterator Record { [[Iterator]]: asyncIterator, [[NextMethod]]: nextMethod, [[Done]]: false }。
  5. 返回 iteratorRecord。

27.1.6.2 %AsyncFromSyncIteratorPrototype% 对象

%AsyncFromSyncIteratorPrototype% 对象：

  • 具有所有 Async-from-Sync Iterator 对象继承的属性。
  • 是一个普通对象。
  • 具有一个 [[Prototype]] 内部槽，其值为 %AsyncIteratorPrototype%。
  • 永远不会被 ECMAScript 代码直接访问。
  • 具有以下属性：

27.1.6.2.1 %AsyncFromSyncIteratorPrototype%.next ( [ value ] )

  1. 令 O 为 this 值。
  2. 断言：O 是一个具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 O.[[SyncIteratorRecord]]。
  5. 若 value 存在，则
    1. 令 result 为 Completion(IteratorNext(syncIteratorRecord, value))。
  6. 否则，
    1. 令 result 为 Completion(IteratorNext(syncIteratorRecord))。
  7. IfAbruptRejectPromise(result, promiseCapability)。
  8. 返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true)。

27.1.6.2.2 %AsyncFromSyncIteratorPrototype%.return ( [ value ] )

  1. 令 O 为 this 值。
  2. 断言：O 是一个具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 O.[[SyncIteratorRecord]]。
  5. 令 syncIterator 为 syncIteratorRecord.[[Iterator]]。
  6. 令 return 为 Completion(GetMethod(syncIterator, "return")).
  7. IfAbruptRejectPromise(return, promiseCapability)。
  8. 若 return 为 undefined，则
    1. 令 iteratorResult 为 CreateIteratorResultObject(value, true)。
    2. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »)。
    3. 返回 promiseCapability.[[Promise]]。
  9. 若 value 存在，则
    1. 令 result 为 Completion(Call(return, syncIterator, « value »))。
  10. 否则，
    1. 令 result 为 Completion(Call(return, syncIterator))。
  11. IfAbruptRejectPromise(result, promiseCapability)。
  12. 若 result 不是一个 Object，则
    1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « 一个新建的 TypeError 对象 »)。
    2. 返回 promiseCapability.[[Promise]]。
  13. 返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, false)。

27.1.6.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [ value ] )

Note
在本规范中，value 总是被提供，但为与 %AsyncFromSyncIteratorPrototype%.return ( [ value ] ) 保持一致而保留为可选。
  1. 令 O 为 this 值。
  2. 断言：O 是一个具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 O.[[SyncIteratorRecord]]。
  5. 令 syncIterator 为 syncIteratorRecord.[[Iterator]]。
  6. 令 throw 为 Completion(GetMethod(syncIterator, "throw"))。
  7. IfAbruptRejectPromise(throw, promiseCapability)。
  8. 若 throw 为 undefined，则
    1. 注：如果 syncIterator 没有 throw 方法，在我们拒绝该 capability 前关闭它以便其有机会清理。
    2. 令 closeCompletion 为 NormalCompletion(empty)。
    3. 令 result 为 Completion(IteratorClose(syncIteratorRecord, closeCompletion))。
    4. IfAbruptRejectPromise(result, promiseCapability)。
    5. 注：下一步抛出一个 TypeError 以指示存在协议违规：syncIterator 没有 throw 方法。
    6. 注：如果关闭 syncIterator 不抛出，则忽略该操作的结果，即使其产生了一个被拒绝的 promise。
    7. 执行 ! Call(promiseCapability.[[Reject]], undefined, « 一个新建的 TypeError 对象 »)。
    8. 返回 promiseCapability.[[Promise]]。
  9. 若 value 存在，则
    1. 令 result 为 Completion(Call(throw, syncIterator, « value »))。
  10. 否则，
    1. 令 result 为 Completion(Call(throw, syncIterator))。
  11. IfAbruptRejectPromise(result, promiseCapability)。
  12. 若 result 不是一个 Object，则
    1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « 一个新建的 TypeError 对象 »)。
    2. 返回 promiseCapability.[[Promise]]。
  13. 返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true)。

27.1.6.3 Async-from-Sync 迭代器实例的属性

Async-from-Sync 迭代器实例是从 %AsyncFromSyncIteratorPrototype% 内在对象继承属性的普通对象。它们最初以 Table 87 中列出的内部槽创建。

Table 87: Async-from-Sync 迭代器实例的内部槽
内部槽 类型 描述
[[SyncIteratorRecord]] an Iterator Record 表示正在被适配的原始同步迭代器。

27.1.6.4 AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection )

The abstract operation AsyncFromSyncIteratorContinuation takes arguments result (an Object), promiseCapability (a PromiseCapability Record for an intrinsic %Promise%), syncIteratorRecord (an Iterator Record), and closeOnRejection (a Boolean) and returns a Promise. It performs the following steps when called:

  1. 注：由于 promiseCapability 来自内在 %Promise%，下面使用 IfAbruptRejectPromise 所导致对 promiseCapability.[[Reject]] 的调用保证不会抛出。
  2. 令 done 为 Completion(IteratorComplete(result))。
  3. IfAbruptRejectPromise(done, promiseCapability)。
  4. 令 value 为 Completion(IteratorValue(result))。
  5. IfAbruptRejectPromise(value, promiseCapability)。
  6. 令 valueWrapper 为 Completion(PromiseResolve(%Promise%, value))。
  7. 若 valueWrapper 是一个 abrupt completion，done 为 false，且 closeOnRejection 为 true，则
    1. 设 valueWrapper 为 Completion(IteratorClose(syncIteratorRecord, valueWrapper))。
  8. IfAbruptRejectPromise(valueWrapper, promiseCapability)。
  9. 令 unwrap 为一个新的具有参数 (v) 且捕获 done 的抽象闭包，调用时执行：
    1. 返回 CreateIteratorResultObject(v, done)。
  10. 令 onFulfilled 为 CreateBuiltinFunction(unwrap, 1, "", « »)。
  11. 注：onFulfilled 用于处理 IteratorResult 对象的 "value" 属性，以便在其值为 promise 时等待，并将结果重新打包为一个新的“解包后的” IteratorResult 对象。
  12. 若 done 为 true，或 closeOnRejection 为 false，则
    1. 令 onRejected 为 undefined。
  13. 否则，
    1. 令 closeIterator 为一个新的具有参数 (error) 且捕获 syncIteratorRecord 的抽象闭包，调用时执行：
      1. 返回 ? IteratorClose(syncIteratorRecord, ThrowCompletion(error))。
    2. 令 onRejected 为 CreateBuiltinFunction(closeIterator, 1, "", « »)。
    3. 注：onRejected 用于在其产生的 IteratorResult 对象的 "value" 属性为一个被拒绝的 promise 时关闭迭代器。
  14. 执行 PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability)。
  15. 返回 promiseCapability.[[Promise]]。

27.2 Promise 对象

Promise 是一个对象，用作延迟（且可能是异步）计算最终结果的占位符。

任一 Promise 处于三个互斥状态之一：fulfilled、rejected 和 pending：

  • 当对一个 promise p 执行 p.then(f, r) 会立即入列一个调用函数 f 的 Job 时，p 为 fulfilled。
  • 当对一个 promise p 执行 p.then(f, r) 会立即入列一个调用函数 r 的 Job 时，p 为 rejected。
  • 当一个 promise 既不是 fulfilled 也不是 rejected 时，它是 pending。

若一个 promise 不是 pending（即已 fulfilled 或 rejected），则称其为 settled。

一个 promise 若已 settled 或被“锁定”与另一个 promise 的状态匹配，则称其为 resolved。试图 resolve 或 reject 一个已 resolved 的 promise 不产生任何效果。一个 promise 若未 resolved 则为 unresolved。未 resolved 的 promise 始终处于 pending 状态。一个已 resolved 的 promise 可能是 pending、fulfilled 或 rejected。

27.2.1 Promise 抽象操作

27.2.1.1 PromiseCapability 记录

PromiseCapability Record 是一个 Record 值，用来封装一个 Promise 或类 Promise 对象及其可用于 resolve 或 reject 该 promise 的函数。PromiseCapability 记录由 NewPromiseCapability 抽象操作产生。

PromiseCapability 记录具有 Table 88 中列出的字段。

Table 88: PromiseCapability Record 字段
字段名 值 含义
[[Promise]] 一个 Object 可用作 promise 的对象。
[[Resolve]] 一个函数对象 用于 resolve 给定 promise 的函数。
[[Reject]] 一个函数对象 用于 reject 给定 promise 的函数。

27.2.1.1.1 IfAbruptRejectPromise ( value, capability )

IfAbruptRejectPromise 是一组使用 PromiseCapability Record 的算法步骤的简写。形如：

  1. IfAbruptRejectPromise(value, capability)。

等价于：

  1. 断言：value 是一个 Completion Record。
  2. 若 value 是一个 abrupt completion，则
    1. 执行 ? Call(capability.[[Reject]], undefined, « value.[[Value]] »)。
    2. 返回 capability.[[Promise]]。
  3. 否则，
    1. 设 value 为 ! value。

27.2.1.2 PromiseReaction 记录

PromiseReaction Record 是一个 Record 值，用来存储当 promise 以给定值 resolved 或 rejected 时应如何响应的信息。PromiseReaction 记录由 PerformPromiseThen 抽象操作创建，并由 NewPromiseReactionJob 返回的抽象闭包使用。

PromiseReaction 记录具有 Table 89 中列出的字段。

Table 89: PromiseReaction Record 字段
字段名 值 含义
[[Capability]] 一个 PromiseCapability Record 或 undefined 该记录为其提供 reaction 处理器的 promise 的能力集合。
[[Type]] fulfill 或 reject 当 [[Handler]] 为 empty 时用于区分针对不同完成类型的行为。
[[Handler]] 一个 JobCallback Record 或 empty 应对传入值执行的函数，其返回值决定派生 promise 的后续行为。若 [[Handler]] 为 empty，则基于 [[Type]] 的函数将被使用。

27.2.1.3 CreateResolvingFunctions ( promise )

The abstract operation CreateResolvingFunctions takes argument promise (a Promise) and returns 一个具有字段 [[Resolve]] (函数对象) 与 [[Reject]] (函数对象) 的 Record. It performs the following steps when called:

  1. 令 alreadyResolved 为 Record { [[Value]]: false }。
  2. 令 stepsResolve 为 Promise Resolve 函数 中定义的算法步骤。
  3. 令 lengthResolve 为 Promise Resolve 函数 中函数定义的非可选参数数量。
  4. 令 resolve 为 CreateBuiltinFunction(stepsResolve, lengthResolve, "", « [[Promise]], [[AlreadyResolved]] »)。
  5. 设 resolve.[[Promise]] 为 promise。
  6. 设 resolve.[[AlreadyResolved]] 为 alreadyResolved。
  7. 令 stepsReject 为 Promise Reject 函数 中定义的算法步骤。
  8. 令 lengthReject 为 Promise Reject 函数 中函数定义的非可选参数数量。
  9. 令 reject 为 CreateBuiltinFunction(stepsReject, lengthReject, "", « [[Promise]], [[AlreadyResolved]] »)。
  10. 设 reject.[[Promise]] 为 promise。
  11. 设 reject.[[AlreadyResolved]] 为 alreadyResolved。
  12. 返回 Record { [[Resolve]]: resolve, [[Reject]]: reject }。

27.2.1.3.1 Promise Reject 函数

Promise reject 函数是一个匿名内置函数，具有 [[Promise]] 与 [[AlreadyResolved]] 内部槽。

当以参数 reason 调用一个 promise reject 函数时，执行以下步骤：

  1. 令 F 为活动函数对象。
  2. 断言：F 具有一个值为 Object 的 [[Promise]] 内部槽。
  3. 令 promise 为 F.[[Promise]]。
  4. 令 alreadyResolved 为 F.[[AlreadyResolved]]。
  5. 若 alreadyResolved.[[Value]] 为 true，返回 undefined。
  6. 设 alreadyResolved.[[Value]] 为 true。
  7. 执行 RejectPromise(promise, reason)。
  8. 返回 undefined。

Promise reject 函数的 "length" 属性为 1𝔽。

27.2.1.3.2 Promise Resolve 函数

Promise resolve 函数是一个匿名内置函数，具有 [[Promise]] 与 [[AlreadyResolved]] 内部槽。

当以参数 resolution 调用一个 promise resolve 函数时，执行以下步骤：

  1. 令 F 为活动函数对象。
  2. 断言：F 具有一个值为 Object 的 [[Promise]] 内部槽。
  3. 令 promise 为 F.[[Promise]]。
  4. 令 alreadyResolved 为 F.[[AlreadyResolved]]。
  5. 若 alreadyResolved.[[Value]] 为 true，返回 undefined。
  6. 设 alreadyResolved.[[Value]] 为 true。
  7. 若 SameValue(resolution, promise) 为 true，则
    1. 令 selfResolutionError 为一个新建的 TypeError 对象。
    2. 执行 RejectPromise(promise, selfResolutionError)。
    3. 返回 undefined。
  8. 若 resolution 不是一个 Object，则
    1. 执行 FulfillPromise(promise, resolution)。
    2. 返回 undefined。
  9. 令 then 为 Completion(Get(resolution, "then"))。
  10. 若 then 是一个 abrupt completion，则
    1. 执行 RejectPromise(promise, then.[[Value]])。
    2. 返回 undefined。
  11. 令 thenAction 为 then.[[Value]]。
  12. 若 IsCallable(thenAction) 为 false，则
    1. 执行 FulfillPromise(promise, resolution)。
    2. 返回 undefined。
  13. 令 thenJobCallback 为 HostMakeJobCallback(thenAction)。
  14. 令 job 为 NewPromiseResolveThenableJob(promise, resolution, thenJobCallback)。
  15. 执行 HostEnqueuePromiseJob(job.[[Job]], job.[[Realm]])。
  16. 返回 undefined。

Promise resolve 函数的 "length" 属性为 1𝔽。

27.2.1.4 FulfillPromise ( promise, value )

The abstract operation FulfillPromise takes arguments promise (a Promise) and value (an ECMAScript language value) and returns unused. It performs the following steps when called:

  1. 断言：promise.[[PromiseState]] 为 pending。
  2. 令 reactions 为 promise.[[PromiseFulfillReactions]]。
  3. 设 promise.[[PromiseResult]] 为 value。
  4. 设 promise.[[PromiseFulfillReactions]] 为 undefined。
  5. 设 promise.[[PromiseRejectReactions]] 为 undefined。
  6. 设 promise.[[PromiseState]] 为 fulfilled。
  7. 执行 TriggerPromiseReactions(reactions, value)。
  8. 返回 unused。

27.2.1.5 NewPromiseCapability ( C )

The abstract operation NewPromiseCapability takes argument C (an ECMAScript language value) and returns 正常完成（含一个 PromiseCapability Record）或抛出完成. 尝试以与内置 Promise 构造函数相同的方式使用 C 作为构造器来创建一个 promise，并提取其 resolve 与 reject 函数。该 promise 及其 resolve 与 reject 函数用于初始化一个新的 PromiseCapability Record。 It performs the following steps when called:

  1. 若 IsConstructor(C) 为 false，抛出一个 TypeError 异常。
  2. 注：假定 C 是一个支持 Promise 构造函数参数约定的构造函数（见 27.2.3.1）。
  3. 令 resolvingFunctions 为 Record { [[Resolve]]: undefined, [[Reject]]: undefined }。
  4. 令 executorClosure 为一个具有参数 (resolve, reject) 且捕获 resolvingFunctions 的新抽象闭包，调用时执行：
    1. 若 resolvingFunctions.[[Resolve]] 不为 undefined，抛出一个 TypeError 异常。
    2. 若 resolvingFunctions.[[Reject]] 不为 undefined，抛出一个 TypeError 异常。
    3. 设 resolvingFunctions.[[Resolve]] 为 resolve。
    4. 设 resolvingFunctions.[[Reject]] 为 reject。
    5. 返回 NormalCompletion(undefined)。
  5. 令 executor 为 CreateBuiltinFunction(executorClosure, 2, "", « »)。
  6. 令 promise 为 ? Construct(C, « executor »)。
  7. 若 IsCallable(resolvingFunctions.[[Resolve]]) 为 false，抛出一个 TypeError 异常。
  8. 若 IsCallable(resolvingFunctions.[[Reject]]) 为 false，抛出一个 TypeError 异常。
  9. 返回 PromiseCapability Record { [[Promise]]: promise, [[Resolve]]: resolvingFunctions.[[Resolve]], [[Reject]]: resolvingFunctions.[[Reject]] }。
 Note

该抽象操作支持 Promise 子类化，因为它对任何以与 Promise 构造函数相同方式调用传入 executor 函数参数的构造器都是通用的。它用于将 Promise 构造函数的静态方法泛化到任意子类。

27.2.1.6 IsPromise ( x )

The abstract operation IsPromise takes argument x (an ECMAScript language value) and returns 一个 Boolean. 检查对象上是否具有 promise 品牌标记。 It performs the following steps when called:

  1. 若 x 不是一个 Object，返回 false。
  2. 若 x 不具有 [[PromiseState]] 内部槽，返回 false。
  3. 返回 true。

27.2.1.7 RejectPromise ( promise, reason )

The abstract operation RejectPromise takes arguments promise (a Promise) and reason (an ECMAScript language value) and returns unused. It performs the following steps when called:

  1. 断言：promise.[[PromiseState]] 为 pending。
  2. 令 reactions 为 promise.[[PromiseRejectReactions]]。
  3. 设 promise.[[PromiseResult]] 为 reason。
  4. 设 promise.[[PromiseFulfillReactions]] 为 undefined。
  5. 设 promise.[[PromiseRejectReactions]] 为 undefined。
  6. 设 promise.[[PromiseState]] 为 rejected。
  7. 若 promise.[[PromiseIsHandled]] 为 false，执行 HostPromiseRejectionTracker(promise, "reject")。
  8. 执行 TriggerPromiseReactions(reactions, reason)。
  9. 返回 unused。

27.2.1.8 TriggerPromiseReactions ( reactions, argument )

The abstract operation TriggerPromiseReactions takes arguments reactions (a List of PromiseReaction Records) and argument (an ECMAScript language value) and returns unused. 为 reactions 中的每个记录入列一个新的 Job。每个这样的 Job 处理该 PromiseReaction Record 的 [[Type]] 与 [[Handler]]，若 [[Handler]] 不是 empty，则以给定参数调用它。若 [[Handler]] 为 empty，行为由 [[Type]] 决定。 It performs the following steps when called:

  1. 对于 reactions 的每个元素 reaction，执行
    1. 令 job 为 NewPromiseReactionJob(reaction, argument)。
    2. 执行 HostEnqueuePromiseJob(job.[[Job]], job.[[Realm]])。
  2. 返回 unused。

27.2.1.9 HostPromiseRejectionTracker ( promise, operation )

The host-defined abstract operation HostPromiseRejectionTracker takes arguments promise (a Promise) and operation ("reject" or "handle") and returns unused. 允许宿主环境追踪 promise 拒绝。

HostPromiseRejectionTracker 的默认实现是返回 unused。

Note 1

HostPromiseRejectionTracker 在两种场景被调用：

  • 当一个 promise 在没有任何处理器的情况下被拒绝时，以 operation 参数为 "reject" 调用。
  • 当首次向一个已拒绝的 promise 添加处理器时，以 operation 参数为 "handle" 调用。

一个典型实现可能尝试通知开发者未处理的拒绝，同时在随后新处理器附加使先前通知失效时再次适当通知。

 Note 2

若 operation 为 "handle"，实现不应以影响垃圾回收的方式持有对 promise 的引用。若 operation 为 "reject"，实现可以持有引用，因为预期拒绝是少见且不在热点路径上。

27.2.2 Promise 作业

27.2.2.1 NewPromiseReactionJob ( reaction, argument )

The abstract operation NewPromiseReactionJob takes arguments reaction (一个 PromiseReaction Record，) and argument (一个 ECMAScript 语言值) and returns 一个具有字段 [[Job]] (一个 Job 抽象闭包) 和 [[Realm]] (一个 Realm Record 或 null) 的 Record. 返回一个新的 Job 抽象闭包，该闭包对传入的值应用合适的处理器，并使用该处理器的返回值来根据该处理器关联的派生 promise 进行 resolve 或 reject。 It performs the following steps when called:

  1. 令 job 为一个无参数的新 Job 抽象闭包，捕获 reaction 和 argument，在被调用时执行下列步骤：
    1. 令 promiseCapability 为 reaction.[[Capability]]。
    2. 令 type 为 reaction.[[Type]]。
    3. 令 handler 为 reaction.[[Handler]]。
    4. 如果 handler 是 empty，则
      1. 如果 type 是 fulfill，则
        1. 令 handlerResult 为 NormalCompletion(argument)。
      2. 否则，
        1. 断言：type 是 reject。
        2. 令 handlerResult 为 ThrowCompletion(argument)。
    5. 否则，
      1. 令 handlerResult 为 Completion(HostCallJobCallback(handler, undefined, « argument »))。
    6. 如果 promiseCapability 是 undefined，则
      1. 断言：handlerResult 不是一个 abrupt completion。
      2. 返回 empty。
    7. 断言：promiseCapability 是一个 PromiseCapability Record。
    8. 如果 handlerResult 是一个 abrupt completion，则
      1. 返回 ? Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »)。
    9. 否则，
      1. 返回 ? Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »)。
  2. 令 handlerRealm 为 null。
  3. 如果 reaction.[[Handler]] 不为 empty，则
    1. 令 getHandlerRealmResult 为 Completion(GetFunctionRealm(reaction.[[Handler]].[[Callback]]))。
    2. 如果 getHandlerRealmResult 是一个 normal completion，则将 handlerRealm 设为 getHandlerRealmResult.[[Value]]。
    3. 否则，将 handlerRealm 设为当前 Realm Record。
    4. 注：除非处理器是 undefined，否则 handlerRealm 永不为 null。当处理器是已撤销的 Proxy 且没有 ECMAScript 代码运行时，handlerRealm 用来创建错误对象。
  4. 返回 Record { [[Job]]: job, [[Realm]]: handlerRealm }。

27.2.2.2 NewPromiseResolveThenableJob ( promiseToResolve, thenable, then )

The abstract operation NewPromiseResolveThenableJob takes arguments promiseToResolve (一个 Promise), thenable (一个 Object), and then (一个 JobCallback Record) and returns 一个具有字段 [[Job]] (一个 Job 抽象闭包) 和 [[Realm]] (一个 Realm Record) 的 Record. It performs the following steps when called:

  1. 令 job 为一个无参数的新 Job 抽象闭包，捕获 promiseToResolve, thenable, 以及 then，在被调用时执行下列步骤：
    1. 令 resolvingFunctions 为 CreateResolvingFunctions(promiseToResolve)。
    2. 令 thenCallResult 为 Completion(HostCallJobCallback(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »))。
    3. 如果 thenCallResult 是一个 abrupt completion，则
      1. 返回 ? Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »)。
    4. 返回 ! thenCallResult。
  2. 令 getThenRealmResult 为 Completion(GetFunctionRealm(then.[[Callback]]))。
  3. 如果 getThenRealmResult 是一个 normal completion，令 thenRealm 为 getThenRealmResult.[[Value]]。
  4. 否则，令 thenRealm 为当前 Realm Record。
  5. 注：thenRealm 永不为 null。当 then.[[Callback]] 是一个已撤销的 Proxy 且无代码运行时，thenRealm 用于创建错误对象。
  6. 返回 Record { [[Job]]: job, [[Realm]]: thenRealm }。
 Note

该作业使用提供的 thenable 及其 then 方法来 resolve 给定的 promise。此过程必须作为一个 Job 进行，以确保对 then 方法的求值发生在任意外围代码求值完成之后。

27.2.3 Promise 构造函数

Promise 构造函数：

  • 是 %Promise%。
  • 是全局对象 "Promise" 属性的初始值。
  • 作为构造函数调用时创建并初始化一个新的 Promise。
  • 不应作为普通函数调用，若以那种方式调用将抛出异常。
  • 可用作类定义中 extends 子句的值。意图继承指定 Promise 行为的子类构造函数必须包含对 Promise 构造函数的 super 调用，以使用支持 Promise 和 Promise.prototype 内建方法所需的内部状态创建并初始化子类实例。

27.2.3.1 Promise ( executor )

此函数在被调用时执行下列步骤：

  1. 如果 NewTarget 是 undefined，抛出 TypeError 异常。
  2. 如果 IsCallable(executor) 是 false，抛出 TypeError 异常。
  3. 令 promise 为 ? OrdinaryCreateFromConstructor(NewTarget, "%Promise.prototype%", « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »)。
  4. 将 promise.[[PromiseState]] 设为 pending。
  5. 将 promise.[[PromiseResult]] 设为 empty。
  6. 将 promise.[[PromiseFulfillReactions]] 设为一个新的空 List。
  7. 将 promise.[[PromiseRejectReactions]] 设为一个新的空 List。
  8. 将 promise.[[PromiseIsHandled]] 设为 false。
  9. 令 resolvingFunctions 为 CreateResolvingFunctions(promise)。
  10. 令 completion 为 Completion(Call(executor, undefined, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »))。
  11. 如果 completion 是一个 abrupt completion，则
    1. 执行 ? Call(resolvingFunctions.[[Reject]], undefined, « completion.[[Value]] »)。
  12. 返回 promise。
 Note

executor 参数必须是一个函数对象。它被调用以发起并报告该 Promise 所表示的可能延迟动作的完成情况。executor 以两个参数调用：resolve 与 reject。executor 函数可使用这些函数报告延迟计算的最终完成或失败。从 executor 函数返回并不意味着延迟动作已经完成，仅表示执行延迟动作的请求已被接受。

传给 executor 的 resolve 函数接受一个参数。executor 代码最终可以调用 resolve 来表示其希望 resolve 关联的 Promise。传给 resolve 的参数表示延迟动作的最终值，可以是实际的 fulfill 值，也可以是另一个在 fulfill 后提供该值的 promise。

传给 executor 的 reject 函数接受一个参数。executor 代码最终可以调用 reject 来表示关联的 Promise 已被 reject 且永不会 fulfill。传给 reject 的参数用作该 promise 的拒绝值。典型情况下它将是一个 Error 对象。

Promise 构造函数传给 executor 的 resolve 与 reject 函数具有实际 resolve 和 reject 关联 promise 的能力。子类可能有不同的构造函数行为，向 executor 传入自定义的 resolve 与 reject 值。

27.2.4 Promise 构造函数的属性

Promise 构造函数：

27.2.4.1 Promise.all ( iterable )

该函数返回一个新的 promise：若传入的各个 promise 全部 fulfill，则以其 fulfill 值数组进行 fulfill；若其中第一个 reject，则以该 reject 原因进行 reject。它在运行本算法时会将传入可迭代对象的所有元素解析为 promise。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(C))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAll(iteratorRecord, C, promiseCapability, promiseResolve))。
  8. 如果 result 是一个 abrupt completion，则
    1. 如果 iteratorRecord.[[Done]] 是 false，将 result 设为 Completion(IteratorClose(iteratorRecord, result))。
    2. IfAbruptRejectPromise(result, promiseCapability)。
  9. 返回 ! result。
 Note

该函数要求其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.1.1 GetPromiseResolve ( promiseConstructor )

The abstract operation GetPromiseResolve takes argument promiseConstructor (一个 constructor) and returns 要么是包含一个函数对象的 normal completion，要么是一个 throw completion. It performs the following steps when called:

  1. 令 promiseResolve 为 ? Get(promiseConstructor, "resolve")。
  2. 如果 IsCallable(promiseResolve) 是 false，抛出 TypeError 异常。
  3. 返回 promiseResolve。

27.2.4.1.2 PerformPromiseAll ( iteratorRecord, constructor, resultCapability, promiseResolve )

The abstract operation PerformPromiseAll takes arguments iteratorRecord (一个 Iterator Record), constructor (一个 constructor), resultCapability (一个 PromiseCapability Record), and promiseResolve (一个函数对象) and returns 要么是包含一个 ECMAScript 语言值的 normal completion，要么是一个 throw completion. It performs the following steps when called:

  1. 令 values 为一个新的空 List。
  2. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  3. 令 index 为 0。
  4. 重复，
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      2. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 valuesArray 为 CreateArrayFromList(values)。
        2. 执行 ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »)。
      3. 返回 resultCapability.[[Promise]]。
    3. 将 undefined 追加到 values。
    4. 令 nextPromise 为 ? Call(promiseResolve, constructor, « next »)。
    5. 令 steps 为 Promise.all Resolve 元素函数 中定义的算法步骤。
    6. 令 length 为 Promise.all Resolve 元素函数 中函数定义的非可选参数个数。
    7. 令 onFulfilled 为 CreateBuiltinFunction(steps, length, "", « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »)。
    8. 将 onFulfilled.[[AlreadyCalled]] 设为 false。
    9. 将 onFulfilled.[[Index]] 设为 index。
    10. 将 onFulfilled.[[Values]] 设为 values。
    11. 将 onFulfilled.[[Capability]] 设为 resultCapability。
    12. 将 onFulfilled.[[RemainingElements]] 设为 remainingElementsCount。
    13. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    14. 执行 ? Invoke(nextPromise, "then", « onFulfilled, resultCapability.[[Reject]] »)。
    15. 将 index 设为 index + 1。

27.2.4.1.3 Promise.all Resolve 元素函数

Promise.all resolve 元素函数是一个匿名内建函数，用于 resolve 某个特定的 Promise.all 元素。每个此类函数具有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。

当一个 Promise.all resolve 元素函数以参数 x 被调用时，执行下列步骤：

  1. 令 F 为活动函数对象。
  2. 如果 F.[[AlreadyCalled]] 是 true，返回 undefined。
  3. 将 F.[[AlreadyCalled]] 设为 true。
  4. 令 index 为 F.[[Index]]。
  5. 令 values 为 F.[[Values]]。
  6. 令 promiseCapability 为 F.[[Capability]]。
  7. 令 remainingElementsCount 为 F.[[RemainingElements]]。
  8. 将 values[index] 设为 x。
  9. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
  10. 如果 remainingElementsCount.[[Value]] = 0，则
    1. 令 valuesArray 为 CreateArrayFromList(values)。
    2. 返回 ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »)。
  11. 返回 undefined。

Promise.all resolve 元素函数的 "length" 属性是 1𝔽。

27.2.4.2 Promise.allSettled ( iterable )

该函数返回一个 promise，当所有原始 promise 均已 settle（即变为 fulfilled 或 rejected）后，以包含 promise 状态快照的数组 fulfill。它在运行本算法时将传入可迭代对象的所有元素解析为 promise。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(C))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAllSettled(iteratorRecord, C, promiseCapability, promiseResolve))。
  8. 如果 result 是一个 abrupt completion，则
    1. 如果 iteratorRecord.[[Done]] 是 false，将 result 设为 Completion(IteratorClose(iteratorRecord, result))。
    2. IfAbruptRejectPromise(result, promiseCapability)。
  9. 返回 ! result。
 Note

该函数要求其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.2.1 PerformPromiseAllSettled ( iteratorRecord, constructor, resultCapability, promiseResolve )

The abstract operation PerformPromiseAllSettled takes arguments iteratorRecord (一个 Iterator Record), constructor (一个 constructor), resultCapability (一个 PromiseCapability Record), and promiseResolve (一个函数对象) and returns 要么是包含一个 ECMAScript 语言值的 normal completion，要么是一个 throw completion. It performs the following steps when called:

  1. 令 values 为一个新的空 List。
  2. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  3. 令 index 为 0。
  4. 重复，
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      2. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 valuesArray 为 CreateArrayFromList(values)。
        2. 执行 ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »)。
      3. 返回 resultCapability.[[Promise]]。
    3. 将 undefined 追加到 values。
    4. 令 nextPromise 为 ? Call(promiseResolve, constructor, « next »)。
    5. 令 stepsFulfilled 为 Promise.allSettled Resolve 元素函数 中定义的算法步骤。
    6. 令 lengthFulfilled 为 Promise.allSettled Resolve 元素函数 中函数定义的非可选参数个数。
    7. 令 onFulfilled 为 CreateBuiltinFunction(stepsFulfilled, lengthFulfilled, "", « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »)。
    8. 令 alreadyCalled 为 Record { [[Value]]: false }。
    9. 将 onFulfilled.[[AlreadyCalled]] 设为 alreadyCalled。
    10. 将 onFulfilled.[[Index]] 设为 index。
    11. 将 onFulfilled.[[Values]] 设为 values。
    12. 将 onFulfilled.[[Capability]] 设为 resultCapability。
    13. 将 onFulfilled.[[RemainingElements]] 设为 remainingElementsCount。
    14. 令 stepsRejected 为 Promise.allSettled Reject 元素函数 中定义的算法步骤。
    15. 令 lengthRejected 为 Promise.allSettled Reject 元素函数 中函数定义的非可选参数个数。
    16. 令 onRejected 为 CreateBuiltinFunction(stepsRejected, lengthRejected, "", « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »)。
    17. 将 onRejected.[[AlreadyCalled]] 设为 alreadyCalled。
    18. 将 onRejected.[[Index]] 设为 index。
    19. 将 onRejected.[[Values]] 设为 values。
    20. 将 onRejected.[[Capability]] 设为 resultCapability。
    21. 将 onRejected.[[RemainingElements]] 设为 remainingElementsCount。
    22. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    23. 执行 ? Invoke(nextPromise, "then", « onFulfilled, onRejected »)。
    24. 将 index 设为 index + 1。

27.2.4.2.2 Promise.allSettled Resolve 元素函数

Promise.allSettled resolve 元素函数是一个匿名内建函数，用于 resolve 某个特定的 Promise.allSettled 元素。每个此类函数具有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。

当一个 Promise.allSettled resolve 元素函数以参数 x 被调用时，执行下列步骤：

  1. 令 F 为活动函数对象。
  2. 令 alreadyCalled 为 F.[[AlreadyCalled]]。
  3. 如果 alreadyCalled.[[Value]] 是 true，返回 undefined。
  4. 将 alreadyCalled.[[Value]] 设为 true。
  5. 令 index 为 F.[[Index]]。
  6. 令 values 为 F.[[Values]]。
  7. 令 promiseCapability 为 F.[[Capability]]。
  8. 令 remainingElementsCount 为 F.[[RemainingElements]]。
  9. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
  10. 执行 ! CreateDataPropertyOrThrow(obj, "status", "fulfilled")。
  11. 执行 ! CreateDataPropertyOrThrow(obj, "value", x)。
  12. 将 values[index] 设为 obj。
  13. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
  14. 如果 remainingElementsCount.[[Value]] = 0，则
    1. 令 valuesArray 为 CreateArrayFromList(values)。
    2. 返回 ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »)。
  15. 返回 undefined。

Promise.allSettled resolve 元素函数的 "length" 属性是 1𝔽。

27.2.4.2.3 Promise.allSettled Reject 元素函数

Promise.allSettled reject 元素函数是一个匿名内建函数，用于 reject 某个特定的 Promise.allSettled 元素。每个此类函数具有 [[Index]]、[[Values]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。

当一个 Promise.allSettled reject 元素函数以参数 x 被调用时，执行下列步骤：

  1. 令 F 为活动函数对象。
  2. 令 alreadyCalled 为 F.[[AlreadyCalled]]。
  3. 如果 alreadyCalled.[[Value]] 是 true，返回 undefined。
  4. 将 alreadyCalled.[[Value]] 设为 true。
  5. 令 index 为 F.[[Index]]。
  6. 令 values 为 F.[[Values]]。
  7. 令 promiseCapability 为 F.[[Capability]]。
  8. 令 remainingElementsCount 为 F.[[RemainingElements]]。
  9. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
  10. 执行 ! CreateDataPropertyOrThrow(obj, "status", "rejected")。
  11. 执行 ! CreateDataPropertyOrThrow(obj, "reason", x)。
  12. 将 values[index] 设为 obj。
  13. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
  14. 如果 remainingElementsCount.[[Value]] = 0，则
    1. 令 valuesArray 为 CreateArrayFromList(values)。
    2. 返回 ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »)。
  15. 返回 undefined。

Promise.allSettled reject 元素函数的 "length" 属性是 1𝔽。

27.2.4.3 Promise.any ( iterable )

该函数返回一个 promise：由第一个 fulfill 的输入 promise 来 fulfill；如果所有输入 promise 均被 reject，则以一个包含所有拒绝原因的 AggregateError 进行 reject。它在运行本算法时将传入可迭代对象的所有元素解析为 promise。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(C))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAny(iteratorRecord, C, promiseCapability, promiseResolve))。
  8. 如果 result 是一个 abrupt completion，则
    1. 如果 iteratorRecord.[[Done]] 是 false，将 result 设为 Completion(IteratorClose(iteratorRecord, result))。
    2. IfAbruptRejectPromise(result, promiseCapability)。
  9. 返回 ! result。
 Note

该函数要求其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.3.1 PerformPromiseAny ( iteratorRecord, constructor, resultCapability, promiseResolve )

The abstract operation PerformPromiseAny takes arguments iteratorRecord (一个 Iterator Record), constructor (一个 constructor), resultCapability (一个 PromiseCapability Record), and promiseResolve (一个函数对象) and returns 要么是包含一个 ECMAScript 语言值的 normal completion，要么是一个 throw completion. It performs the following steps when called:

  1. 令 errors 为一个新的空 List。
  2. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  3. 令 index 为 0。
  4. 重复，
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      2. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 error 为一个新创建的 AggregateError 对象。
        2. 执行 ! DefinePropertyOrThrow(error, "errors", PropertyDescriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: CreateArrayFromList(errors) })。
        3. 返回 ThrowCompletion(error)。
      3. 返回 resultCapability.[[Promise]]。
    3. 将 undefined 追加到 errors。
    4. 令 nextPromise 为 ? Call(promiseResolve, constructor, « next »)。
    5. 令 stepsRejected 为 Promise.any Reject 元素函数 中定义的算法步骤。
    6. 令 lengthRejected 为 Promise.any Reject 元素函数 中函数定义的非可选参数个数。
    7. 令 onRejected 为 CreateBuiltinFunction(stepsRejected, lengthRejected, "", « [[AlreadyCalled]], [[Index]], [[Errors]], [[Capability]], [[RemainingElements]] »)。
    8. 将 onRejected.[[AlreadyCalled]] 设为 false。
    9. 将 onRejected.[[Index]] 设为 index。
    10. 将 onRejected.[[Errors]] 设为 errors。
    11. 将 onRejected.[[Capability]] 设为 resultCapability。
    12. 将 onRejected.[[RemainingElements]] 设为 remainingElementsCount。
    13. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    14. 执行 ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], onRejected »)。
    15. 将 index 设为 index + 1。

27.2.4.3.2 Promise.any Reject 元素函数

Promise.any reject 元素函数是一个匿名内建函数，用于 reject 某个特定的 Promise.any 元素。每个此类函数具有 [[Index]]、[[Errors]]、[[Capability]]、[[RemainingElements]] 和 [[AlreadyCalled]] 内部槽。

当一个 Promise.any reject 元素函数以参数 x 被调用时，执行下列步骤：

  1. 令 F 为活动函数对象。
  2. 如果 F.[[AlreadyCalled]] 是 true，返回 undefined。
  3. 将 F.[[AlreadyCalled]] 设为 true。
  4. 令 index 为 F.[[Index]]。
  5. 令 errors 为 F.[[Errors]]。
  6. 令 promiseCapability 为 F.[[Capability]]。
  7. 令 remainingElementsCount 为 F.[[RemainingElements]]。
  8. 将 errors[index] 设为 x。
  9. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
  10. 如果 remainingElementsCount.[[Value]] = 0，则
    1. 令 error 为一个新创建的 AggregateError 对象。
    2. 执行 ! DefinePropertyOrThrow(error, "errors", PropertyDescriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: CreateArrayFromList(errors) })。
    3. 返回 ? Call(promiseCapability.[[Reject]], undefined, « error »)。
  11. 返回 undefined。

Promise.any reject 元素函数的 "length" 属性是 1𝔽。

27.2.4.4 Promise.prototype

Promise.prototype 的初始值是 Promise 原型对象。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false } 属性。

27.2.4.5 Promise.race ( iterable )

该函数返回一个新的 promise，其 settle 方式与第一个 settle 的传入 promise 相同。它在运行本算法时将传入的 iterable 的所有元素解析为 promise。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(C))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseRace(iteratorRecord, C, promiseCapability, promiseResolve))。
  8. 如果 result 是一个 abrupt completion，则
    1. 如果 iteratorRecord.[[Done]] 是 false，将 result 设为 Completion(IteratorClose(iteratorRecord, result))。
    2. IfAbruptRejectPromise(result, promiseCapability)。
  9. 返回 ! result。
 Note 1

如果 iterable 参数不产生任何值，或其产生的 promise 都永不 settle，则此方法返回的挂起 promise 将永不 settle。

 Note 2

该函数期望其 this 值为一个支持 Promise 构造函数参数约定的构造函数。它还期望其 this 值提供一个 resolve 方法。

27.2.4.5.1 PerformPromiseRace ( iteratorRecord, constructor, resultCapability, promiseResolve )

The abstract operation PerformPromiseRace takes arguments iteratorRecord (一个 Iterator Record), constructor (一个 constructor), resultCapability (一个 PromiseCapability Record), and promiseResolve (一个函数对象) and returns 要么是包含一个 ECMAScript 语言值的 normal completion，要么是一个 throw completion. It performs the following steps when called:

  1. 重复，
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 返回 resultCapability.[[Promise]]。
    3. 令 nextPromise 为 ? Call(promiseResolve, constructor, « next »)。
    4. 执行 ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], resultCapability.[[Reject]] »)。

27.2.4.6 Promise.reject ( r )

该函数返回一个以传入参数为拒绝原因而被 reject 的新 promise。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 执行 ? Call(promiseCapability.[[Reject]], undefined, « r »)。
  4. 返回 promiseCapability.[[Promise]]。
 Note

该函数期望其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.7 Promise.resolve ( x )

该函数要么返回一个以传入参数 resolve 的新 promise，要么若该参数本身是由此构造函数产生的 promise，则直接返回该参数。

  1. 令 C 为 this 值。
  2. 如果 C 不是一个 Object，抛出 TypeError 异常。
  3. 返回 ? PromiseResolve(C, x)。
 Note

该函数期望其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.7.1 PromiseResolve ( C, x )

The abstract operation PromiseResolve takes arguments C (一个 Object) and x (一个 ECMAScript 语言值) and returns 要么是包含一个 ECMAScript 语言值的 normal completion，要么是一个 throw completion. 返回一个以 x resolve 的新 promise。 It performs the following steps when called:

  1. 如果 IsPromise(x) 是 true，则
    1. 令 xConstructor 为 ? Get(x, "constructor")。
    2. 如果 SameValue(xConstructor, C) 是 true，返回 x。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 执行 ? Call(promiseCapability.[[Resolve]], undefined, « x »)。
  4. 返回 promiseCapability.[[Promise]]。

27.2.4.8 Promise.try ( callback, ...args )

该函数在被调用时执行下列步骤：

  1. 令 C 为 this 值。
  2. 如果 C 不是一个 Object，抛出 TypeError 异常。
  3. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  4. 令 status 为 Completion(Call(callback, undefined, args))。
  5. 如果 status 是一个 abrupt completion，则
    1. 执行 ? Call(promiseCapability.[[Reject]], undefined, « status.[[Value]] »)。
  6. 否则，
    1. 执行 ? Call(promiseCapability.[[Resolve]], undefined, « status.[[Value]] »)。
  7. 返回 promiseCapability.[[Promise]]。
 Note

该函数期望其 this 值为一个支持 Promise 构造函数参数约定的构造函数。

27.2.4.9 Promise.withResolvers ( )

该函数返回一个具有三个属性的对象：一个新 promise 以及与之关联的 resolve 和 reject 函数。

  1. 令 C 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(C)。
  3. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
  4. 执行 ! CreateDataPropertyOrThrow(obj, "promise", promiseCapability.[[Promise]])。
  5. 执行 ! CreateDataPropertyOrThrow(obj, "resolve", promiseCapability.[[Resolve]])。
  6. 执行 ! CreateDataPropertyOrThrow(obj, "reject", promiseCapability.[[Reject]])。
  7. 返回 obj。

27.2.4.10 get Promise [ %Symbol.species% ]

Promise[%Symbol.species%] 是一个访问器属性，其 set 访问器函数为 undefined。其 get 访问器函数在被调用时执行下列步骤：

  1. 返回 this 值。

该函数的 "name" 属性值是 "get [Symbol.species]"。

Note

Promise 原型方法通常使用其 this 值的构造函数来创建一个派生对象。然而，一个子类构造函数可以通过重新定义其 %Symbol.species% 属性来覆盖该默认行为。

27.2.5 Promise 原型对象的属性

Promise 原型对象：

  • 是 %Promise.prototype%。
  • 有一个 [[Prototype]] 内部槽，其值为 %Object.prototype%。
  • 是一个普通对象。
  • 不具有 [[PromiseState]] 内部槽，也不具有 Promise 实例的其他任何内部槽。

27.2.5.1 Promise.prototype.catch ( onRejected )

该方法被调用时执行以下步骤：

  1. 令 promise 为 this 值。
  2. 返回 ? Invoke(promise, "then", « undefined, onRejected »)。

27.2.5.2 Promise.prototype.constructor

Promise.prototype.constructor 的初始值是 %Promise%。

27.2.5.3 Promise.prototype.finally ( onFinally )

该方法被调用时执行以下步骤：

  1. 令 promise 为 this 值。
  2. 如果 promise 不是一个 Object，抛出 TypeError 异常。
  3. 令 C 为 ? SpeciesConstructor(promise, %Promise%)。
  4. 断言：IsConstructor(C) 为 true。
  5. 如果 IsCallable(onFinally) 为 false，则
    1. 令 thenFinally 为 onFinally。
    2. 令 catchFinally 为 onFinally。
  6. 否则，
    1. 令 thenFinallyClosure 为一个具有参数 (value) 的新抽象闭包，捕获 onFinally 与 C，在被调用时执行以下步骤：
      1. 令 result 为 ? Call(onFinally, undefined)。
      2. 令 p 为 ? PromiseResolve(C, result)。
      3. 令 returnValue 为一个无参数的新抽象闭包，捕获 value 并在被调用时执行以下步骤：
        1. 返回 NormalCompletion(value)。
      4. 令 valueThunk 为 CreateBuiltinFunction(returnValue, 0, "", « »)。
      5. 返回 ? Invoke(p, "then", « valueThunk »)。
    2. 令 thenFinally 为 CreateBuiltinFunction(thenFinallyClosure, 1, "", « »)。
    3. 令 catchFinallyClosure 为一个具有参数 (reason) 的新抽象闭包，捕获 onFinally 与 C，在被调用时执行以下步骤：
      1. 令 result 为 ? Call(onFinally, undefined)。
      2. 令 p 为 ? PromiseResolve(C, result)。
      3. 令 throwReason 为一个无参数的新抽象闭包，捕获 reason 并在被调用时执行以下步骤：
        1. 返回 ThrowCompletion(reason)。
      4. 令 thrower 为 CreateBuiltinFunction(throwReason, 0, "", « »)。
      5. 返回 ? Invoke(p, "then", « thrower »)。
    4. 令 catchFinally 为 CreateBuiltinFunction(catchFinallyClosure, 1, "", « »)。
  7. 返回 ? Invoke(promise, "then", « thenFinally, catchFinally »)。

27.2.5.4 Promise.prototype.then ( onFulfilled, onRejected )

该方法被调用时执行以下步骤：

  1. 令 promise 为 this 值。
  2. 如果 IsPromise(promise) 为 false，抛出 TypeError 异常。
  3. 令 C 为 ? SpeciesConstructor(promise, %Promise%)。
  4. 令 resultCapability 为 ? NewPromiseCapability(C)。
  5. 返回 PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)。

27.2.5.4.1 PerformPromiseThen ( promise, onFulfilled, onRejected [ , resultCapability ] )

The abstract operation PerformPromiseThen takes arguments promise (a Promise), onFulfilled (an ECMAScript language value), and onRejected (an ECMAScript language value) and optional argument resultCapability (a PromiseCapability Record) and returns an ECMAScript language value. 使用 onFulfilled 和 onRejected 作为 settle 动作在 promise 上执行 “then” 操作。若传入 resultCapability，则通过更新 resultCapability 的 promise 来存储结果；若未传入，则表示 PerformPromiseThen 是由规范内部操作调用，其结果不重要。 It performs the following steps when called:

  1. 断言：IsPromise(promise) 为 true。
  2. 如果 resultCapability 未传入，则
    1. 将 resultCapability 设为 undefined。
  3. 如果 IsCallable(onFulfilled) 为 false，则
    1. 令 onFulfilledJobCallback 为 empty。
  4. 否则，
    1. 令 onFulfilledJobCallback 为 HostMakeJobCallback(onFulfilled)。
  5. 如果 IsCallable(onRejected) 为 false，则
    1. 令 onRejectedJobCallback 为 empty。
  6. 否则，
    1. 令 onRejectedJobCallback 为 HostMakeJobCallback(onRejected)。
  7. 令 fulfillReaction 为 PromiseReaction Record { [[Capability]]: resultCapability, [[Type]]: fulfill, [[Handler]]: onFulfilledJobCallback }。
  8. 令 rejectReaction 为 PromiseReaction Record { [[Capability]]: resultCapability, [[Type]]: reject, [[Handler]]: onRejectedJobCallback }。
  9. 如果 promise.[[PromiseState]] 是 pending，则
    1. 将 fulfillReaction 追加到 promise.[[PromiseFulfillReactions]]。
    2. 将 rejectReaction 追加到 promise.[[PromiseRejectReactions]]。
  10. 否则如果 promise.[[PromiseState]] 是 fulfilled，则
    1. 令 value 为 promise.[[PromiseResult]]。
    2. 令 fulfillJob 为 NewPromiseReactionJob(fulfillReaction, value)。
    3. 执行 HostEnqueuePromiseJob(fulfillJob.[[Job]], fulfillJob.[[Realm]])。
  11. 否则，
    1. 断言：promise.[[PromiseState]] 是 rejected。
    2. 令 reason 为 promise.[[PromiseResult]]。
    3. 如果 promise.[[PromiseIsHandled]] 为 false，执行 HostPromiseRejectionTracker(promise, "handle")。
    4. 令 rejectJob 为 NewPromiseReactionJob(rejectReaction, reason)。
    5. 执行 HostEnqueuePromiseJob(rejectJob.[[Job]], rejectJob.[[Realm]])。
  12. 将 promise.[[PromiseIsHandled]] 设为 true。
  13. 如果 resultCapability 是 undefined，则
    1. 返回 undefined。
  14. 否则，
    1. 返回 resultCapability.[[Promise]]。

27.2.5.5 Promise.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串值 "Promise"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true } 属性。

27.2.6 Promise 实例的属性

Promise 实例是普通对象，从 Promise 原型对象（那个内在对象 %Promise.prototype%）继承属性。Promise 实例最初按照 Table 90 描述的内部槽创建。

Table 90: Promise 实例的内部槽
内部槽 类型 描述
[[PromiseState]] pending, fulfilled, 或 rejected 决定该 promise 对其 then 方法的传入调用如何作出反应。
[[PromiseResult]] 一个 ECMAScript 语言值或 empty promise 被 fulfill 或 reject 时的值（若有）。当且仅当 [[PromiseState]] 为 pending 时为 empty。
[[PromiseFulfillReactions]] 一个 PromiseReaction Record 的 List 当（如果）promise 从 pending 转变为 fulfilled 状态时要处理的记录。
[[PromiseRejectReactions]] 一个 PromiseReaction Record 的 List 当（如果）promise 从 pending 转变为 rejected 状态时要处理的记录。
[[PromiseIsHandled]] 一个 Boolean 指示该 promise 是否曾拥有过 fulfill 或 reject 处理器；用于未处理拒绝的跟踪。

27.3 GeneratorFunction 对象

GeneratorFunction 是通常通过求值 GeneratorDeclaration、GeneratorExpression 和 GeneratorMethod 产生的函数。也可通过调用内在对象 %GeneratorFunction% 创建。

Figure 6 (Informative): Generator 对象关系
大量框与箭头的示意图。

27.3.1 GeneratorFunction 构造函数

GeneratorFunction 构造函数：

  • 是 %GeneratorFunction%。
  • 是 Function 的子类。
  • 当以函数（而非构造函数）方式调用时创建并初始化一个新的 GeneratorFunction。故函数调用 GeneratorFunction (…) 等价于以相同参数的对象创建表达式 new GeneratorFunction (…)。
  • 可用作类定义中 extends 子句的值。意图继承指定 GeneratorFunction 行为的子类构造函数必须包含对 GeneratorFunction 构造函数的 super 调用，以创建并初始化带有内建 GeneratorFunction 行为所需内部槽的子类实例。所有用于定义 generator 函数对象的 ECMAScript 语法形式都会创建 GeneratorFunction 的直接实例。没有语法手段创建 GeneratorFunction 子类的实例。

27.3.1.1 GeneratorFunction ( ...parameterArgs, bodyArg )

最后一个参数（如果存在）指定生成器函数的函数体（可执行代码）；之前的任意参数指定形式参数。

该函数被调用时执行以下步骤：

  1. 令 C 为活动函数对象。
  2. 如果 bodyArg 不存在，将 bodyArg 设为空字符串。
  3. 返回 ? CreateDynamicFunction(C, NewTarget, generator, parameterArgs, bodyArg)。
 Note

参见 20.2.1.1 的注。

27.3.2 GeneratorFunction 构造函数的属性

GeneratorFunction 构造函数：

  • 是一个继承自 Function 构造函数的标准内建函数对象。
  • 具有值为 %Function% 的 [[Prototype]] 内部槽。
  • 具有值为 1𝔽 的 "length" 属性。
  • 具有值为 "GeneratorFunction" 的 "name" 属性。
  • 具有以下属性：

27.3.2.1 GeneratorFunction.prototype

GeneratorFunction.prototype 的初始值是 GeneratorFunction 原型对象。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

27.3.3 GeneratorFunction 原型对象的属性

GeneratorFunction 原型对象：

27.3.3.1 GeneratorFunction.prototype.constructor

GeneratorFunction.prototype.constructor 的初始值是 %GeneratorFunction%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.3.3.2 GeneratorFunction.prototype.prototype

GeneratorFunction.prototype.prototype 的初始值是 %GeneratorPrototype%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.3.3.3 GeneratorFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串 "GeneratorFunction"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.3.4 GeneratorFunction 实例

每个 GeneratorFunction 实例都是一个 ECMAScript 函数对象，并拥有 Table 28 中列出的内部槽。所有此类实例的 [[IsClassConstructor]] 内部槽的值为 false。

每个 GeneratorFunction 实例具有以下自有属性：

27.3.4.1 length

20.2.4.1 中给出的 Function 实例 "length" 属性规范同样适用于 GeneratorFunction 实例。

27.3.4.2 name

20.2.4.2 中给出的 Function 实例 "name" 属性规范同样适用于 GeneratorFunction 实例。

27.3.4.3 prototype

每当创建一个 GeneratorFunction 实例时，也会创建另一个普通对象，作为该生成器函数 "prototype" 属性的初始值。该 prototype 属性的值用于在以 [[Call]] 调用该生成器函数对象时初始化新建 Generator 的 [[Prototype]] 内部槽。

该属性具有 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

Note

不同于 Function 实例，GeneratorFunction 的 "prototype" 属性值对象没有 "constructor" 属性，其值为该 GeneratorFunction 实例。

27.4 AsyncGeneratorFunction 对象

AsyncGeneratorFunction 是通常通过求值 AsyncGeneratorDeclaration、AsyncGeneratorExpression 和 AsyncGeneratorMethod 语法产生式创建的函数。也可通过调用内在对象 %AsyncGeneratorFunction% 创建。

27.4.1 AsyncGeneratorFunction 构造函数

AsyncGeneratorFunction 构造函数：

  • 是 %AsyncGeneratorFunction%。
  • 是 Function 的子类。
  • 当以函数（而非构造函数）方式调用时创建并初始化一个新的 AsyncGeneratorFunction。故函数调用 AsyncGeneratorFunction (...) 等价于以相同参数的对象创建表达式 new AsyncGeneratorFunction (...)。
  • 可用作类定义中 extends 子句的值。意图继承指定 AsyncGeneratorFunction 行为的子类构造函数必须包含对 AsyncGeneratorFunction 构造函数的 super 调用，以创建并初始化带有内建 AsyncGeneratorFunction 行为所需内部槽的子类实例。所有用于定义 async generator 函数对象的 ECMAScript 语法形式都会创建 AsyncGeneratorFunction 的直接实例。没有语法手段创建 AsyncGeneratorFunction 子类的实例。

27.4.1.1 AsyncGeneratorFunction ( ...parameterArgs, bodyArg )

最后一个参数（如果存在）指定异步生成器函数的函数体（可执行代码）；之前的任意参数指定形式参数。

该函数被调用时执行以下步骤：

  1. 令 C 为活动函数对象。
  2. 如果 bodyArg 不存在，将 bodyArg 设为空字符串。
  3. 返回 ? CreateDynamicFunction(C, NewTarget, async-generator, parameterArgs, bodyArg)。
 Note

参见 20.2.1.1 的注。

27.4.2 AsyncGeneratorFunction 构造函数的属性

AsyncGeneratorFunction 构造函数：

  • 是一个继承自 Function 构造函数的标准内建函数对象。
  • 具有值为 %Function% 的 [[Prototype]] 内部槽。
  • 具有值为 1𝔽 的 "length" 属性。
  • 具有值为 "AsyncGeneratorFunction" 的 "name" 属性。
  • 具有以下属性：

27.4.2.1 AsyncGeneratorFunction.prototype

AsyncGeneratorFunction.prototype 的初始值是 AsyncGeneratorFunction 原型对象。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

27.4.3 AsyncGeneratorFunction 原型对象的属性

AsyncGeneratorFunction 原型对象：

27.4.3.1 AsyncGeneratorFunction.prototype.constructor

AsyncGeneratorFunction.prototype.constructor 的初始值是 %AsyncGeneratorFunction%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.4.3.2 AsyncGeneratorFunction.prototype.prototype

AsyncGeneratorFunction.prototype.prototype 的初始值是 %AsyncGeneratorPrototype%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.4.3.3 AsyncGeneratorFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串 "AsyncGeneratorFunction"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.4.4 AsyncGeneratorFunction 实例

每个 AsyncGeneratorFunction 实例都是一个 ECMAScript 函数对象，并拥有 Table 28 中列出的内部槽。所有此类实例的 [[IsClassConstructor]] 内部槽的值为 false。

每个 AsyncGeneratorFunction 实例具有以下自有属性：

27.4.4.1 length

"length" 属性的值是一个整数 Number，表示该 AsyncGeneratorFunction 期望的典型参数个数。然而，语言允许以其他参数个数调用该函数。以不同于其 "length" 属性指定参数个数调用时 AsyncGeneratorFunction 的行为依赖于函数本身。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.4.4.2 name

20.2.4.2 中给出的 Function 实例 "name" 属性规范同样适用于 AsyncGeneratorFunction 实例。

27.4.4.3 prototype

每当创建一个 AsyncGeneratorFunction 实例时，也会创建另一个普通对象，作为该异步生成器函数 "prototype" 属性的初始值。该 prototype 属性的值用于在以 [[Call]] 调用该生成器函数对象时初始化新建 AsyncGenerator 的 [[Prototype]] 内部槽。

该属性具有 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }。

Note

不同于函数实例，AsyncGeneratorFunction 的 "prototype" 属性值对象没有 "constructor" 属性，其值为该 AsyncGeneratorFunction 实例。

27.5 Generator 对象

Generator 通过调用一个生成器函数创建，并符合迭代器接口与可迭代接口。

Generator 实例直接从创建该实例的生成器函数 "prototype" 属性初始值继承属性。Generator 实例间接从 %GeneratorPrototype% 继承属性。

27.5.1 %GeneratorPrototype% 对象

%GeneratorPrototype% 对象：

  • 是 %GeneratorFunction.prototype.prototype%。
  • 是一个普通对象。
  • 不是一个 Generator 实例，且没有 [[GeneratorState]] 内部槽。
  • 具有值为 %Iterator.prototype% 的 [[Prototype]] 内部槽。
  • 具有被所有 Generator 实例间接继承的属性。

27.5.1.1 %GeneratorPrototype%.constructor

%GeneratorPrototype%.constructor 的初始值是 %GeneratorFunction.prototype%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.5.1.2 %GeneratorPrototype%.next ( value )

  1. 返回 ? GeneratorResume(this value, value, empty)。

27.5.1.3 %GeneratorPrototype%.return ( value )

该方法被调用时执行以下步骤：

  1. 令 g 为 this 值。
  2. 令 C 为 ReturnCompletion(value)。
  3. 返回 ? GeneratorResumeAbrupt(g, C, empty)。

27.5.1.4 %GeneratorPrototype%.throw ( exception )

该方法被调用时执行以下步骤：

  1. 令 g 为 this 值。
  2. 令 C 为 ThrowCompletion(exception)。
  3. 返回 ? GeneratorResumeAbrupt(g, C, empty)。

27.5.1.5 %GeneratorPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串 "Generator"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.5.2 Generator 实例的属性

Generator 实例最初按 Table 91 中描述的内部槽创建。

Table 91: Generator 实例的内部槽
内部槽 类型 描述
[[GeneratorState]] suspended-start, suspended-yield, executing, 或 completed 该生成器的当前执行状态。
[[GeneratorContext]] 一个执行上下文 执行该生成器代码时使用的执行上下文。
[[GeneratorBrand]] 一个 String 或 empty 用于区分不同种类生成器的标记。由 ECMAScript 源文本声明的生成器的 [[GeneratorBrand]] 始终为 empty。

27.5.3 Generator 抽象操作

27.5.3.1 GeneratorStart ( generator, generatorBody )

The abstract operation GeneratorStart takes arguments generator (a Generator) and generatorBody (a FunctionBody Parse Node or an Abstract Closure with no parameters) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[GeneratorState]] 是 suspended-start。
  2. 令 genContext 为正在运行的执行上下文。
  3. 将 genContext 的 Generator 组件设为 generator。
  4. 令 closure 为一个无参数的新抽象闭包，捕获 generatorBody 并在被调用时执行以下步骤：
    1. 令 acGenContext 为正在运行的执行上下文。
    2. 令 acGenerator 为 acGenContext 的 Generator 组件。
    3. 如果 generatorBody 是一个 Parse Node，则
      1. 令 result 为 Completion(Evaluation of generatorBody)。
    4. 否则，
      1. 断言：generatorBody 是一个无参数抽象闭包。
      2. 令 result 为 Completion(generatorBody())。
    5. 断言：若我们在此返回，生成器要么抛出了异常，要么执行了隐式或显式的 return。
    6. 将 acGenContext 从执行上下文栈移除，并恢复栈顶执行上下文为正在运行的执行上下文。
    7. 将 acGenerator.[[GeneratorState]] 设为 completed。
    8. 注：一旦生成器进入 completed 状态，它将不再离开该状态，其关联执行上下文不再恢复。此时可丢弃与 acGenerator 相关的任意执行状态。
    9. 如果 result 是一个 normal completion，则
      1. 令 resultValue 为 undefined。
    10. 否则如果 result 是一个 return completion，则
      1. 令 resultValue 为 result.[[Value]]。
    11. 否则，
      1. 断言：result 是一个 throw completion。
      2. 返回 ? result。
    12. 返回 NormalCompletion(CreateIteratorResultObject(resultValue, true))。
  5. 设定 genContext 的代码求值状态，使得当该执行上下文恢复求值时，将无参数调用 closure。
  6. 将 generator.[[GeneratorContext]] 设为 genContext。
  7. 返回 unused。

27.5.3.2 GeneratorValidate ( generator, generatorBrand )

The abstract operation GeneratorValidate takes arguments generator (an ECMAScript language value) and generatorBrand (a String or empty) and returns either a normal completion containing one of suspended-start, suspended-yield, or completed, or a throw completion. It performs the following steps when called:

  1. 执行 ? RequireInternalSlot(generator, [[GeneratorState]])。
  2. 执行 ? RequireInternalSlot(generator, [[GeneratorBrand]])。
  3. 如果 generator.[[GeneratorBrand]] 不等于 generatorBrand，抛出 TypeError 异常。
  4. 断言：generator 也有 [[GeneratorContext]] 内部槽。
  5. 令 state 为 generator.[[GeneratorState]]。
  6. 如果 state 是 executing，抛出 TypeError 异常。
  7. 返回 state。

27.5.3.3 GeneratorResume ( generator, value, generatorBrand )

The abstract operation GeneratorResume takes arguments generator (an ECMAScript language value), value (an ECMAScript language value or empty), and generatorBrand (a String or empty) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. 令 state 为 ? GeneratorValidate(generator, generatorBrand)。
  2. 如果 state 是 completed，返回 CreateIteratorResultObject(undefined, true)。
  3. 断言：state 是 suspended-start 或 suspended-yield。
  4. 令 genContext 为 generator.[[GeneratorContext]]。
  5. 令 methodContext 为正在运行的执行上下文。
  6. 挂起 methodContext。
  7. 将 generator.[[GeneratorState]] 设为 executing。
  8. 将 genContext 压入执行上下文栈；genContext 现在是正在运行的执行上下文。
  9. 恢复 genContext 的挂起求值，使用 NormalCompletion(value) 作为使其挂起的操作的结果。令 result 为恢复计算返回的值。
  10. 断言：当我们在此返回时，genContext 已从执行上下文栈移除且 methodContext 是当前正在运行的执行上下文。
  11. 返回 ? result。

27.5.3.4 GeneratorResumeAbrupt ( generator, abruptCompletion, generatorBrand )

The abstract operation GeneratorResumeAbrupt takes arguments generator (an ECMAScript language value), abruptCompletion (a return completion or a throw completion), and generatorBrand (a String or empty) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. 令 state 为 ? GeneratorValidate(generator, generatorBrand)。
  2. 如果 state 是 suspended-start，则
    1. 将 generator.[[GeneratorState]] 设为 completed。
    2. 注：一旦生成器进入 completed 状态，它将不再离开该状态，其关联执行上下文不再恢复。此时可丢弃与 generator 相关的任意执行状态。
    3. 将 state 设为 completed。
  3. 如果 state 是 completed，则
    1. 如果 abruptCompletion 是一个 return completion，则
      1. 返回 CreateIteratorResultObject(abruptCompletion.[[Value]], true)。
    2. 返回 ? abruptCompletion。
  4. 断言：state 是 suspended-yield。
  5. 令 genContext 为 generator.[[GeneratorContext]]。
  6. 令 methodContext 为正在运行的执行上下文。
  7. 挂起 methodContext。
  8. 将 generator.[[GeneratorState]] 设为 executing。
  9. 将 genContext 压入执行上下文栈；genContext 现在是正在运行的执行上下文。
  10. 恢复 genContext 的挂起求值，使用 abruptCompletion 作为使其挂起的操作的结果。令 result 为恢复计算返回的 Completion Record。
  11. 断言：当我们在此返回时，genContext 已从执行上下文栈移除且 methodContext 是当前正在运行的执行上下文。
  12. 返回 ? result。

27.5.3.5 GetGeneratorKind ( )

The abstract operation GetGeneratorKind takes no arguments and returns non-generator, sync, or async. It performs the following steps when called:

  1. 令 genContext 为正在运行的执行上下文。
  2. 如果 genContext 没有 Generator 组件，返回 non-generator。
  3. 令 generator 为 genContext 的 Generator 组件。
  4. 如果 generator 具有 [[AsyncGeneratorState]] 内部槽，返回 async。
  5. 否则，返回 sync。

27.5.3.6 GeneratorYield ( iteratorResult )

The abstract operation GeneratorYield takes argument iteratorResult (an Object that conforms to the IteratorResult interface) and returns either a normal completion containing an ECMAScript language value or an abrupt completion. It performs the following steps when called:

  1. 令 genContext 为正在运行的执行上下文。
  2. 断言：genContext 是一个生成器的执行上下文。
  3. 令 generator 为 genContext 的 Generator 组件的值。
  4. 断言：GetGeneratorKind() 是 sync。
  5. 将 generator.[[GeneratorState]] 设为 suspended-yield。
  6. 将 genContext 从执行上下文栈移除，恢复栈顶执行上下文为正在运行的执行上下文。
  7. 令 callerContext 为正在运行的执行上下文。
  8. 恢复 callerContext，传入 NormalCompletion(iteratorResult)。如果 genContext 之后再次被恢复，令 resumptionValue 为恢复时使用的 Completion Record。
  9. 断言：若控制流到达此处，则 genContext 再次成为正在运行的执行上下文。
  10. 返回 resumptionValue。

27.5.3.7 Yield ( value )

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

  1. 令 generatorKind 为 GetGeneratorKind()。
  2. 如果 generatorKind 是 async，返回 ? AsyncGeneratorYield(? Await(value))。
  3. 否则，返回 ? GeneratorYield(CreateIteratorResultObject(value, false))。

27.5.3.8 CreateIteratorFromClosure ( closure, generatorBrand, generatorPrototype [ , extraSlots ] )

The abstract operation CreateIteratorFromClosure takes arguments closure (an Abstract Closure with no parameters), generatorBrand (a String or empty), and generatorPrototype (an Object) and optional argument extraSlots (a List of names of internal slots) and returns a Generator. It performs the following steps when called:

  1. 注：closure 可以包含对 Yield 操作的使用，以产出一个 IteratorResult 对象。
  2. 如果 extraSlots 不存在，将 extraSlots 设为一个新的空 List。
  3. 令 internalSlotsList 为 extraSlots 与 « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] » 的列表连接。
  4. 令 generator 为 OrdinaryObjectCreate(generatorPrototype, internalSlotsList)。
  5. 将 generator.[[GeneratorBrand]] 设为 generatorBrand。
  6. 将 generator.[[GeneratorState]] 设为 suspended-start。
  7. 令 callerContext 为正在运行的执行上下文。
  8. 令 calleeContext 为一个新的执行上下文。
  9. 将 calleeContext 的 Function 设为 null。
  10. 将 calleeContext 的 Realm 设为当前 Realm Record。
  11. 将 calleeContext 的 ScriptOrModule 设为 callerContext 的 ScriptOrModule。
  12. 如果 callerContext 尚未被挂起，则挂起 callerContext。
  13. 将 calleeContext 压入执行上下文栈；calleeContext 现在是正在运行的执行上下文。
  14. 执行 GeneratorStart(generator, closure)。
  15. 将 calleeContext 从执行上下文栈移除并恢复 callerContext 为正在运行的执行上下文。
  16. 返回 generator。

27.6 AsyncGenerator 对象

AsyncGenerator 通过调用一个 async 生成器函数创建，并同时符合异步迭代器接口与异步可迭代接口。

AsyncGenerator 实例直接从创建该实例的异步生成器函数 "prototype" 属性的初始值继承属性。AsyncGenerator 实例间接从 %AsyncGeneratorPrototype% 继承属性。

27.6.1 %AsyncGeneratorPrototype% 对象

%AsyncGeneratorPrototype% 对象：

  • 是 %AsyncGeneratorFunction.prototype.prototype%。
  • 是一个普通对象。
  • 不是 AsyncGenerator 实例，并且没有 [[AsyncGeneratorState]] 内部槽。
  • 具有值为 %AsyncIteratorPrototype% 的 [[Prototype]] 内部槽。
  • 具有被所有 AsyncGenerator 实例间接继承的属性。

27.6.1.1 %AsyncGeneratorPrototype%.constructor

%AsyncGeneratorPrototype%.constructor 的初始值是 %AsyncGeneratorFunction.prototype%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.6.1.2 %AsyncGeneratorPrototype%.next ( value )

  1. 令 generator 为 this 值。
  2. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  3. 令 result 为 Completion(AsyncGeneratorValidate(generator, empty))。
  4. IfAbruptRejectPromise(result, promiseCapability)。
  5. 令 state 为 generator.[[AsyncGeneratorState]]。
  6. 如果 state 是 completed，则
    1. 令 iteratorResult 为 CreateIteratorResultObject(undefined, true)。
    2. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »)。
    3. 返回 promiseCapability.[[Promise]]。
  7. 令 completion 为 NormalCompletion(value)。
  8. 执行 AsyncGeneratorEnqueue(generator, completion, promiseCapability)。
  9. 如果 state 是 suspended-start 或 suspended-yield，则
    1. 执行 AsyncGeneratorResume(generator, completion)。
  10. 否则，
    1. 断言：state 是 executing 或 draining-queue。
  11. 返回 promiseCapability.[[Promise]]。

27.6.1.3 %AsyncGeneratorPrototype%.return ( value )

  1. 令 generator 为 this 值。
  2. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  3. 令 result 为 Completion(AsyncGeneratorValidate(generator, empty))。
  4. IfAbruptRejectPromise(result, promiseCapability)。
  5. 令 completion 为 ReturnCompletion(value)。
  6. 执行 AsyncGeneratorEnqueue(generator, completion, promiseCapability)。
  7. 令 state 为 generator.[[AsyncGeneratorState]]。
  8. 如果 state 是 suspended-start 或 completed，则
    1. 将 generator.[[AsyncGeneratorState]] 设为 draining-queue。
    2. 执行 AsyncGeneratorAwaitReturn(generator)。
  9. 否则如果 state 是 suspended-yield，则
    1. 执行 AsyncGeneratorResume(generator, completion)。
  10. 否则，
    1. 断言：state 是 executing 或 draining-queue。
  11. 返回 promiseCapability.[[Promise]]。

27.6.1.4 %AsyncGeneratorPrototype%.throw ( exception )

  1. 令 generator 为 this 值。
  2. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  3. 令 result 为 Completion(AsyncGeneratorValidate(generator, empty))。
  4. IfAbruptRejectPromise(result, promiseCapability)。
  5. 令 state 为 generator.[[AsyncGeneratorState]]。
  6. 如果 state 是 suspended-start，则
    1. 将 generator.[[AsyncGeneratorState]] 设为 completed。
    2. 将 state 设为 completed。
  7. 如果 state 是 completed，则
    1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « exception »)。
    2. 返回 promiseCapability.[[Promise]]。
  8. 令 completion 为 ThrowCompletion(exception)。
  9. 执行 AsyncGeneratorEnqueue(generator, completion, promiseCapability)。
  10. 如果 state 是 suspended-yield，则
    1. 执行 AsyncGeneratorResume(generator, completion)。
  11. 否则，
    1. 断言：state 是 executing 或 draining-queue。
  12. 返回 promiseCapability.[[Promise]]。

27.6.1.5 %AsyncGeneratorPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串 "AsyncGenerator"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.6.2 AsyncGenerator 实例的属性

AsyncGenerator 实例最初按如下描述的内部槽创建：

Table 92: AsyncGenerator 实例的内部槽
内部槽 类型 描述
[[AsyncGeneratorState]] suspended-start, suspended-yield, executing, draining-queue, 或 completed 异步生成器的当前执行状态。
[[AsyncGeneratorContext]] 一个执行上下文 执行该异步生成器代码时使用的执行上下文。
[[AsyncGeneratorQueue]] 一个 AsyncGeneratorRequest Record 的 List 表示恢复该异步生成器请求的记录。除状态转换期间外，当且仅当 [[AsyncGeneratorState]] 为 executing 或 draining-queue 时其非空。
[[GeneratorBrand]] 一个 String 或 empty 用于区分不同种类异步生成器的标记。由 ECMAScript 源文本声明的异步生成器的 [[GeneratorBrand]] 始终为 empty。

27.6.3 AsyncGenerator 抽象操作

27.6.3.1 AsyncGeneratorRequest 记录

AsyncGeneratorRequest 是一个 Record 值，用于存储关于异步生成器应如何恢复的信息，并包含履行或拒绝相应 promise 的能力。

其具有以下字段：

Table 93: AsyncGeneratorRequest Record 字段
字段名 取值 含义
[[Completion]] 一个 Completion Record 用于恢复该异步生成器的 Completion Record。
[[Capability]] 一个 PromiseCapability Record 与此请求关联的 promise 能力。

27.6.3.2 AsyncGeneratorStart ( generator, generatorBody )

The abstract operation AsyncGeneratorStart takes arguments generator (an AsyncGenerator) and generatorBody (a FunctionBody Parse Node or an Abstract Closure with no parameters) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 suspended-start。
  2. 令 genContext 为正在运行的执行上下文。
  3. 将 genContext 的 Generator 组件设为 generator。
  4. 令 closure 为一个无参数的新抽象闭包，捕获 generatorBody 并在被调用时执行以下步骤：
    1. 令 acGenContext 为正在运行的执行上下文。
    2. 令 acGenerator 为 acGenContext 的 Generator 组件。
    3. 如果 generatorBody 是一个 Parse Node，则
      1. 令 result 为 Completion(Evaluation of generatorBody)。
    4. 否则，
      1. 断言：generatorBody 是一个无参数抽象闭包。
      2. 令 result 为 Completion(generatorBody())。
    5. 断言：若我们在此返回，异步生成器要么抛出异常，要么执行了隐式或显式的 return。
    6. 将 acGenContext 从执行上下文栈移除，并恢复栈顶执行上下文为正在运行的执行上下文。
    7. 将 acGenerator.[[AsyncGeneratorState]] 设为 draining-queue。
    8. 如果 result 是一个 normal completion，将 result 设为 NormalCompletion(undefined)。
    9. 如果 result 是一个 return completion，将 result 设为 NormalCompletion(result.[[Value]])。
    10. 执行 AsyncGeneratorCompleteStep(acGenerator, result, true)。
    11. 执行 AsyncGeneratorDrainQueue(acGenerator)。
    12. 返回 NormalCompletion(undefined)。
  5. 设定 genContext 的代码求值状态，使得当该执行上下文恢复求值时，将无参数调用 closure。
  6. 将 generator.[[AsyncGeneratorContext]] 设为 genContext。
  7. 将 generator.[[AsyncGeneratorQueue]] 设为一个新的空 List。
  8. 返回 unused。

27.6.3.3 AsyncGeneratorValidate ( generator, generatorBrand )

The abstract operation AsyncGeneratorValidate takes arguments generator (an ECMAScript language value) and generatorBrand (a String or empty) and returns either a normal completion containing unused or a throw completion. It performs the following steps when called:

  1. 执行 ? RequireInternalSlot(generator, [[AsyncGeneratorContext]])。
  2. 执行 ? RequireInternalSlot(generator, [[AsyncGeneratorState]])。
  3. 执行 ? RequireInternalSlot(generator, [[AsyncGeneratorQueue]])。
  4. 如果 generator.[[GeneratorBrand]] 不等于 generatorBrand，抛出 TypeError 异常。
  5. 返回 unused。

27.6.3.4 AsyncGeneratorEnqueue ( generator, completion, promiseCapability )

The abstract operation AsyncGeneratorEnqueue takes arguments generator (an AsyncGenerator), completion (a Completion Record), and promiseCapability (a PromiseCapability Record) and returns unused. It performs the following steps when called:

  1. 令 request 为 AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }。
  2. 将 request 追加到 generator.[[AsyncGeneratorQueue]]。
  3. 返回 unused。

27.6.3.5 AsyncGeneratorCompleteStep ( generator, completion, done [ , realm ] )

The abstract operation AsyncGeneratorCompleteStep takes arguments generator (an AsyncGenerator), completion (a Completion Record), and done (a Boolean) and optional argument realm (a Realm Record) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorQueue]] 非空。
  2. 令 next 为 generator.[[AsyncGeneratorQueue]] 的第一个元素。
  3. 移除 generator.[[AsyncGeneratorQueue]] 的第一个元素。
  4. 令 promiseCapability 为 next.[[Capability]]。
  5. 令 value 为 completion.[[Value]]。
  6. 如果 completion 是一个 throw completion，则
    1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « value »)。
  7. 否则，
    1. 断言：completion 是一个 normal completion。
    2. 如果存在 realm，则
      1. 令 oldRealm 为正在运行的执行上下文的 Realm。
      2. 将正在运行的执行上下文的 Realm 设为 realm。
      3. 令 iteratorResult 为 CreateIteratorResultObject(value, done)。
      4. 将正在运行的执行上下文的 Realm 设回 oldRealm。
    3. 否则，
      1. 令 iteratorResult 为 CreateIteratorResultObject(value, done)。
    4. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »)。
  8. 返回 unused。

27.6.3.6 AsyncGeneratorResume ( generator, completion )

The abstract operation AsyncGeneratorResume takes arguments generator (an AsyncGenerator) and completion (a Completion Record) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 suspended-start 或 suspended-yield。
  2. 令 genContext 为 generator.[[AsyncGeneratorContext]]。
  3. 令 callerContext 为正在运行的执行上下文。
  4. 挂起 callerContext。
  5. 将 generator.[[AsyncGeneratorState]] 设为 executing。
  6. 将 genContext 压入执行上下文栈；genContext 现在是正在运行的执行上下文。
  7. 恢复 genContext 的挂起求值，使用 completion 作为使其挂起的操作的结果。令 result 为恢复计算返回的 Completion Record。
  8. 断言：result 永不是一个 abrupt completion。
  9. 断言：当我们在此返回时，genContext 已从执行上下文栈移除且 callerContext 是当前正在运行的执行上下文。
  10. 返回 unused。

27.6.3.7 AsyncGeneratorUnwrapYieldResumption ( resumptionValue )

The abstract operation AsyncGeneratorUnwrapYieldResumption takes argument resumptionValue (a Completion Record) and returns either a normal completion containing an ECMAScript language value or an abrupt completion. It performs the following steps when called:

  1. 如果 resumptionValue 不是一个 return completion，返回 ? resumptionValue。
  2. 令 awaited 为 Completion(Await(resumptionValue.[[Value]]))。
  3. 如果 awaited 是一个 throw completion，返回 ? awaited。
  4. 断言：awaited 是一个 normal completion。
  5. 返回 ReturnCompletion(awaited.[[Value]])。

27.6.3.8 AsyncGeneratorYield ( value )

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

  1. 令 genContext 为正在运行的执行上下文。
  2. 断言：genContext 是一个生成器的执行上下文。
  3. 令 generator 为 genContext 的 Generator 组件的值。
  4. 断言：GetGeneratorKind() 是 async。
  5. 令 completion 为 NormalCompletion(value)。
  6. 断言：执行上下文栈至少有两个元素。
  7. 令 previousContext 为执行上下文栈倒数第二个元素。
  8. 令 previousRealm 为 previousContext 的 Realm。
  9. 执行 AsyncGeneratorCompleteStep(generator, completion, false, previousRealm)。
  10. 令 queue 为 generator.[[AsyncGeneratorQueue]]。
  11. 如果 queue 非空，则
    1. 注：执行在不挂起生成器的情况下继续。
    2. 令 toYield 为 queue 的第一个元素。
    3. 令 resumptionValue 为 Completion(toYield.[[Completion]])。
    4. 返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。
  12. 否则，
    1. 将 generator.[[AsyncGeneratorState]] 设为 suspended-yield。
    2. 将 genContext 从执行上下文栈移除并恢复栈顶执行上下文为正在运行的执行上下文。
    3. 令 callerContext 为正在运行的执行上下文。
    4. 恢复 callerContext，传入 undefined。如果 genContext 之后再次被恢复，令 resumptionValue 为恢复时使用的 Completion Record。
    5. 断言：若控制流到达此处，则 genContext 再次成为正在运行的执行上下文。
    6. 返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。

27.6.3.9 AsyncGeneratorAwaitReturn ( generator )

The abstract operation AsyncGeneratorAwaitReturn takes argument generator (an AsyncGenerator) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 draining-queue。
  2. 令 queue 为 generator.[[AsyncGeneratorQueue]]。
  3. 断言：queue 非空。
  4. 令 next 为 queue 的第一个元素。
  5. 令 completion 为 Completion(next.[[Completion]])。
  6. 断言：completion 是一个 return completion。
  7. 令 promiseCompletion 为 Completion(PromiseResolve(%Promise%, completion.[[Value]]))。
  8. 如果 promiseCompletion 是一个 abrupt completion，则
    1. 执行 AsyncGeneratorCompleteStep(generator, promiseCompletion, true)。
    2. 执行 AsyncGeneratorDrainQueue(generator)。
    3. 返回 unused。
  9. 断言：promiseCompletion 是一个 normal completion。
  10. 令 promise 为 promiseCompletion.[[Value]]。
  11. 令 fulfilledClosure 为一个具有参数 (value) 的新抽象闭包，捕获 generator 并在被调用时执行以下步骤：
    1. 断言：generator.[[AsyncGeneratorState]] 是 draining-queue。
    2. 令 result 为 NormalCompletion(value)。
    3. 执行 AsyncGeneratorCompleteStep(generator, result, true)。
    4. 执行 AsyncGeneratorDrainQueue(generator)。
    5. 返回 NormalCompletion(undefined)。
  12. 令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
  13. 令 rejectedClosure 为一个具有参数 (reason) 的新抽象闭包，捕获 generator 并在被调用时执行以下步骤：
    1. 断言：generator.[[AsyncGeneratorState]] 是 draining-queue。
    2. 令 result 为 ThrowCompletion(reason)。
    3. 执行 AsyncGeneratorCompleteStep(generator, result, true)。
    4. 执行 AsyncGeneratorDrainQueue(generator)。
    5. 返回 NormalCompletion(undefined)。
  14. 令 onRejected 为 CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
  15. 执行 PerformPromiseThen(promise, onFulfilled, onRejected)。
  16. 返回 unused。

27.6.3.10 AsyncGeneratorDrainQueue ( generator )

The abstract operation AsyncGeneratorDrainQueue takes argument generator (an AsyncGenerator) and returns unused. 它会耗尽生成器的 AsyncGeneratorQueue，直到遇到持有 return completion 的 AsyncGeneratorRequest。 It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 draining-queue。
  2. 令 queue 为 generator.[[AsyncGeneratorQueue]]。
  3. 当 queue 非空时重复，
    1. 令 next 为 queue 的第一个元素。
    2. 令 completion 为 Completion(next.[[Completion]])。
    3. 如果 completion 是一个 return completion，则
      1. 执行 AsyncGeneratorAwaitReturn(generator)。
      2. 返回 unused。
    4. 否则，
      1. 如果 completion 是一个 normal completion，则
        1. 将 completion 设为 NormalCompletion(undefined)。
      2. 执行 AsyncGeneratorCompleteStep(generator, completion, true)。
  4. 将 generator.[[AsyncGeneratorState]] 设为 completed。
  5. 返回 unused。

27.6.3.11 CreateAsyncIteratorFromClosure ( closure, generatorBrand, generatorPrototype )

The abstract operation CreateAsyncIteratorFromClosure takes arguments closure (an Abstract Closure with no parameters), generatorBrand (a String or empty), and generatorPrototype (an Object) and returns an AsyncGenerator. It performs the following steps when called:

  1. 注：closure 可以包含 Await 操作的使用以及 Yield 操作以产出一个 IteratorResult 对象。
  2. 令 internalSlotsList 为 « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] »。
  3. 令 generator 为 OrdinaryObjectCreate(generatorPrototype, internalSlotsList)。
  4. 将 generator.[[GeneratorBrand]] 设为 generatorBrand。
  5. 将 generator.[[AsyncGeneratorState]] 设为 suspended-start。
  6. 令 callerContext 为正在运行的执行上下文。
  7. 令 calleeContext 为一个新的执行上下文。
  8. 将 calleeContext 的 Function 设为 null。
  9. 将 calleeContext 的 Realm 设为当前 Realm Record。
  10. 将 calleeContext 的 ScriptOrModule 设为 callerContext 的 ScriptOrModule。
  11. 如果 callerContext 尚未被挂起，则挂起 callerContext。
  12. 将 calleeContext 压入执行上下文栈；calleeContext 现在是正在运行的执行上下文。
  13. 执行 AsyncGeneratorStart(generator, closure)。
  14. 将 calleeContext 从执行上下文栈移除并恢复 callerContext 为正在运行的执行上下文。
  15. 返回 generator。

27.7 AsyncFunction 对象

AsyncFunction 通常通过求值 AsyncFunctionDeclaration、AsyncFunctionExpression、AsyncMethod、AsyncArrowFunction 创建。也可通过调用内在对象 %AsyncFunction% 创建。

27.7.1 AsyncFunction 构造函数

AsyncFunction 构造函数：

  • 是 %AsyncFunction%。
  • 是 Function 的子类。
  • 当以函数（而非构造函数）方式调用时创建并初始化一个新的 AsyncFunction。故函数调用 AsyncFunction(…) 等价于以相同参数的对象创建表达式 new AsyncFunction(…)。
  • 可用作类定义中 extends 子句的值。意图继承指定 AsyncFunction 行为的子类构造函数必须包含对 AsyncFunction 构造函数的 super 调用，以创建并初始化具有内建异步函数行为所需内部槽的子类实例。所有用于定义异步函数对象的 ECMAScript 语法形式都会创建 AsyncFunction 的直接实例。没有语法手段创建 AsyncFunction 子类的实例。

27.7.1.1 AsyncFunction ( ...parameterArgs, bodyArg )

最后一个参数（如果存在）指定异步函数的函数体（可执行代码）。之前的任意参数指定形式参数。

该函数被调用时执行以下步骤：

  1. 令 C 为活动函数对象。
  2. 如果 bodyArg 不存在，将 bodyArg 设为空字符串。
  3. 返回 ? CreateDynamicFunction(C, NewTarget, async, parameterArgs, bodyArg)。
 Note
参见 20.2.1.1 的注。

27.7.2 AsyncFunction 构造函数的属性

AsyncFunction 构造函数：

  • 是一个继承自 Function 构造函数的标准内建函数对象。
  • 具有值为 %Function% 的 [[Prototype]] 内部槽。
  • 具有值为 1𝔽 的 "length" 属性。
  • 具有值为 "AsyncFunction" 的 "name" 属性。
  • 具有以下属性：

27.7.2.1 AsyncFunction.prototype

AsyncFunction.prototype 的初始值是 AsyncFunction 原型对象。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

27.7.3 AsyncFunction 原型对象的属性

AsyncFunction 原型对象：

27.7.3.1 AsyncFunction.prototype.constructor

AsyncFunction.prototype.constructor 的初始值是 %AsyncFunction%。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.7.3.2 AsyncFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是字符串 "AsyncFunction"。

该属性具有 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

27.7.4 AsyncFunction 实例

每个 AsyncFunction 实例都是一个 ECMAScript 函数对象，并拥有 Table 28 中列出的内部槽。所有此类实例的 [[IsClassConstructor]] 内部槽的值为 false。AsyncFunction 实例不是构造函数，且没有 [[Construct]] 内部方法。由于不可构造，AsyncFunction 实例没有 prototype 属性。

每个 AsyncFunction 实例具有以下自有属性：

27.7.4.1 length

20.2.4.1 中给出的 Function 实例 "length" 属性规范同样适用于 AsyncFunction 实例。

27.7.4.2 name

20.2.4.2 中给出的 Function 实例 "name" 属性规范同样适用于 AsyncFunction 实例。

27.7.5 Async 函数的抽象操作

27.7.5.1 AsyncFunctionStart ( promiseCapability, asyncFunctionBody )

The abstract operation AsyncFunctionStart takes arguments promiseCapability (a PromiseCapability Record) and asyncFunctionBody (a FunctionBody Parse Node, an ExpressionBody Parse Node, or an Abstract Closure with no parameters) and returns unused. It performs the following steps when called:

  1. 令 runningContext 为正在运行的执行上下文。
  2. 令 asyncContext 为 runningContext 的一个副本。
  3. 注：复制执行状态是 AsyncBlockStart 恢复其执行所需。恢复一个当前正在执行的上下文是未定义的。
  4. 执行 AsyncBlockStart(promiseCapability, asyncFunctionBody, asyncContext)。
  5. 返回 unused。

27.7.5.2 AsyncBlockStart ( promiseCapability, asyncBody, asyncContext )

The abstract operation AsyncBlockStart takes arguments promiseCapability (a PromiseCapability Record), asyncBody (a Parse Node or an Abstract Closure with no parameters), and asyncContext (an execution context) and returns unused. It performs the following steps when called:

  1. 令 runningContext 为正在运行的执行上下文。
  2. 令 closure 为一个无参数的新抽象闭包，捕获 promiseCapability 与 asyncBody 并在被调用时执行以下步骤：
    1. 令 acAsyncContext 为正在运行的执行上下文。
    2. 如果 asyncBody 是一个 Parse Node，则
      1. 令 result 为 Completion(Evaluation of asyncBody)。
    3. 否则，
      1. 断言：asyncBody 是一个无参数抽象闭包。
      2. 令 result 为 Completion(asyncBody())。
    4. 断言：若我们在此返回，异步函数要么抛出异常，要么执行了隐式或显式 return；所有等待均已完成。
    5. 将 acAsyncContext 从执行上下文栈移除，并恢复栈顶执行上下文为正在运行的执行上下文。
    6. 如果 result 是一个 normal completion，则
      1. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « undefined »)。
    7. 否则如果 result 是一个 return completion，则
      1. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « result.[[Value]] »)。
    8. 否则，
      1. 断言：result 是一个 throw completion。
      2. 执行 ! Call(promiseCapability.[[Reject]], undefined, « result.[[Value]] »)。
    9. 返回 NormalCompletion(unused)。
  3. 设定 asyncContext 的代码求值状态，使得当该执行上下文恢复求值时，将无参数调用 closure。
  4. 将 asyncContext 压入执行上下文栈；asyncContext 现在是正在运行的执行上下文。
  5. 恢复 asyncContext 的挂起求值。令 result 为恢复计算返回的值。
  6. 断言：当我们在此返回时，asyncContext 已从执行上下文栈移除且 runningContext 是当前正在运行的执行上下文。
  7. 断言：result 是一个取值为 unused 的 normal completion。该值的可能来源是 Await，或当异步函数未等待任何内容时，上文步骤 2.i。
  8. 返回 unused。

27.7.5.3 Await ( value )

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

  1. 令 asyncContext 为正在运行的执行上下文。
  2. 令 promise 为 ? PromiseResolve(%Promise%, value)。
  3. 令 fulfilledClosure 为一个具有参数 (v) 的新抽象闭包，捕获 asyncContext 并在被调用时执行以下步骤：
    1. 令 prevContext 为正在运行的执行上下文。
    2. 挂起 prevContext。
    3. 将 asyncContext 压入执行上下文栈；asyncContext 现在是正在运行的执行上下文。
    4. 恢复 asyncContext 的挂起求值，使用 NormalCompletion(v) 作为使其挂起的操作的结果。
    5. 断言：当我们到达此步骤时，asyncContext 已从执行上下文栈移除且 prevContext 是当前正在运行的执行上下文。
    6. 返回 NormalCompletion(undefined)。
  4. 令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
  5. 令 rejectedClosure 为一个具有参数 (reason) 的新抽象闭包，捕获 asyncContext 并在被调用时执行以下步骤：
    1. 令 prevContext 为正在运行的执行上下文。
    2. 挂起 prevContext。
    3. 将 asyncContext 压入执行上下文栈；asyncContext 现在是正在运行的执行上下文。
    4. 恢复 asyncContext 的挂起求值，使用 ThrowCompletion(reason) 作为使其挂起的操作的结果。
    5. 断言：当我们到达此步骤时，asyncContext 已从执行上下文栈移除且 prevContext 是当前正在运行的执行上下文。
    6. 返回 NormalCompletion(undefined)。
  6. 令 onRejected 为 CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
  7. 执行 PerformPromiseThen(promise, onFulfilled, onRejected)。
  8. 将 asyncContext 从执行上下文栈移除并恢复栈顶执行上下文为正在运行的执行上下文。
  9. 令 callerContext 为正在运行的执行上下文。
  10. 恢复 callerContext，传入 empty。如果 asyncContext 之后再次被恢复，令 completion 为恢复时使用的 Completion Record。
  11. 断言：若控制流到达此处，则 asyncContext 再次成为正在运行的执行上下文。
  12. 返回 completion。