27 控制抽象对象

27.1 迭代

27.1.1 通用迭代接口

接口是一组属性键，其关联值匹配特定规范。任何提供接口规范所描述的全部属性的对象都符合该接口。接口并不由一个不同的对象来表示。可以有许多分别实现的对象符合任一接口。单个对象可以符合多个接口。

27.1.1.1 可迭代接口

可迭代接口包含 Table 78 中描述的属性：

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

27.1.1.2 迭代器接口

实现迭代器接口的对象必须包含 Table 79 中的属性。这样的对象也可以实现 Table 80 中的属性。

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

可以向 next 函数传递实参，但这些实参的解释和有效性取决于目标迭代器。for-of 语句和迭代器的其他常见使用者不会传递任何实参，因此期望以这种方式使用的迭代器对象必须准备好处理无实参调用。
Table 80: 迭代器接口的可选属性
属性 值 要求
"return" 一个返回 IteratorResult 对象的函数 返回的对象必须符合 IteratorResult 接口。调用此方法会通知迭代器对象，调用者不打算再对该迭代器调用任何 next 方法。返回的 IteratorResult 对象通常会有一个值为 true 的 "done" 属性，以及一个 "value" 属性，其值为作为 return 方法实参传入的值。不过，此要求不强制执行。
"throw" 一个返回 IteratorResult 对象的函数 返回的对象必须符合 IteratorResult 接口。调用此方法会通知迭代器对象，调用者已检测到错误条件。实参可用于标识该错误条件，通常会是一个异常对象。典型的响应是 throw 作为实参传入的值。如果该方法不 throw，则返回的 IteratorResult 对象通常会有一个值为 true 的 "done" 属性。
Note 2

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

27.1.1.3 异步可迭代接口

异步可迭代接口包含 Table 81 中描述的属性：

Table 81: 异步可迭代接口的必需属性
属性 值 要求
%Symbol.asyncIterator% 一个返回异步迭代器对象的函数 返回的对象必须符合异步迭代器接口。

27.1.1.4 异步迭代器接口

实现异步迭代器接口的对象必须包含 Table 82 中的属性。这样的对象也可以实现 Table 83 中的属性。

Table 82: 异步迭代器接口的必需属性
属性 值 要求
"next" 一个返回 IteratorResult 对象 promise 的函数

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

此外，作为兑现值的 IteratorResult 对象应有一个 "value" 属性，其值不是 promise（也不是“thenable”）。不过，此要求也不强制执行。
Note 1

可以向 next 函数传递实参，但这些实参的解释和有效性取决于目标异步迭代器。for-await-of 语句和异步迭代器的其他常见使用者不会传递任何实参，因此期望以这种方式使用的异步迭代器对象必须准备好处理无实参调用。
Table 83: 异步迭代器接口的可选属性
属性 值 要求
"return" 一个返回 IteratorResult 对象 promise 的函数

返回的 promise 在兑现时，必须以一个符合 IteratorResult 接口的对象兑现。调用此方法会通知异步迭代器对象，调用者不打算再对该异步迭代器调用任何 next 方法。返回的 promise 将以一个 IteratorResult 对象兑现，该对象通常会有一个值为 true 的 "done" 属性，以及一个 "value" 属性，其值为作为 return 方法实参传入的值。不过，此要求不强制执行。

此外，作为兑现值的 IteratorResult 对象应有一个 "value" 属性，其值不是 promise（也不是“thenable”）。如果实参值按典型方式使用，那么如果它是一个被拒绝的 promise，则应返回一个以相同原因拒绝的 promise；如果它是一个已兑现的 promise，则应将其兑现值用作返回的 promise 的 IteratorResult 对象兑现值的 "value" 属性。不过，这些要求也不强制执行。
"throw" 一个返回 IteratorResult 对象 promise 的函数

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

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

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

27.1.1.5 IteratorResult 接口

IteratorResult 接口包含 Table 84 中列出的属性：

Table 84: IteratorResult 接口属性
属性 值 要求
"done" 一个布尔值 这是迭代器 next 方法调用的结果状态。如果已到达迭代器的末尾，"done" 为 true。如果尚未到达末尾，"done" 为 false，并且有一个值可用。如果 "done" 属性（自有或继承的）不存在，则认为其值为 false。
"value" 一个 ECMAScript 语言值 如果 done 为 false，这是当前迭代元素的值。如果 done 为 true，这是迭代器的返回值（如果它提供了一个）。如果迭代器没有返回值，则 "value" 为 undefined。在这种情况下，如果符合接口的对象没有继承显式的 "value" 属性，则该对象可以不存在 "value" 属性。

27.1.2 迭代器辅助对象

迭代器辅助对象是一个普通对象，表示对某个特定源迭代器对象的惰性变换。Iterator Helper 对象没有具名构造器。Iterator Helper 对象是通过调用 Iterator 实例对象的某些方法创建的。

27.1.2.1 %IteratorHelperPrototype% 对象

%IteratorHelperPrototype% 对象：

27.1.2.1.1 %IteratorHelperPrototype%.next ( )

  1. 返回 ? GeneratorResume(this value, undefined, "Iterator Helper")。

27.1.2.1.2 %IteratorHelperPrototype%.return ( )

  1. 令 obj 为 this 值。
  2. 执行 ? RequireInternalSlot(obj, [[UnderlyingIterators]])。
  3. 断言：obj 具有 [[GeneratorState]] 内部槽。
  4. 如果 obj.[[GeneratorState]] 是 suspended-start，则
    1. 将 obj.[[GeneratorState]] 设为 completed。
    2. 注：一旦生成器进入 completed 状态，它就永远不会离开该状态，并且其关联的执行上下文永远不会恢复。此时可以丢弃与 obj 关联的任何执行状态。
    3. 执行 ? IteratorCloseAll(obj.[[UnderlyingIterators]], NormalCompletion(unused))。
    4. 返回 CreateIteratorResultObject(undefined, true)。
  5. 令 completion 为 ReturnCompletion(undefined)。
  6. 返回 ? GeneratorResumeAbrupt(obj, completion, "Iterator Helper")。

27.1.2.1.3 %IteratorHelperPrototype% [ %Symbol.toStringTag% ]

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

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

