27 控制抽象对象

27.1 迭代

27.1.1 通用迭代接口

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

27.1.1.1 Iterable 接口

iterable 接口包含 Table 79 中描述的属性：

属性	值	要求
`%Symbol.iterator%`	返回 iterator 对象的函数	返回的对象必须符合 iterator 接口。

27.1.1.2 Iterator 接口

实现 iterator 接口的对象必须包含 Table 80 中的属性。这类对象也可以实现 Table 81 中的属性。

Table 80: Iterator 接口必需属性

属性	值	要求
"next"	返回 IteratorResult 对象的函数	返回的对象必须符合 IteratorResult 接口。如果先前对某个 iterator 的 `next` 方法的调用已返回一个 "done" 属性为 true 的 IteratorResult 对象，则随后对该对象的 `next` 方法的所有调用也应返回一个 "done" 属性为 true 的 IteratorResult 对象。不过，此要求不会被强制执行。

Note 1

可以向 next 函数传递实参，但其解释和有效性取决于目标 iterator。for-of 语句和其他 iterator 的常见使用者不会传递任何实参，因此预期以这种方式使用的 iterator 对象必须准备好处理无实参调用的情况。

Table 81: Iterator 接口可选属性

属性	值	要求
"return"	返回 IteratorResult 对象的函数	返回的对象必须符合 IteratorResult 接口。调用此方法会通知 iterator 对象，调用者不打算再对该 iterator 进行任何 `next` 方法调用。返回的 IteratorResult 对象通常会有一个值为 true 的 "done" 属性，以及一个 "value" 属性，其值为传给 `return` 方法的实参。不过，此要求不会被强制执行。
"throw"	返回 IteratorResult 对象的函数	返回的对象必须符合 IteratorResult 接口。调用此方法会通知 iterator 对象，调用者已检测到错误条件。该实参可用于标识错误条件，并且通常会是一个异常对象。典型响应是 `throw` 作为实参传入的值。如果该方法没有 `throw`，则返回的 IteratorResult 对象通常会有一个值为 true 的 "done" 属性。

Note 2

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

27.1.1.3 Async Iterable 接口

async iterable 接口包含 Table 82 中描述的属性：

Table 82: Async Iterable 接口必需属性

属性	值	要求
`%Symbol.asyncIterator%`	返回 async iterator 对象的函数	返回的对象必须符合 async iterator 接口。

27.1.1.4 Async Iterator 接口

实现 async iterator 接口的对象必须包含 Table 83 中的属性。这类对象也可以实现 Table 84 中的属性。

Table 83: Async Iterator 接口必需属性

属性值要求

属性	值	要求
"next"	返回 IteratorResult 对象 promise 的函数	返回的 promise 在被兑现时，必须以符合 IteratorResult 接口的对象兑现。如果先前对某个 async iterator 的 `next` 方法的调用已返回一个其 "done" 属性为 true 的 IteratorResult 对象的 promise，则随后对该对象的 `next` 方法的所有调用也应返回一个其 "done" 属性为 true 的 IteratorResult 对象的 promise。不过，此要求不会被强制执行。此外，作为兑现值的 IteratorResult 对象应具有一个 "value" 属性，其值不是 promise（也不是“thenable”）。不过，此要求也不会被强制执行。

"next"

返回 IteratorResult 对象 promise 的函数

返回的 promise 在被兑现时，必须以符合 IteratorResult 接口的对象兑现。如果先前对某个 async iterator 的 next 方法的调用已返回一个其 "done" 属性为 true 的 IteratorResult 对象的 promise，则随后对该对象的 next 方法的所有调用也应返回一个其 "done" 属性为 true 的 IteratorResult 对象的 promise。不过，此要求不会被强制执行。

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

Note 1

可以向 next 函数传递实参，但其解释和有效性取决于目标 async iterator。for-await-of 语句和其他 async iterator 的常见使用者不会传递任何实参，因此预期以这种方式使用的 async iterator 对象必须准备好处理无实参调用的情况。

Table 84: Async Iterator 接口可选属性

属性值要求

属性	值	要求
"return"	返回 IteratorResult 对象 promise 的函数	返回的 promise 在被兑现时，必须以符合 IteratorResult 接口的对象兑现。调用此方法会通知 async iterator 对象，调用者不打算再对该 async iterator 进行任何 `next` 方法调用。返回的 promise 会以一个 IteratorResult 对象兑现，该对象通常会有一个值为 true 的 "done" 属性，以及一个 "value" 属性，其值为传给 `return` 方法的实参。不过，此要求不会被强制执行。此外，作为兑现值的 IteratorResult 对象应具有一个 "value" 属性，其值不是 promise（也不是“thenable”）。如果实参值以典型方式使用，则如果它是一个被拒绝的 promise，应返回一个以相同理由拒绝的 promise；如果它是一个已兑现的 promise，则其兑现值应作为返回 promise 的 IteratorResult 对象兑现值的 "value" 属性。不过，这些要求也不会被强制执行。
"throw"	返回 IteratorResult 对象 promise 的函数	返回的 promise 在被兑现时，必须以符合 IteratorResult 接口的对象兑现。调用此方法会通知 async iterator 对象，调用者已检测到错误条件。该实参可用于标识错误条件，并且通常会是一个异常对象。典型响应是返回一个以传入实参值为拒绝理由的被拒绝 promise。如果返回的 promise 被兑现，则 IteratorResult 对象兑现值通常会有一个值为 true 的 "done" 属性。此外，它应具有一个 "value" 属性，其值不是 promise（也不是“thenable”），但此要求不会被强制执行。

"return"

返回 IteratorResult 对象 promise 的函数

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

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

"throw"

返回 IteratorResult 对象 promise 的函数

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

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

Note 2

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

27.1.1.5 IteratorResult 接口

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

Table 85: IteratorResult 接口属性

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

27.1.2 Iterator Helper 对象

Iterator Helper 对象是一种普通对象，表示某个特定源 iterator 对象的惰性转换。Iterator Helper 对象没有命名构造器。相反，Iterator Helper 对象通过调用 Iterator 实例对象的某些方法来创建。

27.1.2.1 %IteratorHelperPrototype% 对象

%IteratorHelperPrototype% 对象：

具有由所有 Iterator Helper 对象继承的属性。
是普通对象。
具有一个 [[Prototype]] 内部槽，其值为 %Iterator.prototype%。
具有以下属性：

27.1.2.1.1 %IteratorHelperPrototype%.next ( )

返回 ? GeneratorResume(this 值, undefined, "Iterator Helper")。

27.1.2.1.2 %IteratorHelperPrototype%.return ( )

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

27.1.2.1.3 %IteratorHelperPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "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 ( )

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

如果 NewTarget 是 undefined 或活动函数对象，则抛出 TypeError 异常。
返回 ? OrdinaryCreateFromConstructor(NewTarget, "%Iterator.prototype%")。

27.1.3.2 Iterator 构造器的属性

Iterator 构造器：

具有一个 [[Prototype]] 内部槽，其值为 %Function.prototype%。
具有以下属性：

27.1.3.2.1 Iterator.concat ( ...`items` )

令 iterables 为新的空 List。
对 items 的每个元素 item，执行：
1. 如果 item 不是 Object，则抛出 TypeError 异常。
2. 令 method 为 ? GetMethod(item, %Symbol.iterator%)。
3. 如果 method 是 undefined，则抛出 TypeError 异常。
4. 将 Record { [[OpenMethod]]: method, [[Iterable]]: item } 追加到 iterables。
令 closure 为一个新的无参数 Abstract Closure，它捕获 iterables，并在被调用时执行以下步骤：
1. 对 iterables 的每个 Record iterable，执行：
  1. 令 iterator 为 ? Call(iterable.[[OpenMethod]], iterable.[[Iterable]])。
  2. 如果 iterator 不是 Object，则抛出 TypeError 异常。
  3. 令 iteratorRecord 为 ? GetIteratorDirect(iterator)。
  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，则
        返回 ? IteratorClose(iteratorRecord, completion)。
2. 返回 ReturnCompletion(undefined)。
令 gen 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 gen.[[UnderlyingIterators]] 设置为新的空 List。
返回 gen。

27.1.3.2.2 Iterator.from ( `obj` )

令 iteratorRecord 为 ? GetIteratorFlattenable(obj, iterate-string-primitives)。
令 hasInstance 为 ? OrdinaryHasInstance(%Iterator%, iteratorRecord.[[Iterator]])。
如果 hasInstance 是 true，则
1. 返回 iteratorRecord.[[Iterator]]。
令 wrapper 为 OrdinaryObjectCreate(%WrapForValidIteratorPrototype%, « [[Iterated]] »)。
将 wrapper.[[Iterated]] 设置为 iteratorRecord。
返回 wrapper。

27.1.3.2.2.1 %WrapForValidIteratorPrototype% 对象

%WrapForValidIteratorPrototype% 对象：

是普通对象。
具有一个 [[Prototype]] 内部槽，其值为 %Iterator.prototype%。

27.1.3.2.2.1.1 %WrapForValidIteratorPrototype%.next ( )

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

27.1.3.2.2.1.2 %WrapForValidIteratorPrototype%.return ( )

令 obj 为 this 值。
执行 ? RequireInternalSlot(obj, [[Iterated]])。
令 iterator 为 obj.[[Iterated]].[[Iterator]]。
断言：iterator 是 Object。
令 returnMethod 为 ? GetMethod(iterator, "return")。
如果 returnMethod 是 undefined，则
1. 返回 CreateIteratorResultObject(undefined, true)。
返回 ? Call(returnMethod, iterator)。

27.1.3.2.3 Iterator.prototype

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

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

27.1.3.2.4 Iterator.zip ( `iterables` [ , `options` ] )

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

如果 iterables 不是 Object，则抛出 TypeError 异常。
将 options 设置为 ? GetOptionsObject(options)。
令 mode 为 ? Get(options, "mode")。
如果 mode 是 undefined，则将 mode 设置为 "shortest"。
如果 mode 不是 "shortest"、"longest" 或 "strict" 之一，则抛出 TypeError 异常。
令 paddingOption 为 undefined。
如果 mode 是 "longest"，则
1. 将 paddingOption 设置为 ? Get(options, "padding")。
2. 如果 paddingOption 不是 undefined 且 paddingOption 不是 Object，则抛出 TypeError 异常。
令 iters 为新的空 List。
令 padding 为新的空 List。
令 inputIter 为 ? GetIterator(iterables, sync)。
令 next 为 not-started。
重复，只要 next 不是 done，
1. 将 next 设置为 Completion(IteratorStepValue(inputIter))。
2. IfAbruptCloseIterators(next, iters)。
3. 如果 next 不是 done，则
  1. 令 iter 为 Completion(GetIteratorFlattenable(next, reject-primitives))。
  2. 令 needClosing 为 « inputIter » 和 iters 的列表连接。
  3. IfAbruptCloseIterators(iter, needClosing)。
  4. 将 iter 追加到 iters。
令 iterCount 为 iters 中元素的数量。
如果 mode 是 "longest"，则
1. 如果 paddingOption 是 undefined，则
  1. 重复 iterCount 次：
    1. 将 undefined 追加到 padding。
2. 否则，
  1. 令 paddingIter 为 Completion(GetIterator(paddingOption, sync))。
  2. IfAbruptCloseIterators(paddingIter, iters)。
  3. 令 usingIterator 为 true。
  4. 重复 iterCount 次：
    1. 如果 usingIterator 是 true，则
      1. 将 next 设置为 Completion(IteratorStepValue(paddingIter))。
      2. IfAbruptCloseIterators(next, iters)。
      3. 如果 next 是 done，则
        将 usingIterator 设置为 false。
      4. 否则，
        将 next 追加到 padding。
    2. 如果 usingIterator 是 false，则将 undefined 追加到 padding。
  5. 如果 usingIterator 是 true，则
    1. 令 completion 为 Completion(IteratorClose(paddingIter, NormalCompletion(unused)))。
    2. IfAbruptCloseIterators(completion, iters)。
令 finishResults 为一个新的 Abstract Closure，其参数为 (results)，不捕获任何内容，并在被调用时执行以下步骤：
1. 返回 CreateArrayFromList(results)。
返回 IteratorZip(iters, mode, padding, finishResults)。