27.1.3 Iterator 对象

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.concat ( ...items )

  1. 令 iterables 为一个新的空 List。
  2. 对于 items 的每个元素 item，执行
    1. 如果 item 不是 Object，则抛出 TypeError 异常。
    2. 令 method 为 ? GetMethod(item, %Symbol.iterator%)。
    3. 如果 method 是 undefined，则抛出 TypeError 异常。
    4. 将 Record { [[OpenMethod]]: method, [[Iterable]]: item } 追加到 iterables。
  3. 令 closure 为一个新的无参数抽象闭包，它捕获 iterables，并在被调用时执行以下步骤：
    1. 对于 iterables 的每个 Record iterable，执行
      1. 令 iter 为 ? Call(iterable.[[OpenMethod]], iterable.[[Iterable]])。
      2. 如果 iter 不是 Object，则抛出 TypeError 异常。
      3. 令 iteratorRecord 为 ? GetIteratorDirect(iter)。
      4. 令 innerAlive 为 true。
      5. 重复，当 innerAlive 为 true 时，
        1. 令 innerValue 为 ? IteratorStepValue(iteratorRecord)。
        2. 如果 innerValue 是 done，则
          1. 将 innerAlive 设为 false。
        3. 否则，
          1. 令 completion 为 Completion(Yield(innerValue))。
          2. 如果 completion 是 abrupt completion，则
            1. 返回 ? IteratorClose(iteratorRecord, completion)。
    2. 返回 ReturnCompletion(undefined)。
  4. 令 gen 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
  5. 将 gen.[[UnderlyingIterators]] 设为一个新的空 List。
  6. 返回 gen。

27.1.3.2.2 Iterator.from ( obj )

  1. 令 iteratorRecord 为 ? GetIteratorFlattenable(obj, 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.2.1 %WrapForValidIteratorPrototype% 对象

%WrapForValidIteratorPrototype% 对象：

27.1.3.2.2.1.1 %WrapForValidIteratorPrototype%.next ( )

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

27.1.3.2.2.1.2 %WrapForValidIteratorPrototype%.return ( )

  1. 令 obj 为 this 值。
  2. 执行 ? RequireInternalSlot(obj, [[Iterated]])。
  3. 令 iterator 为 obj.[[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.3 Iterator.prototype

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

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

27.1.3.3 Iterator 原型对象的属性

Iterator 原型对象：

Note

本规范中定义的所有实现迭代器接口的对象也都继承自 %Iterator.prototype%。ECMAScript 代码也可以定义继承自 %Iterator.prototype% 的对象。%Iterator.prototype% 提供了一个位置，可在其中添加适用于所有迭代器对象的其他方法。

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

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

27.1.3.3.1 Iterator.prototype.constructor

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

27.1.3.3.1.1 get Iterator.prototype.constructor

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

  1. 返回 %Iterator%。

27.1.3.3.1.2 set Iterator.prototype.constructor

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

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

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

27.1.3.3.2 Iterator.prototype.drop ( limit )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[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(obj)。
  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%, « [[UnderlyingIterators]] »)。
  12. 将 result.[[UnderlyingIterators]] 设为 « iterated »。
  13. 返回 result。

27.1.3.3.3 Iterator.prototype.every ( predicate )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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.3.3.4 Iterator.prototype.filter ( predicate )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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%, « [[UnderlyingIterators]] »)。
  8. 将 result.[[UnderlyingIterators]] 设为 « iterated »。
  9. 返回 result。

27.1.3.3.5 Iterator.prototype.find ( predicate )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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.3.3.6 Iterator.prototype.flatMap ( mapper )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(mapper) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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%, « [[UnderlyingIterators]] »)。
  8. 将 result.[[UnderlyingIterators]] 设为 « iterated »。
  9. 返回 result。

27.1.3.3.7 Iterator.prototype.forEach ( procedure )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(procedure) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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.3.3.8 Iterator.prototype.map ( mapper )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(mapper) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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%, « [[UnderlyingIterators]] »)。
  8. 将 result.[[UnderlyingIterators]] 设为 « iterated »。
  9. 返回 result。

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

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(reducer) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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.3.3.10 Iterator.prototype.some ( predicate )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
  4. 如果 IsCallable(predicate) 为 false，则
    1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
    2. 返回 ? IteratorClose(iterated, error)。
  5. 将 iterated 设为 ? GetIteratorDirect(obj)。
  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.3.3.11 Iterator.prototype.take ( limit )

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

  1. 令 obj 为 this 值。
  2. 如果 obj 不是 Object，则抛出 TypeError 异常。
  3. 令 iterated 为 Iterator Record { [[Iterator]]: obj, [[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(obj)。
  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%, « [[UnderlyingIterators]] »)。
  12. 将 result.[[UnderlyingIterators]] 设为 « iterated »。
  13. 返回 result。

27.1.3.3.12 Iterator.prototype.toArray ( )

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

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

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

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

  1. 返回 this 值。

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

27.1.3.3.14 Iterator.prototype [ %Symbol.toStringTag% ]

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

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

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

  1. 返回 "Iterator"。

27.1.3.3.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.4 %AsyncIteratorPrototype% 对象

%AsyncIteratorPrototype% 对象：

Note

本规范中定义的所有实现异步迭代器接口的对象也都继承自 %AsyncIteratorPrototype%。ECMAScript 代码也可以定义继承自 %AsyncIteratorPrototype% 的对象。%AsyncIteratorPrototype% 对象提供了一个位置，可在其中添加适用于所有异步迭代器对象的其他方法。

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

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

  1. 返回 this 值。

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

27.1.5 Async-from-Sync Iterator 对象

Async-from-Sync Iterator 对象是适配特定同步迭代器的异步迭代器。Async-from-Sync Iterator 对象永远不能被 ECMAScript 代码直接访问。Async-from-Sync Iterator 对象没有具名构造器。Async-from-Sync Iterator 对象是由 CreateAsyncFromSyncIterator 抽象操作在需要时创建的。

27.1.5.1 CreateAsyncFromSyncIterator ( syncIteratorRecord )

The abstract operation CreateAsyncFromSyncIterator takes argument syncIteratorRecord (一个 Iterator Record) and returns 一个 Iterator Record. 它用于从同步 Iterator Record 创建异步 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.5.2 %AsyncFromSyncIteratorPrototype% 对象

%AsyncFromSyncIteratorPrototype% 对象：

27.1.5.2.1 %AsyncFromSyncIteratorPrototype%.next ( [ value ] )

  1. 令 obj 为 this 值。
  2. 断言：obj 是具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 obj.[[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.5.2.2 %AsyncFromSyncIteratorPrototype%.return ( [ value ] )

  1. 令 obj 为 this 值。
  2. 断言：obj 是具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 obj.[[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.5.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [ value ] )

Note
在本规范中，value 始终会被提供，但为与 %AsyncFromSyncIteratorPrototype%.return ( [ value ] ) 保持一致而保留为可选。
  1. 令 obj 为 this 值。
  2. 断言：obj 是具有 [[SyncIteratorRecord]] 内部槽的 Object。
  3. 令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
  4. 令 syncIteratorRecord 为 obj.[[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.5.3 Async-from-Sync Iterator 实例的属性

Async-from-Sync Iterator 实例是普通对象，继承来自 %AsyncFromSyncIteratorPrototype% 内在对象的属性。Async-from-Sync Iterator 实例最初会以 Table 85 中列出的内部槽创建。

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

27.1.5.4 AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection )

The abstract operation AsyncFromSyncIteratorContinuation takes arguments result (一个 Object), promiseCapability (内在 %Promise% 的 PromiseCapability Record), syncIteratorRecord (一个 Iterator Record), and closeOnRejection (一个 Boolean) and returns 一个 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. 注：当 IteratorResult 对象所产出的 "value" 属性是一个被拒绝的 promise 时，onRejected 用于关闭 Iterator。
  14. 执行 PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability)。
  15. 返回 promiseCapability.[[Promise]]。

27.2 Promise 对象

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

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

  • 如果 p.then(f, r) 会立即将一个调用函数 f 的 Job 入队，则 promise p 为 fulfilled。
  • 如果 p.then(f, r) 会立即将一个调用函数 r 的 Job 入队，则 promise p 为 rejected。
  • 如果一个 promise 既不是 fulfilled 也不是 rejected，则它为 pending。

如果一个 promise 不是 pending，也就是说如果它是 fulfilled 或 rejected，则称该 promise 为 settled。

如果一个 promise 已 settled，或者已被“锁定”以匹配另一个 promise 的状态，则该 promise 为 resolved。尝试 resolve 或 reject 一个已 resolved 的 promise 不会产生任何效果。如果一个 promise 不是 resolved，则它为 unresolved。一个 unresolved 的 promise 总是处于 pending 状态。一个 resolved 的 promise 可以是 pending、fulfilled 或 rejected。

27.2.1 Promise 抽象操作

27.2.1.1 PromiseCapability Record

PromiseCapability Record 是一种 Record 值，用于封装一个 Promise 或类 promise 对象，以及能够 resolve 或 reject 该 promise 的函数。PromiseCapability Record 由 NewPromiseCapability 抽象操作产生。

PromiseCapability Record 具有 Table 86 中列出的字段。

Table 86: 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. 将 value 设为 ! value。

27.2.1.2 PromiseReaction Record

PromiseReaction Record 是一种 Record 值，用于存储关于 promise 在以给定值变为 resolved 或 rejected 时应如何反应的信息。PromiseReaction Record 由 PerformPromiseThen 抽象操作创建，并由 NewPromiseReactionJob 返回的 Abstract Closure 使用。

PromiseReaction Record 具有 Table 87 中列出的字段。

Table 87: PromiseReaction Record 字段
字段名 值 含义
[[Capability]] 一个 PromiseCapability Record 或 undefined 此记录为其提供 reaction 处理器的 promise 的 capability。
[[Type]] fulfill 或 reject 当 [[Handler]] 为 empty 时，[[Type]] 用于允许特定于 settled 类型的行为。
[[Handler]] 一个 JobCallback Record 或 empty 应应用于传入值的函数，其返回值将决定派生 promise 会发生什么。如果 [[Handler]] 为 empty，则改用一个取决于 [[Type]] 值的函数。

27.2.1.3 CreateResolvingFunctions ( toResolve )

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

  1. 令 promiseOrEmpty 为 Record { [[Value]]: toResolve }。
  2. 令 resolveSteps 为一个新的 Abstract Closure，带有参数 (resolution)，它捕获 promiseOrEmpty，并在被调用时执行以下步骤：
    1. 如果 promiseOrEmpty.[[Value]] 是 empty，返回 undefined。
    2. 令 promise 为 promiseOrEmpty.[[Value]]。
    3. 将 promiseOrEmpty.[[Value]] 设为 empty。
    4. 如果 SameValue(resolution, promise) 为 true，则
      1. 令 selfResolutionError 为一个新创建的 TypeError 对象。
      2. 执行 RejectPromise(promise, selfResolutionError)。
      3. 返回 undefined。
    5. 如果 resolution 不是 Object，则
      1. 执行 FulfillPromise(promise, resolution)。
      2. 返回 undefined。
    6. 令 then 为 Completion(Get(resolution, "then"))。
    7. 如果 then 是 abrupt completion，则
      1. 执行 RejectPromise(promise, then.[[Value]])。
      2. 返回 undefined。
    8. 令 thenAction 为 then.[[Value]]。
    9. 如果 IsCallable(thenAction) 为 false，则
      1. 执行 FulfillPromise(promise, resolution)。
      2. 返回 undefined。
    10. 令 thenJobCallback 为 HostMakeJobCallback(thenAction)。
    11. 令 job 为 NewPromiseResolveThenableJob(promise, resolution, thenJobCallback)。
    12. 执行 HostEnqueuePromiseJob(job.[[Job]], job.[[Realm]])。
    13. 返回 undefined。
  3. 令 resolve 为 CreateBuiltinFunction(resolveSteps, 1, "", « »)。
  4. 令 rejectSteps 为一个新的 Abstract Closure，带有参数 (reason)，它捕获 promiseOrEmpty，并在被调用时执行以下步骤：
    1. 如果 promiseOrEmpty.[[Value]] 是 empty，返回 undefined。
    2. 令 promise 为 promiseOrEmpty.[[Value]]。
    3. 将 promiseOrEmpty.[[Value]] 设为 empty。
    4. 执行 RejectPromise(promise, reason)。
    5. 返回 undefined。
  5. 令 reject 为 CreateBuiltinFunction(rejectSteps, 1, "", « »)。
  6. 返回 Record { [[Resolve]]: resolve, [[Reject]]: reject }。

27.2.1.4 FulfillPromise ( promise, value )

The abstract operation FulfillPromise takes arguments promise (一个 Promise) and value (一个 ECMAScript 语言值) 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 ( constructor )

The abstract operation NewPromiseCapability takes argument constructor (一个 ECMAScript 语言值) and returns 一个包含 PromiseCapability Record 的 normal completion 或一个 throw completion. 它尝试以类似内置 Promise 构造器的方式，将 constructor 用作构造器来创建 promise，并提取其 resolve 和 reject 函数。该 promise 以及 resolve 和 reject 函数用于初始化新的 PromiseCapability Record。 It performs the following steps when called:

  1. 如果 IsConstructor(constructor) 为 false，抛出 TypeError 异常。
  2. 注：假定 constructor 是一个支持 Promise 构造器参数约定的构造器函数（见 27.2.3.1）。
  3. 令 resolvingFunctions 为 Record { [[Resolve]]: undefined, [[Reject]]: undefined }。
  4. 令 executorClosure 为一个新的 Abstract Closure，带有参数 (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(constructor, « 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 ( value )

The abstract operation IsPromise takes argument value (一个 ECMAScript 语言值) and returns 一个 Boolean. 它检查对象上的 promise 品牌。 It performs the following steps when called:

  1. 如果 value 不是 Object，返回 false。
  2. 如果 value 没有 [[PromiseState]] 内部槽，返回 false。
  3. 返回 true。

27.2.1.7 RejectPromise ( promise, reason )

The abstract operation RejectPromise takes arguments promise (一个 Promise) and reason (一个 ECMAScript 语言值) 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 (PromiseReaction Record 的 List) and argument (一个 ECMAScript 语言值) 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 (一个 Promise) and operation ("reject" 或 "handle") and returns unused. 它允许宿主环境跟踪 promise rejection。

HostPromiseRejectionTracker 的默认实现是返回 unused。

Note 1

HostPromiseRejectionTracker 在两种场景中被调用：

  • 当 promise 在没有任何处理器的情况下被 rejected 时，会以其 operation 实参设为 "reject" 调用它。
  • 当首次向 rejected 的 promise 添加处理器时，会以其 operation 实参设为 "handle" 调用它。

HostPromiseRejectionTracker 的典型实现可能会尝试通知开发者未处理的 rejection，同时也会注意在这种先前通知后来因附加了新处理器而失效时通知他们。

 Note 2

如果 operation 是 "handle"，实现不应以会干扰垃圾回收的方式持有对 promise 的引用。如果 operation 是 "reject"，实现可以持有对 promise 的引用，因为预期 rejection 会很少见且不在热代码路径上。

27.2.2 Promise Job

27.2.2.1 NewPromiseReactionJob ( reaction, argument )

The abstract operation NewPromiseReactionJob takes arguments reaction (一个 PromiseReaction Record) and argument (一个 ECMAScript 语言值) and returns 一个具有字段 [[Job]]（一个 Job Abstract Closure）和 [[Realm]]（一个 Realm Record 或 null）的 Record. 它返回一个新的 Job Abstract Closure，该闭包会将适当的处理器应用于传入值，并使用该处理器的返回值来 resolve 或 reject 与该处理器关联的派生 promise。 It performs the following steps when called:

  1. 令 job 为一个新的无参数 Job Abstract Closure，它捕获 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. 返回 ? 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 Abstract Closure）和 [[Realm]]（一个 Realm Record）的 Record. It performs the following steps when called:

  1. 令 job 为一个新的无参数 Job Abstract Closure，它捕获 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

此 Job 使用提供的 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 函数的实参表示延迟动作的最终值，可以是实际的 fulfillment 值，也可以是另一个 promise；如果该 promise 被 fulfilled，它将提供该值。

传递给 executor 函数的 reject 函数接受一个实参。executor 代码最终可以调用 reject 函数，以指示关联的 Promise 被 rejected 且永远不会 fulfilled。传递给 reject 函数的实参用作该 promise 的 rejection 值。通常它会是一个 Error 对象。

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

27.2.4 Promise 构造器的属性

Promise 构造器：

27.2.4.1 Promise.all ( iterable )

此函数返回一个新的 promise，该 promise 以传入的各 promise 的 fulfillment 值数组 fulfilled，或者以第一个被 rejected 的传入 promise 的 reason rejected。它在运行此算法时将传入 iterable 的所有元素 resolve 为 promise。

  1. 令 constructor 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(constructor)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(constructor))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAll(iteratorRecord, constructor, 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 (一个构造器) 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 (an Iterator Record), constructor (a constructor), resultCapability (a PromiseCapability Record), and promiseResolve (a function object) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

  1. 令 values 为一个新的空 List。
  2. 注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Resolve]] 只被调用一次，即使存在行为不当的 "then"，它在输入迭代器耗尽之前调用传入的回调。
  3. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  4. 令 index 为 0。
  5. 重复，
    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. 令 fulfilledSteps 为一个新的 Abstract Closure，带有参数 (value)，它捕获 values、resultCapability 和 remainingElementsCount，并在被调用时执行以下步骤：
      1. 令 activeFunc 为活动函数对象。
      2. 如果 activeFunc.[[AlreadyCalled]] 为 true，返回 undefined。
      3. 将 activeFunc.[[AlreadyCalled]] 设为 true。
      4. 令 thisIndex 为 activeFunc.[[Index]]。
      5. 将 values[thisIndex] 设为 value。
      6. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      7. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 valuesArray 为 CreateArrayFromList(values)。
        2. 返回 ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »)。
      8. 返回 undefined。
    6. 令 onFulfilled 为 CreateBuiltinFunction(fulfilledSteps, 1, "", « [[AlreadyCalled]], [[Index]] »)。
    7. 将 onFulfilled.[[AlreadyCalled]] 设为 false。
    8. 将 onFulfilled.[[Index]] 设为 index。
    9. 将 index 设为 index + 1。
    10. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    11. 执行 ? Invoke(nextPromise, "then", « onFulfilled, resultCapability.[[Reject]] »)。

27.2.4.2 Promise.allSettled ( iterable )

此函数返回一个 promise，该 promise 以 promise 状态快照数组 fulfilled，但仅在所有原始 promise 都 settled，即变为 fulfilled 或 rejected 之后才会如此。它在运行此算法时将传入 iterable 的所有元素 resolve 为 promise。

  1. 令 constructor 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(constructor)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(constructor))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAllSettled(iteratorRecord, constructor, 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 (an Iterator Record), constructor (a constructor), resultCapability (a PromiseCapability Record), and promiseResolve (a function object) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

  1. 令 values 为一个新的空 List。
  2. 注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Resolve]] 只被调用一次，即使存在行为不当的 "then"，它在输入迭代器耗尽之前调用传入的回调之一。
  3. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  4. 令 index 为 0。
  5. 重复，
    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. 令 alreadyCalled 为 Record { [[Value]]: false }。
    6. 令 fulfilledSteps 为一个新的 Abstract Closure，带有参数 (value)，它捕获 values、resultCapability 和 remainingElementsCount，并在被调用时执行以下步骤：
      1. 令 activeFunc 为活动函数对象。
      2. 如果 activeFunc.[[AlreadyCalled]].[[Value]] 为 true，返回 undefined。
      3. 将 activeFunc.[[AlreadyCalled]].[[Value]] 设为 true。
      4. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
      5. 执行 ! CreateDataPropertyOrThrow(obj, "status", "fulfilled")。
      6. 执行 ! CreateDataPropertyOrThrow(obj, "value", value)。
      7. 令 thisIndex 为 activeFunc.[[Index]]。
      8. 将 values[thisIndex] 设为 obj。
      9. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      10. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 valuesArray 为 CreateArrayFromList(values)。
        2. 返回 ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »)。
      11. 返回 undefined。
    7. 令 onFulfilled 为 CreateBuiltinFunction(fulfilledSteps, 1, "", « [[AlreadyCalled]], [[Index]] »)。
    8. 将 onFulfilled.[[AlreadyCalled]] 设为 alreadyCalled。
    9. 将 onFulfilled.[[Index]] 设为 index。
    10. 令 rejectedSteps 为一个新的 Abstract Closure，带有参数 (error)，它捕获 values、resultCapability 和 remainingElementsCount，并在被调用时执行以下步骤：
      1. 令 activeFunc 为活动函数对象。
      2. 如果 activeFunc.[[AlreadyCalled]].[[Value]] 为 true，返回 undefined。
      3. 将 activeFunc.[[AlreadyCalled]].[[Value]] 设为 true。
      4. 令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
      5. 执行 ! CreateDataPropertyOrThrow(obj, "status", "rejected")。
      6. 执行 ! CreateDataPropertyOrThrow(obj, "reason", error)。
      7. 令 thisIndex 为 activeFunc.[[Index]]。
      8. 将 values[thisIndex] 设为 obj。
      9. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      10. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 valuesArray 为 CreateArrayFromList(values)。
        2. 返回 ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »)。
      11. 返回 undefined。
    11. 令 onRejected 为 CreateBuiltinFunction(rejectedSteps, 1, "", « [[AlreadyCalled]], [[Index]] »)。
    12. 将 onRejected.[[AlreadyCalled]] 设为 alreadyCalled。
    13. 将 onRejected.[[Index]] 设为 index。
    14. 将 index 设为 index + 1。
    15. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    16. 执行 ? Invoke(nextPromise, "then", « onFulfilled, onRejected »)。