27.1.3.2.5 Iterator.zipKeyed ( `iterables` [ , `options` ] )

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

如果 iterables 不是 Object，则抛出 TypeError 异常。
将 options 设置为 ? GetOptionsObject(options)。
令 mode 为 ? Get(options, "mode")。
如果 mode 是 undefined，则将 mode 设置为 "shortest"。
如果 mode 不是 "shortest"、"longest" 或 "strict" 之一，则抛出 TypeError 异常。
令 paddingOption 为 undefined。
如果 mode 是 "longest"，则
1. 将 paddingOption 设置为 ? Get(options, "padding")。
2. 如果 paddingOption 不是 undefined 且 paddingOption 不是 Object，则抛出 TypeError 异常。
令 iters 为新的空 List。
令 padding 为新的空 List。
令 allKeys 为 ? iterables.[[OwnPropertyKeys]]()。
令 keys 为新的空 List。
对 allKeys 的每个元素 key，执行：
1. 令 propertyDesc 为 Completion(iterables.[[GetOwnProperty]](key))。
2. IfAbruptCloseIterators(propertyDesc, iters)。
3. 如果 propertyDesc 不是 undefined 且 propertyDesc.[[Enumerable]] 是 true，则
  1. 令 value 为 Completion(Get(iterables, key))。
  2. IfAbruptCloseIterators(value, iters)。
  3. 如果 value 不是 undefined，则
    1. 将 key 追加到 keys。
    2. 令 iter 为 Completion(GetIteratorFlattenable(value, reject-primitives))。
    3. IfAbruptCloseIterators(iter, iters)。
    4. 将 iter 追加到 iters。
令 iterCount 为 iters 中元素的数量。
如果 mode 是 "longest"，则
1. 如果 paddingOption 是 undefined，则
  1. 重复 iterCount 次：
    1. 将 undefined 追加到 padding。
2. 否则，
  1. 对 keys 的每个元素 key，执行：
    1. 令 value 为 Completion(Get(paddingOption, key))。
    2. IfAbruptCloseIterators(value, iters)。
    3. 将 value 追加到 padding。
令 finishResults 为一个新的 Abstract Closure，其参数为 (results)，捕获 keys 和 iterCount，并在被调用时执行以下步骤：
1. 令 obj 为 OrdinaryObjectCreate(null)。
2. 对满足 0 ≤ i < iterCount 的每个整数 i，按升序执行：
  1. 执行 ! CreateDataPropertyOrThrow(obj, keys[i], results[i])。
3. 返回 obj。
返回 IteratorZip(iters, mode, padding, finishResults)。

27.1.3.3 Iterator 原型对象的属性

Iterator 原型对象：

是 %Iterator.prototype%。
具有一个 [[Prototype]] 内部槽，其值为 %Object.prototype%。
是普通对象。

Note

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

以下表达式是 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]] 特性的值是一个不需要实参的内置函数。它在被调用时执行以下步骤：

返回 %Iterator%。

27.1.3.3.1.2 set Iterator.prototype.constructor

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

执行 ? SetterThatIgnoresPrototypeProperties(this 值, %Iterator.prototype%, "constructor", v)。
返回 undefined。

Note

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

27.1.3.3.2 Iterator.prototype.drop ( `limit` )

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