27.2.4.3 Promise.any ( iterable )

此函数返回一个 promise，该 promise 由第一个 fulfilled 的给定 promise 使其 fulfilled，或者如果所有给定 promise 都被 rejected，则以持有各 rejection reason 的 AggregateError rejected。它在运行此算法时将传入 iterable 的所有元素 resolve 为 promise。

  1. 令 constructor 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(constructor)。
  3. 令 promiseResolve 为 Completion(GetPromiseResolve(constructor))。
  4. IfAbruptRejectPromise(promiseResolve, promiseCapability)。
  5. 令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
  6. IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
  7. 令 result 为 Completion(PerformPromiseAny(iteratorRecord, constructor, 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 (an Iterator Record), constructor (a constructor), resultCapability (a PromiseCapability Record), and promiseResolve (a function object) and returns either a normal completion containing an Object or a throw completion. It performs the following steps when called:

  1. 令 errors 为一个新的空 List。
  2. 注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Reject]] 只被调用一次，即使存在行为不当的 "then"，它在输入迭代器耗尽之前调用传入的回调。
  3. 令 remainingElementsCount 为 Record { [[Value]]: 1 }。
  4. 令 index 为 0。
  5. 重复，
    1. 令 next 为 ? IteratorStepValue(iteratorRecord)。
    2. 如果 next 是 done，则
      1. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      2. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 aggregateError 为一个新创建的 AggregateError 对象。
        2. 执行 ! DefinePropertyOrThrow(aggregateError, "errors", PropertyDescriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: CreateArrayFromList(errors) })。
        3. 执行 ? Call(resultCapability.[[Reject]], undefined, « aggregateError »)。
      3. 返回 resultCapability.[[Promise]]。
    3. 将 undefined 追加到 errors。
    4. 令 nextPromise 为 ? Call(promiseResolve, constructor, « next »)。
    5. 令 rejectedSteps 为一个新的 Abstract Closure，带有参数 (error)，它捕获 errors、resultCapability 和 remainingElementsCount，并在被调用时执行以下步骤：
      1. 令 activeFunc 为活动函数对象。
      2. 如果 activeFunc.[[AlreadyCalled]] 为 true，返回 undefined。
      3. 将 activeFunc.[[AlreadyCalled]] 设为 true。
      4. 令 thisIndex 为 activeFunc.[[Index]]。
      5. 将 errors[thisIndex] 设为 error。
      6. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] - 1。
      7. 如果 remainingElementsCount.[[Value]] = 0，则
        1. 令 aggregateError 为一个新创建的 AggregateError 对象。
        2. 执行 ! DefinePropertyOrThrow(aggregateError, "errors", PropertyDescriptor { [[Configurable]]: true, [[Enumerable]]: false, [[Writable]]: true, [[Value]]: CreateArrayFromList(errors) })。
        3. 返回 ? Call(resultCapability.[[Reject]], undefined, « aggregateError »)。
      8. 返回 undefined。
    6. 令 onRejected 为 CreateBuiltinFunction(rejectedSteps, 1, "", « [[AlreadyCalled]], [[Index]] »)。
    7. 将 onRejected.[[AlreadyCalled]] 设为 false。
    8. 将 onRejected.[[Index]] 设为 index。
    9. 将 index 设为 index + 1。
    10. 将 remainingElementsCount.[[Value]] 设为 remainingElementsCount.[[Value]] + 1。
    11. 执行 ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], onRejected »)。

27.2.4.4 Promise.prototype

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

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

27.2.4.5 Promise.race ( iterable )

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

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

如果 iterable 实参不产生任何值，或者 iterable 产生的 promise 都永远不 settle，那么此方法返回的 pending promise 将永远不会 settled。

 Note 2

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

27.2.4.5.1 PerformPromiseRace ( iteratorRecord, constructor, resultCapability, promiseResolve )

The abstract operation PerformPromiseRace takes arguments iteratorRecord (an Iterator Record), constructor (a constructor), resultCapability (a PromiseCapability Record), and promiseResolve (a function object) and returns either a normal completion containing an Object or a 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 ( reason )

此函数返回一个以传入实参 rejected 的新 promise。

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

此函数期望其 this 值为支持 Promise 构造器参数约定的构造器函数。

27.2.4.7 Promise.resolve ( resolution )

此函数返回一个以传入实参 resolved 的新 promise，或者如果该实参是由此构造器产生的 promise，则返回该实参本身。

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

此函数期望其 this 值为支持 Promise 构造器参数约定的构造器函数。

27.2.4.7.1 PromiseResolve ( constructor, resolution )

The abstract operation PromiseResolve takes arguments constructor (an Object) and resolution (an ECMAScript language value) and returns either a normal completion containing an Object or a throw completion. 它返回一个以 resolution resolved 的新 promise。 It performs the following steps when called:

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

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

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

  1. 令 constructor 为 this 值。
  2. 如果 constructor 不是 Object，抛出 TypeError 异常。
  3. 令 promiseCapability 为 ? NewPromiseCapability(constructor)。
  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. 令 constructor 为 this 值。
  2. 令 promiseCapability 为 ? NewPromiseCapability(constructor)。
  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. 令 constructor 为 ? SpeciesConstructor(promise, %Promise%)。
  4. 断言：IsConstructor(constructor) 为 true。
  5. 如果 IsCallable(onFinally) 为 false，则
    1. 令 thenFinally 为 onFinally。
    2. 令 catchFinally 为 onFinally。
  6. 否则，
    1. 令 thenFinallyClosure 为一个新的 Abstract Closure，带有参数 (value)，它捕获 onFinally 和 constructor，并在被调用时执行以下步骤：
      1. 令 result 为 ? Call(onFinally, undefined)。
      2. 令 p 为 ? PromiseResolve(constructor, result)。
      3. 令 returnValue 为一个新的无参数 Abstract Closure，它捕获 value，并在被调用时执行以下步骤：
        1. 返回 NormalCompletion(value)。
      4. 令 valueThunk 为 CreateBuiltinFunction(returnValue, 0, "", « »)。
      5. 返回 ? Invoke(p, "then", « valueThunk »)。
    2. 令 thenFinally 为 CreateBuiltinFunction(thenFinallyClosure, 1, "", « »)。
    3. 令 catchFinallyClosure 为一个新的 Abstract Closure，带有参数 (reason)，它捕获 onFinally 和 constructor，并在被调用时执行以下步骤：
      1. 令 result 为 ? Call(onFinally, undefined)。
      2. 令 p 为 ? PromiseResolve(constructor, result)。
      3. 令 throwReason 为一个新的无参数 Abstract Closure，它捕获 reason，并在被调用时执行以下步骤：
        1. 抛出 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. 令 constructor 为 ? SpeciesConstructor(promise, %Promise%)。
  4. 令 resultCapability 为 ? NewPromiseCapability(constructor)。
  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 Object or undefined. 它使用 onFulfilled 和 onRejected 作为其 settlement 动作，对 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，返回 undefined。
  14. 返回 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 88 中描述的内部槽创建。