令 obj 为 this 值。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
令 numberLimit 为 Completion(ToNumber(limit))。
IfAbruptCloseIterator(numberLimit, iterated)。
如果 numberLimit 是 NaN，则
1. 令 error 为 ThrowCompletion(一个新创建的 RangeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
令 intLimit 为 ! ToIntegerOrInfinity(numberLimit)。
如果 intLimit < 0，则
1. 令 error 为 ThrowCompletion(一个新创建的 RangeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
令 closure 为一个新的无参数 Abstract Closure，它捕获 iterated 和 intLimit，并在被调用时执行以下步骤：
1. 令 remaining 为 intLimit。
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)。
令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 result.[[UnderlyingIterators]] 设置为 « iterated »。
返回 result。

27.1.3.3.3 Iterator.prototype.every ( `predicate` )

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

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

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

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

27.1.3.3.5 Iterator.prototype.find ( `predicate` )

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

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

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

令 obj 为 this 值。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(mapper) 是 false，则
1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
令 closure 为一个新的无参数 Abstract 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，则
        令 backupCompletion 为 Completion(IteratorClose(innerIterator, completion))。
        IfAbruptCloseIterator(backupCompletion, iterated)。
        返回 ? IteratorClose(iterated, completion)。
  9. 将 counter 设置为 counter + 1。
令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 result.[[UnderlyingIterators]] 设置为 « iterated »。
返回 result。

27.1.3.3.7 Iterator.prototype.forEach ( `procedure` )

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

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

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

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

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

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

令 obj 为 this 值。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(reducer) 是 false，则
1. 令 error 为 ThrowCompletion(一个新创建的 TypeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
如果 initialValue 不存在，则
1. 令 accumulator 为 ? IteratorStepValue(iterated)。
2. 如果 accumulator 是 done，则抛出 TypeError 异常。
3. 令 counter 为 1。
否则，
1. 令 accumulator 为 initialValue。
2. 令 counter 为 0。
重复，
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` )

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

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

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

令 obj 为 this 值。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
令 numberLimit 为 Completion(ToNumber(limit))。
IfAbruptCloseIterator(numberLimit, iterated)。
如果 numberLimit 是 NaN，则
1. 令 error 为 ThrowCompletion(一个新创建的 RangeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
令 intLimit 为 ! ToIntegerOrInfinity(numberLimit)。
如果 intLimit < 0，则
1. 令 error 为 ThrowCompletion(一个新创建的 RangeError 对象)。
2. 返回 ? IteratorClose(iterated, error)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
令 closure 为一个新的无参数 Abstract Closure，它捕获 iterated 和 intLimit，并在被调用时执行以下步骤：
1. 令 remaining 为 intLimit。
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)。
令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 result.[[UnderlyingIterators]] 设置为 « iterated »。
返回 result。

27.1.3.3.12 Iterator.prototype.toArray ( )

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

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

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

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

令 obj 为 this 值。
令 return 为 ? GetMethod(obj, "return")。
如果 return 不是 undefined，则
1. 执行 ? Call(return, obj)。
返回 undefined。

此方法的 "name" 属性的值是 "[Symbol.dispose]"。

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

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

返回 this 值。

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

27.1.3.3.15 Iterator.prototype [ %Symbol.toStringTag% ]

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

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

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

返回 "Iterator"。

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

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

执行 ? SetterThatIgnoresPrototypeProperties(this 值, %Iterator.prototype%, %Symbol.toStringTag%, v)。
返回 undefined。

Note

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

27.1.3.4 Iterator 的抽象操作

27.1.3.4.1 IteratorZip ( `iters`, `mode`, `padding`, `finishResults` )

The abstract operation IteratorZip takes arguments iters (a List of Iterator Records), mode ("shortest", "longest", or "strict"), padding (a List of ECMAScript language values), and finishResults (an Abstract Closure that takes a List of ECMAScript language values and returns an ECMAScript language value) and returns a Generator. It performs the following steps when called:

令 iterCount 为 iters 中元素的数量。
令 openIters 为 iters 的副本。
令 closure 为一个新的无参数 Abstract Closure，它捕获 iters、iterCount、openIters、mode、padding 和 finishResults，并在被调用时执行以下步骤：
1. 如果 iterCount = 0，则返回 ReturnCompletion(undefined)。
2. 重复，
  1. 令 results 为新的空 List。
  2. 断言：openIters 不是空。
  3. 对满足 0 ≤ i < iterCount 的每个整数 i，按升序执行：
    1. 令 iter 为 iters[i]。
    2. 如果 iter 是 null，则
      1. 断言：mode 是 "longest"。
      2. 令 result 为 padding[i]。
    3. 否则，
      1. 令 result 为 Completion(IteratorStepValue(iter))。
      2. 如果 result 是 abrupt completion，则
        从 openIters 中移除 iter。
        返回 ? IteratorCloseAll(openIters, result)。
      3. 将 result 设置为 ! result。
      4. 如果 result 是 done，则
        从 openIters 中移除 iter。
        如果 mode 是 "shortest"，则
        返回 ? IteratorCloseAll(openIters, ReturnCompletion(undefined))。
        否则，如果 mode 是 "strict"，则
        如果 i ≠ 0，则
        返回 ? IteratorCloseAll(openIters, ThrowCompletion(一个新创建的 TypeError 对象))。
        对满足 1 ≤ k < iterCount 的每个整数 k，按升序执行：
        断言：iters[k] 不是 null。
        令 open 为 Completion(IteratorStep(iters[k]))。
        如果 open 是 abrupt completion，则
        从 openIters 中移除 iters[k]。
        返回 ? IteratorCloseAll(openIters, open)。
        将 open 设置为 ! open。
        如果 open 是 done，则
        从 openIters 中移除 iters[k]。
        否则，
        返回 ? IteratorCloseAll(openIters, ThrowCompletion(一个新创建的 TypeError 对象))。
        返回 ReturnCompletion(undefined)。
        否则，
        断言：mode 是 "longest"。
        如果 openIters 为空，则返回 ReturnCompletion(undefined)。
        将 iters[i] 设置为 null。
        将 result 设置为 padding[i]。
    4. 将 result 追加到 results。
  4. 将 results 设置为 finishResults(results)。
  5. 令 completion 为 Completion(Yield(results))。
  6. IfAbruptCloseIterators(completion, openIters)。
令 gen 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 gen.[[UnderlyingIterators]] 设置为 openIters。
返回 gen。

27.1.4 %AsyncIteratorPrototype% 对象

%AsyncIteratorPrototype% 对象：

具有一个 [[Prototype]] 内部槽，其值为 %Object.prototype%。
是普通对象。

Note

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

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

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

令 obj 为 this 值。
令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
令 return 为 Completion(GetMethod(obj, "return"))。
IfAbruptRejectPromise(return, promiseCapability)。
如果 return 是 undefined，则
1. 执行 ! Call(promiseCapability.[[Resolve]], undefined, « undefined »)。
否则，
1. 令 result 为 Completion(Call(return, obj, « »))。
2. IfAbruptRejectPromise(result, promiseCapability)。
3. 令 resultWrapper 为 Completion(PromiseResolve(%Promise%, result))。
4. IfAbruptRejectPromise(resultWrapper, promiseCapability)。
5. 令 unwrap 为一个新的抽象闭包，该闭包没有参数，不捕获任何内容，并在被调用时执行以下步骤：
  1. 返回 undefined。
6. 令 onFulfilled 为 CreateBuiltinFunction(unwrap, 1, "", « »)。
7. 执行 PerformPromiseThen(resultWrapper, onFulfilled, undefined, promiseCapability)。
返回 promiseCapability.[[Promise]]。

此方法的 "name" 属性的值是 "[Symbol.asyncDispose]"。

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

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

返回 this 值。

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

27.1.5 Async-from-Sync Iterator 对象

Async-from-Sync Iterator 对象是一种 async iterator，用于适配特定的同步 iterator。ECMAScript 代码永远无法直接访问 Async-from-Sync Iterator 对象。Async-from-Sync Iterator 对象没有命名构造器。相反，Async-from-Sync Iterator 对象根据需要由 CreateAsyncFromSyncIterator 抽象操作创建。

27.1.5.1 CreateAsyncFromSyncIterator ( `syncIteratorRecord` )

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

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

27.1.5.2 %AsyncFromSyncIteratorPrototype% 对象

%AsyncFromSyncIteratorPrototype% 对象：

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

27.1.5.2.1 %AsyncFromSyncIteratorPrototype%.next ( [ `value` ] )

令 obj 为 this 值。
断言：obj 是具有 [[SyncIteratorRecord]] 内部槽的 Object。
令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
令 syncIteratorRecord 为 obj.[[SyncIteratorRecord]]。
如果 value 存在，则
1. 令 result 为 Completion(IteratorNext(syncIteratorRecord, value))。
否则，
1. 令 result 为 Completion(IteratorNext(syncIteratorRecord))。
IfAbruptRejectPromise(result, promiseCapability)。
返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true)。

27.1.5.2.2 %AsyncFromSyncIteratorPrototype%.return ( [ `value` ] )

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

27.1.5.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [ `value` ] )

Note

在本规范中，value 总是被提供，但为了与 %AsyncFromSyncIteratorPrototype%.return ( [ value ] ) 保持一致，仍将其保留为可选。

令 obj 为 this 值。
断言：obj 是具有 [[SyncIteratorRecord]] 内部槽的 Object。
令 promiseCapability 为 ! NewPromiseCapability(%Promise%)。
令 syncIteratorRecord 为 obj.[[SyncIteratorRecord]]。
令 syncIterator 为 syncIteratorRecord.[[Iterator]]。
令 throw 为 Completion(GetMethod(syncIterator, "throw"))。
IfAbruptRejectPromise(throw, promiseCapability)。
如果 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]]。
如果 value 存在，则
1. 令 result 为 Completion(Call(throw, syncIterator, « value »))。
否则，
1. 令 result 为 Completion(Call(throw, syncIterator))。
IfAbruptRejectPromise(result, promiseCapability)。
如果 result 不是 Object，则
1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « 一个新创建的 TypeError 对象 »)。
2. 返回 promiseCapability.[[Promise]]。
返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true)。

27.1.5.3 Async-from-Sync Iterator 实例的属性

Async-from-Sync Iterator 实例是普通对象，继承自 %AsyncFromSyncIteratorPrototype% 固有对象的属性。Async-from-Sync Iterator 实例最初创建时具有 Table 86 中列出的内部槽。

Table 86: Async-from-Sync Iterator 实例的内部槽

内部槽	类型	描述
`[[SyncIteratorRecord]]`	Iterator Record	表示正在被适配的原始同步 iterator。

27.1.5.4 AsyncFromSyncIteratorContinuation ( `result`, `promiseCapability`, `syncIteratorRecord`, `closeOnRejection` )

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

注：由于 promiseCapability 派生自固有 %Promise%，因此下面使用 IfAbruptRejectPromise 所导致的对 promiseCapability.[[Reject]] 的调用保证不会抛出。
令 done 为 Completion(IteratorComplete(result))。
IfAbruptRejectPromise(done, promiseCapability)。
令 value 为 Completion(IteratorValue(result))。
IfAbruptRejectPromise(value, promiseCapability)。
令 valueWrapper 为 Completion(PromiseResolve(%Promise%, value))。
如果 valueWrapper 是 abrupt completion，done 是 false，且 closeOnRejection 是 true，则
1. 将 valueWrapper 设置为 Completion(IteratorClose(syncIteratorRecord, valueWrapper))。
IfAbruptRejectPromise(valueWrapper, promiseCapability)。
令 unwrap 为一个新的 Abstract Closure，其参数为 (v)，捕获 done，并在被调用时执行以下步骤：
1. 返回 CreateIteratorResultObject(v, done)。
令 onFulfilled 为 CreateBuiltinFunction(unwrap, 1, "", « »)。
注：onFulfilled 用于在处理 IteratorResult 对象的 "value" 属性时等待其值（如果它是 promise），并将结果重新包装到新的“已解包”IteratorResult 对象中。
如果 done 是 true 或 closeOnRejection 是 false，则
1. 令 onRejected 为 undefined。
否则，
1. 令 closeIterator 为一个新的 Abstract Closure，其参数为 (error)，捕获 syncIteratorRecord，并在被调用时执行以下步骤：
  1. 返回 ? IteratorClose(syncIteratorRecord, ThrowCompletion(error))。
2. 令 onRejected 为 CreateBuiltinFunction(closeIterator, 1, "", « »)。
3. 注：当 IteratorResult 对象所产生的 "value" 属性是被拒绝的 promise 时，onRejected 用于关闭 Iterator。
执行 PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability)。
返回 promiseCapability.[[Promise]]。

27.2 资源管理

27.2.1 通用资源管理接口

27.2.1.1 Disposable 接口

Disposable 接口包含 Table 87 中描述的属性：

Table 87: Disposable 接口必需属性

属性值要求

属性	值	要求
`%Symbol.dispose%`	一个函数对象	调用此方法会通知 Disposable 对象：调用者不打算继续使用此对象。此方法应执行任何必要逻辑，以对资源执行显式清理，包括但不限于文件系统句柄、流、宿主对象等。当此方法抛出异常时，通常意味着无法显式释放该资源。对同一个对象多次调用此方法时，应避免对已经处置的资源重复执行清理逻辑，并且不应抛出异常，即使第一次调用时曾抛出异常也是如此。不过，此要求不会被强制执行。当通过 `using` 或 `await using` 声明使用 Disposable 对象时，在直接包含该声明的 Block 或 Module 求值完成后，该资源将被自动处置。

%Symbol.dispose%

一个函数对象

调用此方法会通知 Disposable 对象：调用者不打算继续使用此对象。此方法应执行任何必要逻辑，以对资源执行显式清理，包括但不限于文件系统句柄、流、宿主对象等。当此方法抛出异常时，通常意味着无法显式释放该资源。

对同一个对象多次调用此方法时，应避免对已经处置的资源重复执行清理逻辑，并且不应抛出异常，即使第一次调用时曾抛出异常也是如此。不过，此要求不会被强制执行。

当通过 using 或 await using 声明使用 Disposable 对象时，在直接包含该声明的 Block 或 Module 求值完成后，该资源将被自动处置。

27.2.1.2 AsyncDisposable 接口

AsyncDisposable 接口包含 Table 88 中描述的属性：

Table 88: AsyncDisposable 接口必需属性

属性值要求

属性	值	要求
`%Symbol.asyncDispose%`	一个返回 promise 的函数对象	调用此方法会通知 AsyncDisposable 对象：调用者不打算继续使用此对象。此方法应执行任何必要逻辑，以对资源执行显式清理，包括但不限于文件系统句柄、流、宿主对象等。当此方法返回的 promise 被拒绝时，通常意味着无法显式释放该资源。直到所得 Promise 被兑现前，AsyncDisposable 对象不被视为已“处置”。对同一个对象多次调用此方法时，应避免对已经处置的资源重复执行清理逻辑，并且不应抛出异常或返回被拒绝的 promise，即使第一次调用时曾抛出异常或返回被拒绝的 promise 也是如此。不过，此要求不会被强制执行。当通过 `await using` 声明使用 AsyncDisposable 对象时，在直接包含该声明的 Block 或 Module 求值完成后，该资源将被自动处置。

%Symbol.asyncDispose%

一个返回 promise 的函数对象

调用此方法会通知 AsyncDisposable 对象：调用者不打算继续使用此对象。此方法应执行任何必要逻辑，以对资源执行显式清理，包括但不限于文件系统句柄、流、宿主对象等。当此方法返回的 promise 被拒绝时，通常意味着无法显式释放该资源。直到所得 Promise 被兑现前，AsyncDisposable 对象不被视为已“处置”。

对同一个对象多次调用此方法时，应避免对已经处置的资源重复执行清理逻辑，并且不应抛出异常或返回被拒绝的 promise，即使第一次调用时曾抛出异常或返回被拒绝的 promise 也是如此。不过，此要求不会被强制执行。

当通过 await using 声明使用 AsyncDisposable 对象时，在直接包含该声明的 Block 或 Module 求值完成后，该资源将被自动处置。

27.3 DisposableStack 对象

DisposableStack 是一个对象，可用于容纳一个或多个应一起处置的资源。

任何 DisposableStack 对象都处于两个互斥状态之一：已处置或待处理。当且仅当既未对可处置栈 d 调用 d.dispose()，也未对其调用 d.move() 时，d 是待处理的。

27.3.1 DisposableStack 构造函数

DisposableStack 构造函数：

是 %DisposableStack%。
是全局对象的 "DisposableStack" 属性的初始值。
在作为构造函数调用时，创建并初始化一个新的 DisposableStack。
不旨在作为函数调用，并且在以这种方式调用时会抛出异常。
可用作类定义的 extends 子句中的值。意图继承指定 DisposableStack 行为的子类构造函数，必须包含一次对 DisposableStack 构造函数的 super 调用，以创建并初始化带有必要内部状态的子类实例，从而支持 DisposableStack.prototype 的内置方法。

27.3.1.1 DisposableStack ( )

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

如果 NewTarget 是 undefined，则抛出 TypeError 异常。
令 disposableStack 为 ? OrdinaryCreateFromConstructor(NewTarget, "%DisposableStack.prototype%", « [[DisposableState]], [[DisposableResourceStack]] »)。
将 disposableStack.[[DisposableState]] 设置为 pending。
将 disposableStack.[[DisposableResourceStack]] 设置为一个新的空列表。
返回 disposableStack。

27.3.2 DisposableStack 构造函数的属性

DisposableStack 构造函数：

具有一个值为 %Function.prototype% 的 [[Prototype]] 内部槽。
具有以下属性：

27.3.2.1 DisposableStack.prototype

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

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

27.3.3 DisposableStack 原型对象的属性

DisposableStack 原型对象：

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

27.3.3.1 DisposableStack.prototype.adopt ( `value`, `onDispose` )

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

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDispose) 是 false，则抛出 TypeError 异常。
令 closure 为一个新的抽象闭包，该闭包没有参数，捕获 value 和 onDispose，并在被调用时执行以下步骤：
1. 返回 ? Call(onDispose, undefined, « value »)。
令 func 为 CreateBuiltinFunction(closure, 0, "", « »)。
执行 ? AddDisposableResource(disposableStack.[[DisposableResourceStack]], undefined, sync-dispose, func)。
返回 value。

27.3.3.2 DisposableStack.prototype.constructor

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

27.3.3.3 DisposableStack.prototype.defer ( `onDispose` )

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

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDispose) 是 false，则抛出 TypeError 异常。
执行 ? AddDisposableResource(disposableStack.[[DisposableResourceStack]], undefined, sync-dispose, onDispose)。
返回 undefined。

27.3.3.4 DisposableStack.prototype.dispose ( )

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

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则返回 undefined。
将 disposableStack.[[DisposableState]] 设置为 disposed。
返回 ? DisposeResources(disposableStack.[[DisposableResourceStack]], NormalCompletion(undefined))。

27.3.3.5 get DisposableStack.prototype.disposed

DisposableStack.prototype.disposed 是一个访问器属性，其 set 访问器函数为 undefined。调用其 get 访问器函数时，它执行以下步骤：

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则返回 true。
返回 false。

27.3.3.6 DisposableStack.prototype.move ( )

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

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则抛出 ReferenceError 异常。
令 newDisposableStack 为 ? OrdinaryCreateFromConstructor(%DisposableStack%, "%DisposableStack.prototype%", « [[DisposableState]], [[DisposableResourceStack]] »)。
将 newDisposableStack.[[DisposableState]] 设置为 pending。
将 newDisposableStack.[[DisposableResourceStack]] 设置为 disposableStack.[[DisposableResourceStack]]。
将 disposableStack.[[DisposableResourceStack]] 设置为一个新的空列表。
将 disposableStack.[[DisposableState]] 设置为 disposed。
返回 newDisposableStack。

27.3.3.7 DisposableStack.prototype.use ( `value` )

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

令 disposableStack 为 this 值。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则抛出 ReferenceError 异常。
执行 ? AddDisposableResource(disposableStack.[[DisposableResourceStack]], value, sync-dispose)。
返回 value。

27.3.3.8 DisposableStack.prototype [ %Symbol.dispose% ] ( )

%Symbol.dispose% 属性的初始值是 %DisposableStack.prototype.dispose%，定义于 27.3.3.4。

27.3.3.9 DisposableStack.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "DisposableStack"。

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

27.3.4 DisposableStack 实例的属性

DisposableStack 实例是普通对象，它们从 DisposableStack 原型对象（内在对象 %DisposableStack.prototype%）继承属性。DisposableStack 实例最初创建时带有 Table 89 中描述的内部槽。

Table 89: DisposableStack 实例的内部槽

内部槽	类型	描述
`[[DisposableState]]`	pending 或 disposed	支配可处置栈将如何响应对其 `%Symbol.dispose%` 方法的传入调用。
`[[DisposableResourceStack]]`	一个 DisposableResource 记录的列表	在可处置栈被处置时要处置的资源。资源按其初始化顺序添加，并按相反顺序处置。

27.4 AsyncDisposableStack 对象

AsyncDisposableStack 是一个对象，可用于容纳一个或多个应一起异步处置的资源。

任何 AsyncDisposableStack 对象都处于两个互斥状态之一：已处置或待处理。当且仅当既未对异步可处置栈 d 调用 d.disposeAsync()，也未对其调用 d.move() 时，d 是待处理的。

27.4.1 AsyncDisposableStack 构造函数

AsyncDisposableStack 构造函数：

是 %AsyncDisposableStack%。
是全局对象的 "AsyncDisposableStack" 属性的初始值。
在作为构造函数调用时，创建并初始化一个新的 AsyncDisposableStack。
不旨在作为函数调用，并且在以这种方式调用时会抛出异常。
可用作类定义的 extends 子句中的值。意图继承指定 AsyncDisposableStack 行为的子类构造函数，必须包含一次对 AsyncDisposableStack 构造函数的 super 调用，以创建并初始化带有必要内部状态的子类实例，从而支持 AsyncDisposableStack.prototype 的内置方法。

27.4.1.1 AsyncDisposableStack ( )

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

如果 NewTarget 是 undefined，则抛出 TypeError 异常。
令 asyncDisposableStack 为 ? OrdinaryCreateFromConstructor(NewTarget, "%AsyncDisposableStack.prototype%", « [[AsyncDisposableState]], [[DisposableResourceStack]] »)。
将 asyncDisposableStack.[[AsyncDisposableState]] 设置为 pending。
将 asyncDisposableStack.[[DisposableResourceStack]] 设置为一个新的空列表。
返回 asyncDisposableStack。

27.4.2 AsyncDisposableStack 构造函数的属性

AsyncDisposableStack 构造函数：

具有一个值为 %Function.prototype% 的 [[Prototype]] 内部槽。
具有以下属性：

27.4.2.1 AsyncDisposableStack.prototype

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

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

27.4.3 AsyncDisposableStack 原型对象的属性

AsyncDisposableStack 原型对象：

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

27.4.3.1 AsyncDisposableStack.prototype.adopt ( `value`, `onDisposeAsync` )

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

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDisposeAsync) 是 false，则抛出 TypeError 异常。
令 closure 为一个新的抽象闭包，该闭包没有参数，捕获 value 和 onDisposeAsync，并在被调用时执行以下步骤：
1. 返回 ? Call(onDisposeAsync, undefined, « value »)。
令 func 为 CreateBuiltinFunction(closure, 0, "", « »)。
执行 ? AddDisposableResource(asyncDisposableStack.[[DisposableResourceStack]], undefined, async-dispose, func)。
返回 value。

27.4.3.2 AsyncDisposableStack.prototype.constructor

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

27.4.3.3 AsyncDisposableStack.prototype.defer ( `onDisposeAsync` )

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

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDisposeAsync) 是 false，则抛出 TypeError 异常。
执行 ? AddDisposableResource(asyncDisposableStack.[[DisposableResourceStack]], undefined, async-dispose, onDisposeAsync)。
返回 undefined。

27.4.3.4 AsyncDisposableStack.prototype.disposeAsync ( )

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

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则返回 undefined。
将 asyncDisposableStack.[[AsyncDisposableState]] 设置为 disposed。
返回 ? DisposeResources(asyncDisposableStack.[[DisposableResourceStack]], NormalCompletion(undefined))。

27.4.3.5 get AsyncDisposableStack.prototype.disposed

AsyncDisposableStack.prototype.disposed 是一个访问器属性，其 set 访问器函数为 undefined。调用其 get 访问器函数时，它执行以下步骤：

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则返回 true。
返回 false。

27.4.3.6 AsyncDisposableStack.prototype.move ( )

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

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则抛出 ReferenceError 异常。
令 newAsyncDisposableStack 为 ? OrdinaryCreateFromConstructor(%AsyncDisposableStack%, "%AsyncDisposableStack.prototype%", « [[AsyncDisposableState]], [[DisposableResourceStack]] »)。
将 newAsyncDisposableStack.[[AsyncDisposableState]] 设置为 pending。
将 newAsyncDisposableStack.[[DisposableResourceStack]] 设置为 asyncDisposableStack.[[DisposableResourceStack]]。
将 asyncDisposableStack.[[DisposableResourceStack]] 设置为一个新的空列表。
将 asyncDisposableStack.[[AsyncDisposableState]] 设置为 disposed。
返回 newAsyncDisposableStack。

27.4.3.7 AsyncDisposableStack.prototype.use ( `value` )

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

令 asyncDisposableStack 为 this 值。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则抛出 ReferenceError 异常。
执行 ? AddDisposableResource(asyncDisposableStack.[[DisposableResourceStack]], value, async-dispose)。
返回 value。

27.4.3.8 AsyncDisposableStack.prototype [ %Symbol.asyncDispose% ] ( )

%Symbol.asyncDispose% 属性的初始值是 %AsyncDisposableStack.prototype.disposeAsync%，定义于 27.4.3.4。

27.4.3.9 AsyncDisposableStack.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "AsyncDisposableStack"。

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

27.4.4 AsyncDisposableStack 实例的属性

AsyncDisposableStack 实例是普通对象，它们从 AsyncDisposableStack 原型对象（内在对象 %AsyncDisposableStack.prototype%）继承属性。AsyncDisposableStack 实例最初创建时带有 Table 90 中描述的内部槽。

Table 90: AsyncDisposableStack 实例的内部槽

内部槽	类型	描述
`[[AsyncDisposableState]]`	pending 或 disposed	支配可处置栈将如何响应对其 `%Symbol.asyncDispose%` 方法的传入调用。
`[[DisposableResourceStack]]`	一个 DisposableResource 记录的列表	在可处置栈被处置时要处置的资源。资源按其初始化顺序添加，并按相反顺序处置。

27.5 Promise 对象

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

任何 Promise 都处于三种互斥状态之一：已兑现、已拒绝和待定：

如果 p.then(f, r) 会立即入队一个 Job 来调用函数 f，则 promise p 已兑现。
如果 p.then(f, r) 会立即入队一个 Job 来调用函数 r，则 promise p 已拒绝。
如果 promise 既未兑现也未拒绝，则它是待定的。

如果 promise 不是待定的，即如果它已兑现或已拒绝，则称该 promise 已敲定。

如果 promise 已敲定，或者它已被“锁定”为匹配另一个 promise 的状态，则该 promise 是已解决的。尝试解决或拒绝一个已解决的 promise 没有效果。如果 promise 不是已解决的，则它是未解决的。未解决的 promise 总是处于待定状态。已解决的 promise 可以是待定、已兑现或已拒绝。

27.5.1 Promise 抽象操作

27.5.1.1 PromiseCapability Record

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

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

Table 91: PromiseCapability Record 字段

字段名	值	含义
`[[Promise]]`	Object	可用作 promise 的对象。
`[[Resolve]]`	function object	用于解决给定 promise 的函数。
`[[Reject]]`	function object	用于拒绝给定 promise 的函数。

27.5.1.1.1 IfAbruptRejectPromise ( `value`, `capability` )

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

IfAbruptRejectPromise(value, capability)。

与以下内容含义相同：

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

27.5.1.2 PromiseReaction Record

PromiseReaction Record 是一种 Record 值，用于存储当 promise 以给定值变为已解决或已拒绝时应如何作出反应的信息。PromiseReaction Record 由 PerformPromiseThen 抽象操作创建，并由 NewPromiseReactionJob 返回的 Abstract Closure 使用。

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

Table 92: PromiseReaction Record 字段

字段名	值	含义
`[[Capability]]`	PromiseCapability Record 或 undefined	此 Record 为其提供 reaction handler 的 promise 的 capability。
`[[Type]]`	fulfill 或 reject	当 `[[Handler]]` 是 empty 时，`[[Type]]` 用于允许特定于敲定类型的行为。
`[[Handler]]`	JobCallback Record 或 empty	应应用于传入值的函数，其返回值将支配派生 promise 会发生什么。如果 `[[Handler]]` 是 empty，则改用一个取决于 `[[Type]]` 值的函数。

27.5.1.3 CreateResolvingFunctions ( `toResolve` )

The abstract operation CreateResolvingFunctions takes argument toResolve (a Promise) and returns a Record with fields [[Resolve]] (a function object) and [[Reject]] (a function object). It performs the following steps when called:

令 promiseOrEmpty 为 Record { [[Value]]: toResolve }。
令 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。
令 resolve 为 CreateBuiltinFunction(resolveSteps, 1, "", « »)。
令 rejectSteps 为一个新的 Abstract Closure，其参数为 (reason)，捕获 promiseOrEmpty，并在被调用时执行以下步骤：
1. 如果 promiseOrEmpty.[[Value]] 是 empty，则返回 undefined。
2. 令 promise 为 promiseOrEmpty.[[Value]]。
3. 将 promiseOrEmpty.[[Value]] 设置为 empty。
4. 执行 RejectPromise(promise, reason)。
5. 返回 undefined。
令 reject 为 CreateBuiltinFunction(rejectSteps, 1, "", « »)。
返回 Record { [[Resolve]]: resolve, [[Reject]]: reject }。

27.5.1.4 FulfillPromise ( `promise`, `value` )

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

断言：promise.[[PromiseState]] 是 pending。
令 reactions 为 promise.[[PromiseFulfillReactions]]。
将 promise.[[PromiseResult]] 设置为 value。
将 promise.[[PromiseFulfillReactions]] 设置为 undefined。
将 promise.[[PromiseRejectReactions]] 设置为 undefined。
将 promise.[[PromiseState]] 设置为 fulfilled。
执行 TriggerPromiseReactions(reactions, value)。
返回 unused。

27.5.1.5 NewPromiseCapability ( `ctor` )

The abstract operation NewPromiseCapability takes argument ctor (an ECMAScript language value) and returns either a normal completion containing a PromiseCapability Record or a throw completion. 它尝试以类似内置 Promise 构造器的方式，将 ctor 用作构造器来创建 promise，并提取其 resolve 和 reject 函数。该 promise 加上 resolve 和 reject 函数用于初始化新的 PromiseCapability Record。 It performs the following steps when called:

如果 IsConstructor(ctor) 是 false，则抛出 TypeError 异常。
注：假定 ctor 是支持 Promise 构造器参数约定的构造函数（见 27.5.3.1）。
令 resolvingFuncs 为 Record { [[Resolve]]: undefined, [[Reject]]: undefined }。
令 executorClosure 为一个新的 Abstract Closure，其参数为 (resolve, reject)，捕获 resolvingFuncs，并在被调用时执行以下步骤：
1. 如果 resolvingFuncs.[[Resolve]] 不是 undefined，则抛出 TypeError 异常。
2. 如果 resolvingFuncs.[[Reject]] 不是 undefined，则抛出 TypeError 异常。
3. 将 resolvingFuncs.[[Resolve]] 设置为 resolve。
4. 将 resolvingFuncs.[[Reject]] 设置为 reject。
5. 返回 NormalCompletion(undefined)。
令 executor 为 CreateBuiltinFunction(executorClosure, 2, "", « »)。
令 promise 为 ? Construct(ctor, « executor »)。
如果 IsCallable(resolvingFuncs.[[Resolve]]) 是 false，则抛出 TypeError 异常。
如果 IsCallable(resolvingFuncs.[[Reject]]) 是 false，则抛出 TypeError 异常。
返回 PromiseCapability Record { [[Promise]]: promise, [[Resolve]]: resolvingFuncs.[[Resolve]], [[Reject]]: resolvingFuncs.[[Reject]] }。

Note

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

27.5.1.6 IsPromise ( `arg` )

The abstract operation IsPromise takes argument arg (an ECMAScript language value) and returns a Boolean. 它检查对象上的 promise 品牌。 It performs the following steps when called:

如果 arg 不是 Object，则返回 false。
如果 arg 没有 [[PromiseState]] 内部槽，则返回 false。
返回 true。

27.5.1.7 RejectPromise ( `promise`, `reason` )

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

断言：promise.[[PromiseState]] 是 pending。
令 reactions 为 promise.[[PromiseRejectReactions]]。
将 promise.[[PromiseResult]] 设置为 reason。
将 promise.[[PromiseFulfillReactions]] 设置为 undefined。
将 promise.[[PromiseRejectReactions]] 设置为 undefined。
将 promise.[[PromiseState]] 设置为 rejected。
如果 promise.[[PromiseIsHandled]] 是 false，则执行 HostPromiseRejectionTracker(promise, "reject")。
执行 TriggerPromiseReactions(reactions, reason)。
返回 unused。

27.5.1.8 TriggerPromiseReactions ( `reactions`, `arg` )

The abstract operation TriggerPromiseReactions takes arguments reactions (a List of PromiseReaction Records) and arg (an ECMAScript language value) and returns unused. 它为 reactions 中的每个 Record 入队一个新的 Job。每个这样的 Job 会处理 PromiseReaction Record 的 [[Type]] 和 [[Handler]]，并且如果 [[Handler]] 不是 empty，则以给定实参调用它。如果 [[Handler]] 是 empty，则行为由 [[Type]] 决定。 It performs the following steps when called:

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

27.5.1.9 HostPromiseRejectionTracker ( `promise`, `operation` )

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

HostPromiseRejectionTracker 的默认实现是返回 unused。

Note 1

HostPromiseRejectionTracker 在两种场景中被调用：

当 promise 在没有任何 handler 的情况下被拒绝时，它会以 operation 实参设置为 "reject" 被调用。
当第一次向已拒绝的 promise 添加 handler 时，它会以 operation 实参设置为 "handle" 被调用。

HostPromiseRejectionTracker 的典型实现可能会尝试向开发者通知未处理的拒绝，同时也会小心地在这类先前通知之后因附加新 handler 而失效时通知开发者。

Note 2

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

27.5.2 Promise Job

27.5.2.1 NewPromiseReactionJob ( `reaction`, `arg` )

The abstract operation NewPromiseReactionJob takes arguments reaction (a PromiseReaction Record) and arg (an ECMAScript language value) and returns a Record with fields [[Job]] (a Job Abstract Closure) and [[Realm]] (a Realm Record or null). 它返回一个新的 Job Abstract Closure，该 Closure 会将适当的 handler 应用于传入值，并使用该 handler 的返回值来解决或拒绝与该 handler 关联的派生 promise。 It performs the following steps when called:

令 job 为一个新的无参数 Job Abstract Closure，它捕获 reaction 和 arg，并在被调用时执行以下步骤：
1. 令 promiseCapability 为 reaction.[[Capability]]。
2. 令 type 为 reaction.[[Type]]。
3. 令 handler 为 reaction.[[Handler]]。
4. 如果 handler 是 empty，则
  1. 如果 type 是 fulfill，则
    1. 令 handlerResult 为 NormalCompletion(arg)。
  2. 否则，
    1. 断言：type 是 reject。
    2. 令 handlerResult 为 ThrowCompletion(arg)。
5. 否则，
  1. 令 handlerResult 为 Completion(HostCallJobCallback(handler, undefined, « arg »))。
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]] »)。
令 handlerRealm 为 null。
如果 reaction.[[Handler]] 不是 empty，则
1. 令 getHandlerRealmResult 为 Completion(GetFunctionRealm(reaction.[[Handler]].[[Callback]]))。
2. 如果 getHandlerRealmResult 是 normal completion，则将 handlerRealm 设置为 getHandlerRealmResult.[[Value]]。
3. 否则，将 handlerRealm 设置为当前 Realm Record。
4. 注：除非 handler 是 undefined，否则 handlerRealm 永远不是 null。当 handler 是已撤销 Proxy 且没有 ECMAScript 代码运行时，handlerRealm 用于创建错误对象。
返回 Record { [[Job]]: job, [[Realm]]: handlerRealm }。

27.5.2.2 NewPromiseResolveThenableJob ( `promiseToResolve`, `thenable`, `then` )

The abstract operation NewPromiseResolveThenableJob takes arguments promiseToResolve (a Promise), thenable (an Object), and then (a JobCallback Record) and returns a Record with fields [[Job]] (a Job Abstract Closure) and [[Realm]] (a Realm Record). It performs the following steps when called:

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

Note

此 Job 使用所提供的 thenable 及其 then 方法来解决给定 promise。此过程必须作为 Job 发生，以确保 then 方法的求值发生在任何 surrounding code 的求值完成之后。

27.5.3 Promise 构造器

Promise 构造器：

是 %Promise%。
是全局对象的 "Promise" 属性的初始值。
在作为构造器调用时创建并初始化一个新的 Promise。
不意图作为函数调用，并且以这种方式调用时会抛出异常。
可以用作类定义的 extends 子句中的值。打算继承指定 Promise 行为的子类构造函数，必须包含一次对 Promise 构造函数的 super 调用，以创建并初始化子类实例，使其具备支持 Promise 和 Promise.prototype 的内置方法所必需的内部状态。

27.5.3.1 Promise ( `executor` )

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

如果 NewTarget 是 undefined，则抛出 TypeError 异常。
如果 IsCallable(executor) 是 false，则抛出 TypeError 异常。
令 promise 为 ? OrdinaryCreateFromConstructor(NewTarget, "%Promise.prototype%", « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »)。
将 promise.[[PromiseState]] 设置为 pending。
将 promise.[[PromiseResult]] 设置为 empty。
将 promise.[[PromiseFulfillReactions]] 设置为新的空 List。
将 promise.[[PromiseRejectReactions]] 设置为新的空 List。
将 promise.[[PromiseIsHandled]] 设置为 false。
令 resolvingFuncs 为 CreateResolvingFunctions(promise)。
令 completion 为 Completion(Call(executor, undefined, « resolvingFuncs.[[Resolve]], resolvingFuncs.[[Reject]] »))。
如果 completion 是 abrupt completion，则
1. 执行 ? Call(resolvingFuncs.[[Reject]], undefined, « completion.[[Value]] »)。
返回 promise。

Note

executor 实参必须是 function object。它被调用以启动和报告此 Promise 所表示的可能延迟动作的完成情况。executor 以两个实参调用：resolve 和 reject。这些函数可由 executor 函数使用，以报告延迟计算的最终完成或失败。从 executor 函数返回并不表示延迟动作已完成，而只表示最终执行该延迟动作的请求已被接受。

传给 executor 函数的 resolve 函数接受单个实参。executor 代码最终可以调用 resolve 函数，以指示它希望解决关联的 Promise。传给 resolve 函数的实参表示延迟动作的最终值，可以是实际的兑现值，也可以是另一个 promise，如果该 promise 被兑现，则它将提供该值。

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

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

27.5.4 Promise 构造器的属性

Promise 构造器：

具有一个 [[Prototype]] 内部槽，其值为 %Function.prototype%。
具有以下属性：

27.5.4.1 Promise.all ( `iterable` )

此函数返回一个新的 promise，该 promise 以所传 promise 的兑现值数组兑现，或者以第一个被拒绝的所传 promise 的理由拒绝。它在运行此算法时会将所传 iterable 的所有元素解决为 promise。

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
令 promiseResolve 为 Completion(GetPromiseResolve(ctor))。
IfAbruptRejectPromise(promiseResolve, promiseCapability)。
令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
令 result 为 Completion(PerformPromiseAll(iteratorRecord, ctor, promiseCapability, promiseResolve))。
如果 result 是 abrupt completion，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

Note

此函数要求其 this 值是支持 Promise 构造器参数约定的构造函数。

27.5.4.1.1 GetPromiseResolve ( `promiseCtor` )

The abstract operation GetPromiseResolve takes argument promiseCtor (a constructor) and returns either a normal completion containing a function object or a throw completion. It performs the following steps when called:

令 promiseResolve 为 ? Get(promiseCtor, "resolve")。
如果 IsCallable(promiseResolve) 是 false，则抛出 TypeError 异常。
返回 promiseResolve。

27.5.4.1.2 PerformPromiseAll ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

The abstract operation PerformPromiseAll takes arguments iteratorRecord (an Iterator Record), ctor (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:

令 values 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Resolve]] 只被调用一次，即使存在行为不当的 "then" 在输入 iterator 耗尽之前调用传入的回调。
令 remainingElementsCount 为 Record { [[Value]]: 1 }。
令 index 为 0。
重复，
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, ctor, « 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.5.4.2 Promise.allSettled ( `iterable` )

此函数返回一个 promise，该 promise 会以 promise 状态快照数组兑现，但只有在所有原始 promise 都已敲定，即变为已兑现或已拒绝之后才会兑现。它在运行此算法时会将所传 iterable 的所有元素解决为 promise。

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
令 promiseResolve 为 Completion(GetPromiseResolve(ctor))。
IfAbruptRejectPromise(promiseResolve, promiseCapability)。
令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
令 result 为 Completion(PerformPromiseAllSettled(iteratorRecord, ctor, promiseCapability, promiseResolve))。
如果 result 是 abrupt completion，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

Note

此函数要求其 this 值是支持 Promise 构造器参数约定的构造函数。

27.5.4.2.1 PerformPromiseAllSettled ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

The abstract operation PerformPromiseAllSettled takes arguments iteratorRecord (an Iterator Record), ctor (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:

令 values 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Resolve]] 只被调用一次，即使存在行为不当的 "then" 在输入 iterator 耗尽之前调用传入的某个回调。
令 remainingElementsCount 为 Record { [[Value]]: 1 }。
令 index 为 0。
重复，
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, ctor, « 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.5.4.3 Promise.any ( `iterable` )

此函数返回一个 promise，该 promise 由第一个被兑现的给定 promise 兑现；或者如果所有给定 promise 都被拒绝，则以持有拒绝理由的 AggregateError 拒绝。它在运行此算法时会将所传 iterable 的所有元素解决为 promise。

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
令 promiseResolve 为 Completion(GetPromiseResolve(ctor))。
IfAbruptRejectPromise(promiseResolve, promiseCapability)。
令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
令 result 为 Completion(PerformPromiseAny(iteratorRecord, ctor, promiseCapability, promiseResolve))。
如果 result 是 abrupt completion，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

Note

此函数要求其 this 值是支持 Promise 构造器参数约定的构造函数。

27.5.4.3.1 PerformPromiseAny ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

The abstract operation PerformPromiseAny takes arguments iteratorRecord (an Iterator Record), ctor (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:

令 errors 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保 resultCapability.[[Reject]] 只被调用一次，即使存在行为不当的 "then" 在输入 iterator 耗尽之前调用传入的回调。
令 remainingElementsCount 为 Record { [[Value]]: 1 }。
令 index 为 0。
重复，
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, ctor, « 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.5.4.4 Promise.prototype

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

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

27.5.4.5 Promise.race ( `iterable` )

此函数返回一个新的 promise，其敲定方式与第一个被敲定的所传 promise 相同。它在运行此算法时会将所传 iterable 的所有元素解决为 promise。

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
令 promiseResolve 为 Completion(GetPromiseResolve(ctor))。
IfAbruptRejectPromise(promiseResolve, promiseCapability)。
令 iteratorRecord 为 Completion(GetIterator(iterable, sync))。
IfAbruptRejectPromise(iteratorRecord, promiseCapability)。
令 result 为 Completion(PerformPromiseRace(iteratorRecord, ctor, promiseCapability, promiseResolve))。
如果 result 是 abrupt completion，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

Note 1

如果 iterable 实参不产生任何值，或者如果 iterable 产生的 promise 都永远不敲定，则此方法返回的待定 promise 永远不会被敲定。

Note 2

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

27.5.4.5.1 PerformPromiseRace ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

The abstract operation PerformPromiseRace takes arguments iteratorRecord (an Iterator Record), ctor (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. 令 next 为 ? IteratorStepValue(iteratorRecord)。
2. 如果 next 是 done，则
  1. 返回 resultCapability.[[Promise]]。
3. 令 nextPromise 为 ? Call(promiseResolve, ctor, « next »)。
4. 执行 ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], resultCapability.[[Reject]] »)。

27.5.4.6 Promise.reject ( `reason` )

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

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
执行 ? Call(promiseCapability.[[Reject]], undefined, « reason »)。
返回 promiseCapability.[[Promise]]。

Note

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

27.5.4.7 Promise.resolve ( `resolution` )

此函数要么返回一个以所传实参解决的新 promise，要么如果该实参是由此构造器产生的 promise，则返回该实参自身。

令 ctor 为 this 值。
如果 ctor 不是 Object，则抛出 TypeError 异常。
返回 ? PromiseResolve(ctor, resolution)。

Note

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

27.5.4.7.1 PromiseResolve ( `ctor`, `resolution` )

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

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

27.5.4.8 Promise.try ( `callback`, ...`args` )

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

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

Note

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

27.5.4.9 Promise.withResolvers ( )

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

令 ctor 为 this 值。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
令 obj 为 OrdinaryObjectCreate(%Object.prototype%)。
执行 ! CreateDataPropertyOrThrow(obj, "promise", promiseCapability.[[Promise]])。
执行 ! CreateDataPropertyOrThrow(obj, "resolve", promiseCapability.[[Resolve]])。
执行 ! CreateDataPropertyOrThrow(obj, "reject", promiseCapability.[[Reject]])。
返回 obj。

27.5.4.10 get Promise [ %Symbol.species% ]

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

返回 this 值。

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

Note

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

27.5.5 Promise 原型对象的属性

Promise 原型对象：

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

27.5.5.1 Promise.prototype.catch ( `onRejected` )

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

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

27.5.5.2 Promise.prototype.constructor

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

27.5.5.3 Promise.prototype.finally ( `onFinally` )

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

令 promise 为 this 值。
如果 promise 不是 Object，则抛出 TypeError 异常。
令 ctor 为 ? SpeciesConstructor(promise, %Promise%)。
断言：IsConstructor(ctor) 是 true。
如果 IsCallable(onFinally) 是 false，则
1. 令 thenFinally 为 onFinally。
2. 令 catchFinally 为 onFinally。
否则，
1. 令 thenFinallyClosure 为一个新的 Abstract Closure，其参数为 (value)，捕获 onFinally 和 ctor，并在被调用时执行以下步骤：
  1. 令 result 为 ? Call(onFinally, undefined)。
  2. 令 p 为 ? PromiseResolve(ctor, 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 和 ctor，并在被调用时执行以下步骤：
  1. 令 result 为 ? Call(onFinally, undefined)。
  2. 令 p 为 ? PromiseResolve(ctor, result)。
  3. 令 throwReason 为一个新的无参数 Abstract Closure，它捕获 reason，并在被调用时执行以下步骤：
    1. 抛出 reason。
  4. 令 thrower 为 CreateBuiltinFunction(throwReason, 0, "", « »)。
  5. 返回 ? Invoke(p, "then", « thrower »)。
4. 令 catchFinally 为 CreateBuiltinFunction(catchFinallyClosure, 1, "", « »)。
返回 ? Invoke(promise, "then", « thenFinally, catchFinally »)。

27.5.5.4 Promise.prototype.then ( `onFulfilled`, `onRejected` )

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

令 promise 为 this 值。
如果 IsPromise(promise) 是 false，则抛出 TypeError 异常。
令 ctor 为 ? SpeciesConstructor(promise, %Promise%)。
令 resultCapability 为 ? NewPromiseCapability(ctor)。
返回 PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)。

27.5.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 作为 promise 的敲定动作，对 promise 执行 “then” 操作。如果传入了 resultCapability，则结果通过更新 resultCapability 的 promise 来存储。如果未传入，则 PerformPromiseThen 是由规范内部操作调用，其结果并不重要。 It performs the following steps when called:

断言：IsPromise(promise) 是 true。
如果 resultCapability 不存在，则
1. 将 resultCapability 设置为 undefined。
如果 IsCallable(onFulfilled) 是 false，则
1. 令 onFulfilledJobCallback 为 empty。
否则，
1. 令 onFulfilledJobCallback 为 HostMakeJobCallback(onFulfilled)。
如果 IsCallable(onRejected) 是 false，则
1. 令 onRejectedJobCallback 为 empty。
否则，
1. 令 onRejectedJobCallback 为 HostMakeJobCallback(onRejected)。
令 fulfillReaction 为 PromiseReaction Record { [[Capability]]: resultCapability, [[Type]]: fulfill, [[Handler]]: onFulfilledJobCallback }。
令 rejectReaction 为 PromiseReaction Record { [[Capability]]: resultCapability, [[Type]]: reject, [[Handler]]: onRejectedJobCallback }。
如果 promise.[[PromiseState]] 是 pending，则
1. 将 fulfillReaction 追加到 promise.[[PromiseFulfillReactions]]。
2. 将 rejectReaction 追加到 promise.[[PromiseRejectReactions]]。
否则，如果 promise.[[PromiseState]] 是 fulfilled，则
1. 令 value 为 promise.[[PromiseResult]]。
2. 令 fulfillJob 为 NewPromiseReactionJob(fulfillReaction, value)。
3. 执行 HostEnqueuePromiseJob(fulfillJob.[[Job]], fulfillJob.[[Realm]])。
否则，
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]])。
将 promise.[[PromiseIsHandled]] 设置为 true。
如果 resultCapability 是 undefined，则返回 undefined。
返回 resultCapability.[[Promise]]。

27.5.5.5 Promise.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "Promise"。

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

27.5.6 Promise 实例的属性

Promise 实例是普通对象，继承自 Promise 原型对象（固有对象 %Promise.prototype%）的属性。Promise 实例最初创建时具有 Table 93 中描述的内部槽。

Table 93: Promise 实例的内部槽

内部槽	类型	描述
`[[PromiseState]]`	pending, fulfilled, or rejected	支配 promise 将如何对传入的 `then` 方法调用作出反应。
`[[PromiseResult]]`	ECMAScript 语言值或 empty	promise 已被兑现或拒绝所用的值（如果有）。当且仅当 `[[PromiseState]]` 是 pending 时为 empty。
`[[PromiseFulfillReactions]]`	PromiseReaction Record 的 List	当/如果 promise 从 pending 状态转换到 fulfilled 状态时要处理的 Record。
`[[PromiseRejectReactions]]`	PromiseReaction Record 的 List	当/如果 promise 从 pending 状态转换到 rejected 状态时要处理的 Record。
`[[PromiseIsHandled]]`	Boolean	指示 promise 是否曾经具有兑现或拒绝 handler；用于未处理拒绝跟踪。

27.6 GeneratorFunction 对象

GeneratorFunction 是通常通过求值 GeneratorDeclaration、GeneratorExpression 和 GeneratorMethod 创建的函数。它们也可以通过调用 %GeneratorFunction% 固有对象来创建。

大量纵横交错的框和箭头。 — Figure 6 (Informative): Generator 对象关系

27.6.1 GeneratorFunction 构造器

GeneratorFunction 构造器：

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

27.6.1.1 GeneratorFunction ( ...`paramArgs`, `bodyArg` )

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

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

令 activeFunc 为活动函数对象。
如果 bodyArg 不存在，则将 bodyArg 设置为空 String。
返回 ? CreateDynamicFunction(activeFunc, NewTarget, generator, paramArgs, bodyArg)。

Note

见 20.2.1.1 的注。

27.6.2 GeneratorFunction 构造器的属性

GeneratorFunction 构造器：

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

27.6.2.1 GeneratorFunction.prototype

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

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

27.6.3 GeneratorFunction 原型对象的属性

GeneratorFunction 原型对象：

是 %GeneratorFunction.prototype%（见 Figure 6）。
是普通对象。
不是函数对象，并且没有 [[ECMAScriptCode]] 内部槽，也没有 Table 26 或 Table 94 中列出的任何其他内部槽。
具有一个 [[Prototype]] 内部槽，其值为 %Function.prototype%。

27.6.3.1 GeneratorFunction.prototype.constructor

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

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

27.6.3.2 GeneratorFunction.prototype.prototype

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

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

27.6.3.3 GeneratorFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "GeneratorFunction"。

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

27.6.4 GeneratorFunction 实例

每个 GeneratorFunction 实例都是 ECMAScript 函数对象，并且具有 Table 26 中列出的内部槽。所有这类实例的 [[IsClassConstructor]] 内部槽的值都是 false。

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

27.6.4.1 length

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

27.6.4.2 name

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

27.6.4.3 prototype

每当创建一个 GeneratorFunction 实例时，还会创建另一个普通对象，并且该对象是 generator function 的 "prototype" 属性的初始值。当使用 [[Call]] 调用 generator function 对象时，该 prototype 属性的值用于初始化新创建的 Generator 的 [[Prototype]] 内部槽。

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

Note

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

27.7 AsyncGeneratorFunction 对象

AsyncGeneratorFunction 是通常通过求值 AsyncGeneratorDeclaration、AsyncGeneratorExpression 和 AsyncGeneratorMethod 语法产生式创建的函数。它们也可以通过调用 %AsyncGeneratorFunction% 固有对象来创建。

27.7.1 AsyncGeneratorFunction 构造器

AsyncGeneratorFunction 构造器：

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

27.7.1.1 AsyncGeneratorFunction ( ...`paramArgs`, `bodyArg` )

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

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

令 activeFunc 为活动函数对象。
如果 bodyArg 不存在，则将 bodyArg 设置为空 String。
返回 ? CreateDynamicFunction(activeFunc, NewTarget, async-generator, paramArgs, bodyArg)。

Note

见 20.2.1.1 的注。

27.7.2 AsyncGeneratorFunction 构造器的属性

AsyncGeneratorFunction 构造器：

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

27.7.2.1 AsyncGeneratorFunction.prototype

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

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

27.7.3 AsyncGeneratorFunction 原型对象的属性

AsyncGeneratorFunction 原型对象：

是 %AsyncGeneratorFunction.prototype%。
是普通对象。
不是函数对象，并且没有 [[ECMAScriptCode]] 内部槽，也没有 Table 26 或 Table 95 中列出的任何其他内部槽。
具有一个 [[Prototype]] 内部槽，其值为 %Function.prototype%。

27.7.3.1 AsyncGeneratorFunction.prototype.constructor

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

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

27.7.3.2 AsyncGeneratorFunction.prototype.prototype

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

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

27.7.3.3 AsyncGeneratorFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "AsyncGeneratorFunction"。

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

27.7.4 AsyncGeneratorFunction 实例

每个 AsyncGeneratorFunction 实例都是 ECMAScript 函数对象，并且具有 Table 26 中列出的内部槽。所有这类实例的 [[IsClassConstructor]] 内部槽的值都是 false。

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

27.7.4.1 length

"length" 属性的值是一个整数 Number，指示 AsyncGeneratorFunction 通常期望的实参数量。不过，语言允许以其他数量的实参调用函数。当 AsyncGeneratorFunction 以不同于其 "length" 属性所指定数量的实参数量调用时，其行为取决于该函数。

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

27.7.4.2 name

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

27.7.4.3 prototype

每当创建一个 AsyncGeneratorFunction 实例时，还会创建另一个普通对象，并且该对象是 async generator function 的 "prototype" 属性的初始值。当使用 [[Call]] 调用 generator function 对象时，该 prototype 属性的值用于初始化新创建的 AsyncGenerator 的 [[Prototype]] 内部槽。

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

Note

不同于 function 实例，作为 AsyncGeneratorFunction 的 "prototype" 属性值的对象没有一个值为该 AsyncGeneratorFunction 实例的 "constructor" 属性。

27.8 Generator 对象

Generator 通过调用 generator function 创建，并且同时符合 iterator 接口和 iterable 接口。

Generator 实例直接继承创建该实例的 generator function 的 "prototype" 属性初始值上的属性。Generator 实例间接继承 %GeneratorPrototype% 上的属性。

27.8.1 %GeneratorPrototype% 对象

%GeneratorPrototype% 对象：

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

27.8.1.1 %GeneratorPrototype%.constructor

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

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

27.8.1.2 %GeneratorPrototype%.next ( `value` )

返回 ? GeneratorResume(this 值, value, empty)。

27.8.1.3 %GeneratorPrototype%.return ( `value` )

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

令 gen 为 this 值。
令 completion 为 ReturnCompletion(value)。
返回 ? GeneratorResumeAbrupt(gen, completion, empty)。

27.8.1.4 %GeneratorPrototype%.throw ( `exception` )

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

令 gen 为 this 值。
令 completion 为 ThrowCompletion(exception)。
返回 ? GeneratorResumeAbrupt(gen, completion, empty)。

27.8.1.5 %GeneratorPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "Generator"。

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

27.8.2 Generator 实例的属性

Generator 实例最初创建时具有 Table 94 中描述的内部槽。

Table 94: Generator 实例的内部槽

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

27.8.3 Generator 抽象操作

27.8.3.1 GeneratorStart ( `gen`, `genBody` )

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

断言：gen.[[GeneratorState]] 是 suspended-start。
令 genContext 为运行中的执行上下文。
将 genContext 的 Generator 组件设置为 gen。
令 closure 为一个新的无参数 Abstract Closure，它捕获 genBody，并在被调用时执行以下步骤：
1. 令 acGenContext 为运行中的执行上下文。
2. 令 acGen 为 acGenContext 的 Generator 组件。
3. 如果 genBody 是 Parse Node，则
  1. 令 result 为 genBody 的求值的 Completion。
4. 否则，
  1. 断言：genBody 是无参数 Abstract Closure。
  2. 令 result 为 Completion(genBody())。
5. 断言：如果我们返回到这里，则该 generator 要么抛出了异常，要么执行了隐式或显式 return。
6. 从执行上下文栈中移除 acGenContext，并将执行上下文栈顶部的执行上下文恢复为运行中的执行上下文。
7. 将 acGen.[[GeneratorState]] 设置为 completed。
8. 注：一旦 generator 进入 completed 状态，它就永远不会离开该状态，其关联执行上下文也永远不会恢复。此时可以丢弃与 acGen 关联的任何执行状态。
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))。
设置 genContext 的代码求值状态，使得当该执行上下文恢复求值时，将以无实参调用 closure。
将 gen.[[GeneratorContext]] 设置为 genContext。
返回 unused。

27.8.3.2 GeneratorValidate ( `gen`, `genBrand` )

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

执行 ? RequireInternalSlot(gen, [[GeneratorState]])。
执行 ? RequireInternalSlot(gen, [[GeneratorBrand]])。
如果 gen.[[GeneratorBrand]] 不是 genBrand，则抛出 TypeError 异常。
断言：gen 具有 [[GeneratorContext]] 内部槽。
令 state 为 gen.[[GeneratorState]]。
如果 state 是 executing，则抛出 TypeError 异常。
返回 state。

27.8.3.3 GeneratorResume ( `gen`, `value`, `genBrand` )

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

令 state 为 ? GeneratorValidate(gen, genBrand)。
如果 state 是 completed，则返回 CreateIteratorResultObject(undefined, true)。
断言：state 是 suspended-start 或 suspended-yield。
令 genContext 为 gen.[[GeneratorContext]]。
将 gen.[[GeneratorState]] 设置为 executing。
返回 ? RunSuspendedContext(genContext, NormalCompletion(value))。

27.8.3.4 GeneratorResumeAbrupt ( `gen`, `abruptCompletion`, `genBrand` )

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

令 state 为 ? GeneratorValidate(gen, genBrand)。
如果 state 是 suspended-start，则
1. 将 gen.[[GeneratorState]] 设置为 completed。
2. 注：一旦 generator 进入 completed 状态，它就永远不会离开该状态，其关联执行上下文也永远不会恢复。此时可以丢弃与 gen 关联的任何执行状态。
3. 将 state 设置为 completed。
如果 state 是 completed，则
1. 如果 abruptCompletion 是 return completion，则
  1. 返回 CreateIteratorResultObject(abruptCompletion.[[Value]], true)。
2. 返回 ? abruptCompletion。
断言：state 是 suspended-yield。
令 genContext 为 gen.[[GeneratorContext]]。
将 gen.[[GeneratorState]] 设置为 executing。
返回 ? RunSuspendedContext(genContext, abruptCompletion)。

27.8.3.5 GetGeneratorKind ( )

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

令 genContext 为运行中的执行上下文。
如果 genContext 没有 Generator 组件，则返回 non-generator。
令 gen 为 genContext 的 Generator 组件。
如果 gen 具有 [[AsyncGeneratorState]] 内部槽，则返回 async。
返回 sync。

27.8.3.6 GeneratorYield ( `iteratorResult` )

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

令 genContext 为运行中的执行上下文。
断言：genContext 是一个生成器的执行上下文。
令 gen 为 genContext 的 Generator 组件的值。
断言：GetGeneratorKind() 是 sync。
将 gen.[[GeneratorState]] 设置为 suspended-yield。
返回 ? RunCallerContext(iteratorResult)。

27.8.3.7 Yield ( `arg` )

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

令 genKind 为 GetGeneratorKind()。
如果 genKind 是 async，则返回 ? AsyncGeneratorYield(? Await(arg))。
返回 ? GeneratorYield(CreateIteratorResultObject(arg, false))。

27.8.3.8 CreateIteratorFromClosure ( `closure`, `genBrand`, `genProto` [ , `extraSlots` ] )

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

注：closure 可以包含 Yield 操作的使用，以产生 IteratorResult 对象。
如果 extraSlots 不存在，则将 extraSlots 设置为新的空 List。
令 internalSlotsList 为 extraSlots 和 « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] » 的列表连接。
令 gen 为 OrdinaryObjectCreate(genProto, internalSlotsList)。
将 gen.[[GeneratorBrand]] 设置为 genBrand。
将 gen.[[GeneratorState]] 设置为 suspended-start。
令 callerContext 为运行中的执行上下文。
令 calleeContext 为新的执行上下文。
将 calleeContext 的 Function 设置为 null。
将 calleeContext 的 Realm 设置为当前 Realm Record。
将 calleeContext 的 ScriptOrModule 设置为 callerContext 的 ScriptOrModule。
如果 callerContext 尚未挂起，则挂起 callerContext。
将 calleeContext 压入执行上下文栈；calleeContext 现在是运行中的执行上下文。
执行 GeneratorStart(gen, closure)。
从执行上下文栈中移除 calleeContext，并将 callerContext 恢复为运行中的执行上下文。
返回 gen。

27.9 AsyncGenerator 对象

AsyncGenerator 通过调用 async generator function 创建，并且同时符合 async iterator 接口和 async iterable 接口。

AsyncGenerator 实例直接继承创建该实例的 async generator function 的 "prototype" 属性初始值上的属性。AsyncGenerator 实例间接继承 %AsyncGeneratorPrototype% 上的属性。

27.9.1 %AsyncGeneratorPrototype% 对象

%AsyncGeneratorPrototype% 对象：

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

27.9.1.1 %AsyncGeneratorPrototype%.constructor

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

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

27.9.1.2 %AsyncGeneratorPrototype%.next ( `value` )

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

27.9.1.3 %AsyncGeneratorPrototype%.return ( `value` )

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

27.9.1.4 %AsyncGeneratorPrototype%.throw ( `exception` )

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

27.9.1.5 %AsyncGeneratorPrototype% [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "AsyncGenerator"。

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

27.9.2 AsyncGenerator 实例的属性

AsyncGenerator 实例最初创建时具有下面描述的内部槽：

Table 95: AsyncGenerator 实例的内部槽

内部槽	类型	描述
`[[AsyncGeneratorState]]`	suspended-start, suspended-yield, executing, draining-queue, or completed	async generator 的当前执行状态。
`[[AsyncGeneratorContext]]`	execution context	执行此 async generator 的代码时使用的执行上下文。
`[[AsyncGeneratorQueue]]`	AsyncGeneratorRequest Record 的 List	表示恢复 async generator 请求的 Record。除状态转换期间外，当且仅当 `[[AsyncGeneratorState]]` 是 executing 或 draining-queue 时，它才非空。
`[[GeneratorBrand]]`	String 或 empty	用于区分不同种类 async generator 的品牌。由 ECMAScript 源文本声明的 async generator 的 `[[GeneratorBrand]]` 始终是 empty。

27.9.3 AsyncGenerator 抽象操作

27.9.3.1 AsyncGeneratorRequest Record

AsyncGeneratorRequest 是一种 Record 值，用于存储 async generator 应如何恢复的信息，并包含用于兑现或拒绝相应 promise 的 capability。

它们具有以下字段：

Table 96: AsyncGeneratorRequest Record 字段

字段名	值	含义
`[[Completion]]`	Completion Record	应用来恢复 async generator 的 Completion Record。
`[[Capability]]`	PromiseCapability Record	与此请求关联的 promise capability。

27.9.3.2 AsyncGeneratorStart ( `gen`, `genBody` )

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

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

27.9.3.3 AsyncGeneratorValidate ( `gen`, `genBrand` )

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

执行 ? RequireInternalSlot(gen, [[AsyncGeneratorContext]])。
执行 ? RequireInternalSlot(gen, [[AsyncGeneratorState]])。
执行 ? RequireInternalSlot(gen, [[AsyncGeneratorQueue]])。
如果 gen.[[GeneratorBrand]] 不是 genBrand，则抛出 TypeError 异常。
返回 unused。

27.9.3.4 AsyncGeneratorEnqueue ( `gen`, `completion`, `promiseCapability` )

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

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

27.9.3.5 AsyncGeneratorCompleteStep ( `gen`, `completion`, `done` [ , `realm` ] )

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

断言：gen.[[AsyncGeneratorQueue]] 不是空。
令 next 为 gen.[[AsyncGeneratorQueue]] 的第一个元素。
从 gen.[[AsyncGeneratorQueue]] 中移除第一个元素。
令 promiseCapability 为 next.[[Capability]]。
令 value 为 completion.[[Value]]。
如果 completion 是 throw completion，则
1. 执行 ! Call(promiseCapability.[[Reject]], undefined, « value »)。
否则，
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 »)。
返回 unused。

27.9.3.6 AsyncGeneratorResume ( `gen`, `completion` )

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

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

27.9.3.7 AsyncGeneratorUnwrapYieldResumption ( `resumptionValue` )

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

如果 resumptionValue 不是 return completion，则返回 ? resumptionValue。
令 awaited 为 Completion(Await(resumptionValue.[[Value]]))。
如果 awaited 是 throw completion，则返回 ? awaited。
断言：awaited 是 normal completion。
返回 ReturnCompletion(awaited.[[Value]])。

27.9.3.8 AsyncGeneratorYield ( `arg` )

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

令 genContext 为运行中的执行上下文。
断言：genContext 是一个生成器的执行上下文。
令 gen 为 genContext 的 Generator 组件的值。
断言：GetGeneratorKind() 是 async。
令 completion 为 NormalCompletion(arg)。
断言：执行上下文栈至少有两个元素。
令 previousContext 为执行上下文栈中从栈顶数第二个元素。
令 previousRealm 为 previousContext 的 Realm。
执行 AsyncGeneratorCompleteStep(gen, completion, false, previousRealm)。
令 queue 为 gen.[[AsyncGeneratorQueue]]。
如果 queue 非空，则
1. 注：执行会继续，而不会挂起该生成器。
2. 令 toYield 为 queue 的第一个元素。
3. 令 resumptionValue 为 Completion(toYield.[[Completion]])。
4. 返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。
将 gen.[[AsyncGeneratorState]] 设置为 suspended-yield。
令 resumptionValue 为 Completion(RunCallerContext(undefined))。
返回 ? AsyncGeneratorUnwrapYieldResumption(resumptionValue)。

27.9.3.9 AsyncGeneratorAwaitReturn ( `gen` )

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

断言：gen.[[AsyncGeneratorState]] 是 draining-queue。
令 queue 为 gen.[[AsyncGeneratorQueue]]。
断言：queue 不是空。
令 next 为 queue 的第一个元素。
令 completion 为 Completion(next.[[Completion]])。
断言：completion 是 return completion。
令 promiseCompletion 为 Completion(PromiseResolve(%Promise%, completion.[[Value]]))。
如果 promiseCompletion 是 abrupt completion，则
1. 执行 AsyncGeneratorCompleteStep(gen, promiseCompletion, true)。
2. 执行 AsyncGeneratorDrainQueue(gen)。
3. 返回 unused。
断言：promiseCompletion 是 normal completion。
令 promise 为 promiseCompletion.[[Value]]。
令 fulfilledClosure 为一个新的 Abstract Closure，其参数为 (value)，捕获 gen，并在被调用时执行以下步骤：
1. 断言：gen.[[AsyncGeneratorState]] 是 draining-queue。
2. 令 result 为 NormalCompletion(value)。
3. 执行 AsyncGeneratorCompleteStep(gen, result, true)。
4. 执行 AsyncGeneratorDrainQueue(gen)。
5. 返回 NormalCompletion(undefined)。
令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
令 rejectedClosure 为一个新的 Abstract Closure，其参数为 (reason)，捕获 gen，并在被调用时执行以下步骤：
1. 断言：gen.[[AsyncGeneratorState]] 是 draining-queue。
2. 令 result 为 ThrowCompletion(reason)。
3. 执行 AsyncGeneratorCompleteStep(gen, result, true)。
4. 执行 AsyncGeneratorDrainQueue(gen)。
5. 返回 NormalCompletion(undefined)。
令 onRejected 为 CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
执行 PerformPromiseThen(promise, onFulfilled, onRejected)。
返回 unused。

27.9.3.10 AsyncGeneratorDrainQueue ( `gen` )

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

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

27.10 AsyncFunction 对象

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

27.10.1 AsyncFunction 构造器

AsyncFunction 构造器：

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

27.10.1.1 AsyncFunction ( ...`paramArgs`, `bodyArg` )

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

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

令 activeFunc 为活动函数对象。
如果 bodyArg 不存在，则将 bodyArg 设置为空 String。
返回 ? CreateDynamicFunction(activeFunc, NewTarget, async, paramArgs, bodyArg)。

Note

见 20.2.1.1 的注。

27.10.2 AsyncFunction 构造器的属性

AsyncFunction 构造器：

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

27.10.2.1 AsyncFunction.prototype

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

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

27.10.3 AsyncFunction 原型对象的属性

AsyncFunction 原型对象：

是 %AsyncFunction.prototype%。
是普通对象。
不是函数对象，并且没有 [[ECMAScriptCode]] 内部槽，也没有 Table 26 中列出的任何其他内部槽。
具有一个 [[Prototype]] 内部槽，其值为 %Function.prototype%。

27.10.3.1 AsyncFunction.prototype.constructor

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

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

27.10.3.2 AsyncFunction.prototype [ %Symbol.toStringTag% ]

%Symbol.toStringTag% 属性的初始值是 String 值 "AsyncFunction"。

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

27.10.4 AsyncFunction 实例

每个 AsyncFunction 实例都是 ECMAScript 函数对象，并且具有 Table 26 中列出的内部槽。所有这类实例的 [[IsClassConstructor]] 内部槽的值都是 false。AsyncFunction 实例不是构造器，并且没有 [[Construct]] 内部方法。AsyncFunction 实例没有 prototype 属性，因为它们不可构造。

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

27.10.4.1 length

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

27.10.4.2 name

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

27.10.5 Async Function 的抽象操作

27.10.5.1 AsyncFunctionStart ( `promiseCapability`, `asyncFuncBody` )

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

令 runningContext 为运行中的执行上下文。
令 asyncContext 为 runningContext 的副本。
注：复制执行状态是 AsyncBlockStart 恢复其执行所必需的。恢复一个当前正在执行的上下文是未良定义的。
执行 AsyncBlockStart(promiseCapability, asyncFuncBody, asyncContext)。
返回 unused。

27.10.5.2 AsyncBlockStart ( `promiseCapability`, `asyncBody`, `asyncContext` )

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

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

27.10.5.3 Await ( `arg` )

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

令 asyncContext 为运行中的执行上下文。
令 promise 为 ? PromiseResolve(%Promise%, arg)。
令 fulfilledClosure 为一个新的抽象闭包，其参数为 (v)，它捕获 asyncContext 并在被调用时执行以下步骤：
1. 执行 Completion(RunSuspendedContext(asyncContext, NormalCompletion(v)))。
2. 注：RunSuspendedContext 返回的完成记录会被有意忽略。
3. 返回 NormalCompletion(undefined)。
令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
令 rejectedClosure 为一个新的抽象闭包，其参数为 (reason)，它捕获 asyncContext 并在被调用时执行以下步骤：
1. 执行 Completion(RunSuspendedContext(asyncContext, ThrowCompletion(reason)))。
2. 注：RunSuspendedContext 返回的完成记录会被有意忽略。
3. 返回 NormalCompletion(undefined)。
令 onRejected 为 CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
执行 PerformPromiseThen(promise, onFulfilled, onRejected)。
返回 ? RunCallerContext(empty)。

27 控制抽象对象

27.1 迭代

27.1.1 通用迭代接口

27.1.1.1 Iterable 接口

27.1.1.2 Iterator 接口

27.1.1.3 Async Iterable 接口

27.1.1.4 Async Iterator 接口

27.1.1.5 IteratorResult 接口

27.1.2 Iterator Helper 对象

27.1.2.1 %IteratorHelperPrototype% 对象

27.1.2.1.1 %IteratorHelperPrototype%.next ( )

27.1.2.1.2 %IteratorHelperPrototype%.return ( )

27.1.2.1.3 %IteratorHelperPrototype% [ %Symbol.toStringTag% ]

27.1.3 Iterator 对象

27.1.3.1 Iterator 构造器

27.1.3.1.1 Iterator ( )

27.1.3.2 Iterator 构造器的属性

27.1.3.2.1 Iterator.concat ( ...items )

27.1.3.2.2 Iterator.from ( obj )

27.1.3.2.2.1 %WrapForValidIteratorPrototype% 对象

27.1.3.2.2.1.1 %WrapForValidIteratorPrototype%.next ( )

27.1.3.2.2.1.2 %WrapForValidIteratorPrototype%.return ( )

27.1.3.2.3 Iterator.prototype

27.1.3.2.4 Iterator.zip ( iterables [ , options ] )

27.1.3.2.5 Iterator.zipKeyed ( iterables [ , options ] )

27.1.3.3 Iterator 原型对象的属性

27.1.3.3.1 Iterator.prototype.constructor

27.1.3.3.1.1 get Iterator.prototype.constructor

27.1.3.3.1.2 set Iterator.prototype.constructor

27.1.3.3.2 Iterator.prototype.drop ( limit )

27.1.3.3.3 Iterator.prototype.every ( predicate )

27.1.3.3.4 Iterator.prototype.filter ( predicate )

27.1.3.3.5 Iterator.prototype.find ( predicate )

27.1.3.3.6 Iterator.prototype.flatMap ( mapper )

27.1.3.3.7 Iterator.prototype.forEach ( procedure )

27.1.3.3.8 Iterator.prototype.map ( mapper )

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

27.1.3.3.10 Iterator.prototype.some ( predicate )

27.1.3.3.11 Iterator.prototype.take ( limit )

27.1.3.3.12 Iterator.prototype.toArray ( )

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

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

27.1.3.3.15 Iterator.prototype [ %Symbol.toStringTag% ]

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

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

27.1.3.4 Iterator 的抽象操作

27.1.3.4.1 IteratorZip ( iters, mode, padding, finishResults )

27.1.4 %AsyncIteratorPrototype% 对象

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

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

27.1.5 Async-from-Sync Iterator 对象

27.1.5.1 CreateAsyncFromSyncIterator ( syncIteratorRecord )

27.1.5.2 %AsyncFromSyncIteratorPrototype% 对象

27.1.5.2.1 %AsyncFromSyncIteratorPrototype%.next ( [ value ] )

27.1.5.2.2 %AsyncFromSyncIteratorPrototype%.return ( [ value ] )

27.1.5.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [ value ] )

27.1.5.3 Async-from-Sync Iterator 实例的属性

27.1.5.4 AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection )

27.2 资源管理

27.2.1 通用资源管理接口

27.2.1.1 Disposable 接口

27.2.1.2 AsyncDisposable 接口

27.3 DisposableStack 对象

27.3.1 DisposableStack 构造函数

27.3.1.1 DisposableStack ( )

27.3.2 DisposableStack 构造函数的属性

27.3.2.1 DisposableStack.prototype

27.3.3 DisposableStack 原型对象的属性

27.3.3.1 DisposableStack.prototype.adopt ( value, onDispose )

27.3.3.2 DisposableStack.prototype.constructor

27.3.3.3 DisposableStack.prototype.defer ( onDispose )

27.3.3.4 DisposableStack.prototype.dispose ( )

27.3.3.5 get DisposableStack.prototype.disposed

27.3.3.6 DisposableStack.prototype.move ( )

27.3.3.7 DisposableStack.prototype.use ( value )

27.3.3.8 DisposableStack.prototype [ %Symbol.dispose% ] ( )

27.3.3.9 DisposableStack.prototype [ %Symbol.toStringTag% ]

27.3.4 DisposableStack 实例的属性

27.4 AsyncDisposableStack 对象

27.4.1 AsyncDisposableStack 构造函数

27.1.3.2.1 Iterator.concat ( ...`items` )

27.1.3.2.2 Iterator.from ( `obj` )

27.1.3.2.4 Iterator.zip ( `iterables` [ , `options` ] )

27.1.3.2.5 Iterator.zipKeyed ( `iterables` [ , `options` ] )

27.1.3.3.2 Iterator.prototype.drop ( `limit` )

27.1.3.3.3 Iterator.prototype.every ( `predicate` )

27.1.3.3.4 Iterator.prototype.filter ( `predicate` )

27.1.3.3.5 Iterator.prototype.find ( `predicate` )

27.1.3.3.6 Iterator.prototype.flatMap ( `mapper` )

27.1.3.3.7 Iterator.prototype.forEach ( `procedure` )

27.1.3.3.8 Iterator.prototype.map ( `mapper` )

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

27.1.3.3.10 Iterator.prototype.some ( `predicate` )

27.1.3.3.11 Iterator.prototype.take ( `limit` )

27.1.3.4.1 IteratorZip ( `iters`, `mode`, `padding`, `finishResults` )

27.1.5.1 CreateAsyncFromSyncIterator ( `syncIteratorRecord` )

27.1.5.2.1 %AsyncFromSyncIteratorPrototype%.next ( [ `value` ] )

27.1.5.2.2 %AsyncFromSyncIteratorPrototype%.return ( [ `value` ] )

27.1.5.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [ `value` ] )

27.1.5.4 AsyncFromSyncIteratorContinuation ( `result`, `promiseCapability`, `syncIteratorRecord`, `closeOnRejection` )

27.3.3.1 DisposableStack.prototype.adopt ( `value`, `onDispose` )

27.3.3.3 DisposableStack.prototype.defer ( `onDispose` )

27.3.3.7 DisposableStack.prototype.use ( `value` )

27.4.3.1 AsyncDisposableStack.prototype.adopt ( `value`, `onDisposeAsync` )

27.4.3.3 AsyncDisposableStack.prototype.defer ( `onDisposeAsync` )

27.4.3.7 AsyncDisposableStack.prototype.use ( `value` )

27.5.1.1.1 IfAbruptRejectPromise ( `value`, `capability` )

27.5.1.3 CreateResolvingFunctions ( `toResolve` )

27.5.1.4 FulfillPromise ( `promise`, `value` )

27.5.1.5 NewPromiseCapability ( `ctor` )

27.5.1.6 IsPromise ( `arg` )

27.5.1.7 RejectPromise ( `promise`, `reason` )

27.5.1.8 TriggerPromiseReactions ( `reactions`, `arg` )

27.5.1.9 HostPromiseRejectionTracker ( `promise`, `operation` )

27.5.2.1 NewPromiseReactionJob ( `reaction`, `arg` )

27.5.2.2 NewPromiseResolveThenableJob ( `promiseToResolve`, `thenable`, `then` )

27.5.3.1 Promise ( `executor` )

27.5.4.1 Promise.all ( `iterable` )

27.5.4.1.1 GetPromiseResolve ( `promiseCtor` )

27.5.4.1.2 PerformPromiseAll ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

27.5.4.2 Promise.allSettled ( `iterable` )

27.5.4.2.1 PerformPromiseAllSettled ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

27.5.4.3 Promise.any ( `iterable` )

27.5.4.3.1 PerformPromiseAny ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

27.5.4.5 Promise.race ( `iterable` )

27.5.4.5.1 PerformPromiseRace ( `iteratorRecord`, `ctor`, `resultCapability`, `promiseResolve` )

27.5.4.6 Promise.reject ( `reason` )

27.5.4.7 Promise.resolve ( `resolution` )

27.5.4.7.1 PromiseResolve ( `ctor`, `resolution` )

27.5.4.8 Promise.try ( `callback`, ...`args` )

27.5.5.1 Promise.prototype.catch ( `onRejected` )

27.5.5.3 Promise.prototype.finally ( `onFinally` )

27.5.5.4 Promise.prototype.then ( `onFulfilled`, `onRejected` )

27.5.5.4.1 PerformPromiseThen ( `promise`, `onFulfilled`, `onRejected` [ , `resultCapability` ] )

27.6.1.1 GeneratorFunction ( ...`paramArgs`, `bodyArg` )