Table 88: Promise 实例的内部槽
内部槽 类型 描述
[[PromiseState]] pending、fulfilled 或 rejected 控制 promise 如何对传入的对其 then 方法的调用作出反应。
[[PromiseResult]] 一个 ECMAScript 语言值或 empty promise 已被 fulfilled 或 rejected 时所使用的值（如果有）。当且仅当 [[PromiseState]] 是 pending 时为 empty。
[[PromiseFulfillReactions]] PromiseReaction Record 的 List 当/如果 promise 从 pending 状态转换到 fulfilled 状态时要处理的记录。
[[PromiseRejectReactions]] PromiseReaction Record 的 List 当/如果 promise 从 pending 状态转换到 rejected 状态时要处理的记录。
[[PromiseIsHandled]] 一个 Boolean 表示该 promise 是否曾经有过 fulfillment 或 rejection 处理器；用于未处理 rejection 跟踪。

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 )

最后一个实参（如果有）指定 generator 函数的函数体（可执行代码）；任何前面的实参指定形式参数。

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

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

见 20.2.1.1 的注。

27.3.2 GeneratorFunction 构造器的属性

GeneratorFunction 构造器：

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

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 25 中列出的内部槽。所有此类实例的 [[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 实例时，也会创建另一个普通对象，并且该对象是 generator 函数的 "prototype" 属性的初始值。当 generator 函数对象使用 [[Call]] 被调用时，prototype 属性的值用于初始化新创建的 Generator 的 [[Prototype]] 内部槽。

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

Note

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

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 )

最后一个实参（如果有）指定 async generator 函数的函数体（可执行代码）；任何前面的实参指定形式参数。

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

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

见 20.2.1.1 的注。

27.4.2 AsyncGeneratorFunction 构造器的属性

AsyncGeneratorFunction 构造器：

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

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 25 中列出的内部槽。所有此类实例的 [[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 实例时，也会创建另一个普通对象，并且该对象是 async generator 函数的 "prototype" 属性的初始值。当 generator 函数对象使用 [[Call]] 被调用时，prototype 属性的值用于初始化新创建的 AsyncGenerator 的 [[Prototype]] 内部槽。

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

Note

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

27.5 Generator 对象

Generator 通过调用 generator 函数创建，并且同时符合迭代器接口和可迭代接口。

Generator 实例直接继承创建该实例的 generator 函数的 "prototype" 属性初始值中的属性。Generator 实例间接继承来自 %GeneratorPrototype% 的属性。

27.5.1 %GeneratorPrototype% 对象

%GeneratorPrototype% 对象：

  • 是 %GeneratorFunction.prototype.prototype%。
  • 是一个普通对象。
  • 不是 Generator 实例，并且没有 [[GeneratorState]] 内部槽。
  • 有一个 [[Prototype]] 内部槽，其值为 %Iterator.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. 令 generator 为 this 值。
  2. 令 completion 为 ReturnCompletion(value)。
  3. 返回 ? GeneratorResumeAbrupt(generator, completion, empty)。

27.5.1.4 %GeneratorPrototype%.throw ( exception )

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

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

27.5.1.5 %GeneratorPrototype% [ %Symbol.toStringTag% ]

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

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

27.5.2 Generator 实例的属性

Generator 实例最初会以 Table 89 中描述的内部槽创建。

Table 89: Generator 实例的内部槽
内部槽 类型 描述
[[GeneratorState]] suspended-start、suspended-yield、executing 或 completed generator 的当前执行状态。
[[GeneratorContext]] 一个执行上下文 执行此 generator 的代码时使用的执行上下文。
[[GeneratorBrand]] 一个 String 或 empty 用于区分不同种类 generator 的品牌。由 ECMAScript 源文本声明的 generator 的 [[GeneratorBrand]] 始终是 empty。

27.5.3 Generator 抽象操作

27.5.3.1 GeneratorStart ( generator, generatorBody )

The abstract operation GeneratorStart takes arguments generator (一个 Generator) and generatorBody (一个 FunctionBody Parse Node 或一个无参数 Abstract Closure) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[GeneratorState]] 是 suspended-start。
  2. 令 genContext 为运行中的执行上下文。
  3. 将 genContext 的 Generator 组件设为 generator。
  4. 令 closure 为一个新的无参数 Abstract Closure，它捕获 generatorBody，并在被调用时执行以下步骤：
    1. 令 acGenContext 为运行中的执行上下文。
    2. 令 acGenerator 为 acGenContext 的 Generator 组件。
    3. 如果 generatorBody 是 Parse Node，则
      1. 令 result 为 Completion(对 generatorBody 求值)。
    4. 否则，
      1. 断言：generatorBody 是一个无参数 Abstract Closure。
      2. 令 result 为 Completion(generatorBody())。
    5. 断言：如果我们返回到这里，则 generator 要么抛出了异常，要么执行了隐式或显式 return。
    6. 从执行上下文栈中移除 acGenContext，并将位于执行上下文栈顶部的执行上下文恢复为运行中的执行上下文。
    7. 将 acGenerator.[[GeneratorState]] 设为 completed。
    8. 注：一旦 generator 进入 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 (一个 ECMAScript 语言值) and generatorBrand (一个 String 或 empty) and returns 一个包含 suspended-start、suspended-yield 或 completed 之一的 normal completion，或一个 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 (一个 ECMAScript 语言值), value (一个 ECMAScript 语言值或 empty), and generatorBrand (一个 String 或 empty) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 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. 将 generator.[[GeneratorState]] 设置为 executing。
  6. 返回 ? RunSuspendedContext(genContext, NormalCompletion(value))。

27.5.3.4 GeneratorResumeAbrupt ( generator, abruptCompletion, generatorBrand )

The abstract operation GeneratorResumeAbrupt takes arguments generator (一个 ECMAScript 语言值), abruptCompletion (一个 return completion 或一个 throw completion), and generatorBrand (一个 String 或 empty) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 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 完成，则
      1. 返回 CreateIteratorResultObject(abruptCompletion.[[Value]], true)。
    2. 返回 ? abruptCompletion。
  4. 断言：state 是 suspended-yield。
  5. 令 genContext 为 generator.[[GeneratorContext]]。
  6. 将 generator.[[GeneratorState]] 设置为 executing。
  7. 返回 ? RunSuspendedContext(genContext, abruptCompletion)。

27.5.3.5 GetGeneratorKind ( )

The abstract operation GetGeneratorKind takes no arguments and returns non-generator、sync 或 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 (一个符合 IteratorResult 接口的 Object) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 abrupt completion. It performs the following steps when called:

  1. 令 genContext 为运行中的执行上下文。
  2. 断言：genContext 是某个 generator 的执行上下文。
  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 (一个 ECMAScript 语言值) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 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 (一个无参数 Abstract Closure), generatorBrand (一个 String 或 empty), and generatorPrototype (一个 Object) and optional argument extraSlots (一个内部槽名称的 List) and returns 一个 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 generator 函数创建，并且同时符合异步迭代器接口和异步可迭代接口。

AsyncGenerator 实例直接继承创建该实例的 async generator 函数的 "prototype" 属性初始值中的属性。AsyncGenerator 实例间接继承来自 %AsyncGeneratorPrototype% 的属性。

27.6.1 %AsyncGeneratorPrototype% 对象

%AsyncGeneratorPrototype% 对象：

  • 是 %AsyncGeneratorFunction.prototype.prototype%。
  • 是一个普通对象。
  • 不是 AsyncGenerator 实例，并且没有 [[AsyncGeneratorState]] 内部槽。
  • 有一个 [[Prototype]] 内部槽，其值为 %AsyncIteratorPrototype%。
  • 具有由所有 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 90: AsyncGenerator 实例的内部槽
内部槽 类型 描述
[[AsyncGeneratorState]] suspended-start、suspended-yield、executing、draining-queue 或 completed async generator 的当前执行状态。
[[AsyncGeneratorContext]] 一个执行上下文 执行此 async generator 的代码时使用的执行上下文。
[[AsyncGeneratorQueue]] AsyncGeneratorRequest Record 的 List 表示恢复 async generator 请求的记录。除状态转换期间外，当且仅当 [[AsyncGeneratorState]] 是 executing 或 draining-queue 时，它非空。
[[GeneratorBrand]] 一个 String 或 empty 用于区分不同种类 async generator 的品牌。由 ECMAScript 源文本声明的 async generator 的 [[GeneratorBrand]] 始终是 empty。

27.6.3 AsyncGenerator 抽象操作

27.6.3.1 AsyncGeneratorRequest Record

AsyncGeneratorRequest 是一种 Record 值，用于存储关于 async generator 应如何恢复的信息，并包含用于 fulfill 或 reject 对应 promise 的 capability。

它们具有以下字段：

Table 91: AsyncGeneratorRequest Record 字段
字段名 值 含义
[[Completion]] 一个 Completion Record 应当用于恢复 async generator 的 Completion Record。
[[Capability]] 一个 PromiseCapability Record 与此请求关联的 promise capability。

27.6.3.2 AsyncGeneratorStart ( generator, generatorBody )

The abstract operation AsyncGeneratorStart takes arguments generator (一个 AsyncGenerator) and generatorBody (一个 FunctionBody Parse Node 或一个无参数 Abstract Closure) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 suspended-start。
  2. 令 genContext 为运行中的执行上下文。
  3. 将 genContext 的 Generator 组件设为 generator。
  4. 令 closure 为一个新的无参数 Abstract Closure，它捕获 generatorBody，并在被调用时执行以下步骤：
    1. 令 acGenContext 为运行中的执行上下文。
    2. 令 acGenerator 为 acGenContext 的 Generator 组件。
    3. 如果 generatorBody 是 Parse Node，则
      1. 令 result 为 Completion(对 generatorBody 求值)。
    4. 否则，
      1. 断言：generatorBody 是一个无参数 Abstract Closure。
      2. 令 result 为 Completion(generatorBody())。
    5. 断言：如果我们返回到这里，则 async generator 要么抛出了异常，要么执行了隐式或显式 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 (一个 ECMAScript 语言值) and generatorBrand (一个 String 或 empty) and returns 一个包含 unused 的 normal completion 或一个 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 (一个 AsyncGenerator), completion (一个 Completion Record), and promiseCapability (一个 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 (一个 AsyncGenerator), completion (一个 Completion Record), and done (一个 Boolean) and optional argument realm (一个 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 (一个 AsyncGenerator) and completion (一个 Completion Record) and returns unused. It performs the following steps when called:

  1. 断言：generator.[[AsyncGeneratorState]] 是 suspended-start 或 suspended-yield。
  2. 令 genContext 为 generator.[[AsyncGeneratorContext]]。
  3. 将 generator.[[AsyncGeneratorState]] 设置为 executing。
  4. 执行 ! RunSuspendedContext(genContext, completion)。
  5. 返回 unused。

27.6.3.7 AsyncGeneratorUnwrapYieldResumption ( resumptionValue )

The abstract operation AsyncGeneratorUnwrapYieldResumption takes argument resumptionValue (一个 Completion Record) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 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 (一个 ECMAScript 语言值) and returns 一个包含 ECMAScript 语言值的 normal completion 或一个 abrupt completion. It performs the following steps when called:

  1. 令 genContext 为运行中的执行上下文。
  2. 断言：genContext 是某个 generator 的执行上下文。
  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. 注：执行会继续，而不挂起 generator。
    2. 令 toYield 为 queue 的第一个元素。
    3. 令 resumptionValue 为 Completion(toYield.[[Completion]])。
    4. 返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。
  12. 将 generator.[[AsyncGeneratorState]] 设为 suspended-yield。
  13. 从执行上下文栈中移除 genContext，并将位于执行上下文栈顶部的执行上下文恢复为运行中的执行上下文。
  14. 令 callerContext 为运行中的执行上下文。
  15. 恢复 callerContext，传入 undefined。如果 genContext 曾经再次被恢复，令 resumptionValue 为它被恢复时所用的 Completion Record。
  16. 断言：如果控制到达这里，则 genContext 又是运行中的执行上下文。
  17. 返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。

27.6.3.9 AsyncGeneratorAwaitReturn ( generator )

The abstract operation AsyncGeneratorAwaitReturn takes argument generator (一个 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 为一个新的 Abstract Closure，带有参数 (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 为一个新的 Abstract Closure，带有参数 (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 (一个 AsyncGenerator) and returns unused. 它会清空 generator 的 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. 如果 completion 是 normal completion，则
      1. 将 completion 设为 NormalCompletion(undefined)。
    5. 执行 AsyncGeneratorCompleteStep(generator, completion, true)。
  4. 将 generator.[[AsyncGeneratorState]] 设为 completed。
  5. 返回 unused。

27.7 AsyncFunction 对象

AsyncFunction 是通常通过求值 AsyncFunctionDeclaration、AsyncFunctionExpression、AsyncMethod 和 AsyncArrowFunction 创建的函数。它们也可以通过调用 %AsyncFunction% 内在对象来创建。

27.7.1 AsyncFunction 构造器

AsyncFunction 构造器：

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

27.7.1.1 AsyncFunction ( ...parameterArgs, bodyArg )

最后一个实参（如果有）指定 async 函数的函数体（可执行代码）。任何前面的实参指定形式参数。

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

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

27.7.2 AsyncFunction 构造器的属性

AsyncFunction 构造器：

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

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 25 中列出的内部槽。所有此类实例的 [[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 Function 抽象操作

27.7.5.1 AsyncFunctionStart ( promiseCapability, asyncFunctionBody )

The abstract operation AsyncFunctionStart takes arguments promiseCapability (一个 PromiseCapability Record) and asyncFunctionBody (一个 FunctionBody Parse Node、一个 ExpressionBody Parse Node 或一个无参数 Abstract Closure) 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 (一个 PromiseCapability Record), asyncBody (一个 Parse Node 或一个无参数 Abstract Closure), and asyncContext (一个执行上下文) and returns unused. It performs the following steps when called:

  1. 令 closure 为一个无参数的新抽象闭包，它捕获 promiseCapability 和 asyncBody，并在被调用时执行以下步骤：
    1. 令 acAsyncContext 为正在运行的执行上下文。
    2. 如果 asyncBody 是解析节点，则
      1. 令 result 为 Completion(对 asyncBody 求值)。
    3. 否则，
      1. 断言：asyncBody 是一个无参数的抽象闭包。
      2. 令 result 为 Completion(asyncBody())。
    4. 断言：如果我们在这里返回，则该 async 函数要么抛出了异常，要么执行了隐式或显式 return；所有 await 都已完成。
    5. 从执行上下文栈中移除 acAsyncContext，并将执行上下文栈顶的执行上下文恢复为正在运行的执行上下文。
    6. 如果 result 是一个正常完成，则
      1. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « undefined »)。
    7. 否则，如果 result 是一个 return 完成，则
      1. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « result.[[Value]] »)。
    8. 否则，
      1. 断言：result 是一个 throw 完成。
      2. 执行 ! Call(promiseCapability.[[Reject]], undefined, « result.[[Value]] »)。
    9. 返回 NormalCompletion(unused)。
  2. 设置 asyncContext 的代码求值状态，使得当该执行上下文的求值被恢复时，将不带参数调用 closure。
  3. 令 result 为 ! RunSuspendedContext(asyncContext, NormalCompletion(empty))。
  4. 断言：result 是 unused。
  5. 注：result 值的可能来源是 Await，或者如果该 async 函数没有 await 任何内容，则为上面的步骤 1.i。
  6. 返回 unused。

27.7.5.3 Await ( value )

The abstract operation Await takes argument value (一个 ECMAScript 语言值) and returns 一个包含 ECMAScript 语言值或 empty 的 normal completion，或一个 throw completion. It performs the following steps when called:

  1. 令 asyncContext 为正在运行的执行上下文。
  2. 令 promise 为 ? PromiseResolve(%Promise%, value)。
  3. 令 fulfilledClosure 为一个带参数 (v) 的新抽象闭包，它捕获 asyncContext，并在被调用时执行以下步骤：
    1. 执行 Completion(RunSuspendedContext(asyncContext, NormalCompletion(v)))。
    2. 注：RunSuspendedContext 返回的完成记录会被有意忽略。
    3. 返回 NormalCompletion(undefined)。
  4. 令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
  5. 令 rejectedClosure 为一个带参数 (reason) 的新抽象闭包，它捕获 asyncContext，并在被调用时执行以下步骤：
    1. 执行 Completion(RunSuspendedContext(asyncContext, ThrowCompletion(reason)))。
    2. 注：RunSuspendedContext 返回的完成记录会被有意忽略。
    3. 返回 NormalCompletion(undefined)。
  6. 令 onRejected 为 CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
  7. 执行 PerformPromiseThen(promise, onFulfilled, onRejected)。
  8. 从执行上下文栈中移除 asyncContext，并将位于执行上下文栈顶的执行上下文恢复为正在运行的执行上下文。
  9. 令 callerContext 为正在运行的执行上下文。
  10. 恢复 callerContext，传入 empty。如果 asyncContext 再次被恢复，则令 completion 为恢复它所用的完成记录。
  11. 断言：如果控制到达这里，则 asyncContext 再次成为正在运行的执行上下文。
  12. 返回 completion。