27 控制抽象对象

27.1 迭代

27.1.1 通用迭代接口

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

27.1.1.1 Iterable 接口

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

属性	值	要求
`%Symbol.iterator%`	a function that returns an iterator object	返回的对象必须符合 iterator 接口。

27.1.1.2 Iterator 接口

实现 iterator 接口的对象必须包含表 80 中的属性。此类对象还可以实现表 81 中的属性。

表 80: Iterator 接口必需属性

属性	值	要求
"next"	a function that returns an IteratorResult object	返回的对象必须符合 IteratorResult 接口。如果先前对某个 iterator 的 `next` 方法的调用已经返回了一个 "done" 属性为 true 的 IteratorResult 对象，那么对该对象的所有后续 `next` 方法调用也应返回 "done" 属性为 true 的 IteratorResult 对象。不过，此要求不会被强制执行。

注 1

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

表 81: Iterator 接口可选属性

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

注 2

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

27.1.1.3 Async Iterable 接口

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

表 82: Async Iterable 接口必需属性

属性	值	要求
`%Symbol.asyncIterator%`	a function that returns an async iterator object	返回的对象必须符合 async iterator 接口。

27.1.1.4 Async Iterator 接口

实现 async iterator 接口的对象必须包含表 83 中的属性。此类对象还可以实现表 84 中的属性。

表 83: Async Iterator 接口必需属性

属性值要求

属性	值	要求
"next"	a function that returns a promise for an IteratorResult object	返回的 promise 在兑现时，必须以符合 IteratorResult 接口的对象作为兑现值。如果先前对 async iterator 的 `next` 方法的调用已经返回了一个 promise，该 promise 对应的 IteratorResult 对象的 "done" 属性为 true，那么对该对象的所有后续 `next` 方法调用也应返回一个 promise，该 promise 对应的 IteratorResult 对象的 "done" 属性为 true。不过，此要求不会被强制执行。此外，用作兑现值的 IteratorResult 对象应具有一个 "value" 属性，其值不是 promise（或“thenable”）。不过，此要求同样不会被强制执行。

"next"

a function that returns a promise for an IteratorResult object

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

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

注 1

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

表 84: Async Iterator 接口可选属性

属性值要求

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

"return"

a function that returns a promise for an IteratorResult object

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

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

"throw"

a function that returns a promise for an IteratorResult object

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

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

注 2

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

27.1.1.5 IteratorResult 接口

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

表 85: IteratorResult 接口属性

属性	值	要求
"done"	a Boolean	这是 iterator 的 `next` 方法调用的结果状态。如果已经到达 iterator 的末尾，则 "done" 为 true。如果尚未到达末尾，则 "done" 为 false，并且存在可用值。如果不存在 "done" 属性（无论是自有属性还是继承属性），则认为其值为 false。
"value"	an ECMAScript language value	如果 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 value, undefined, "Iterator Helper")。

27.1.2.1.2 %IteratorHelperPrototype%.return ( )

令 obj 为 this value。
执行 ? 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 是突然完成，则
        返回 ? 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 value。
执行 ? RequireInternalSlot(obj, [[Iterated]])。
令 iteratorRecord 为 obj.[[Iterated]]。
返回 ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]])。

27.1.3.2.2.1.2 %WrapForValidIteratorPrototype%.return ( )

令 obj 为 this value。
执行 ? 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 为参数为 (results) 且不捕获任何内容的新 Abstract Closure，它在被调用时执行以下步骤：
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 为参数为 (results) 的新 Abstract Closure，它捕获 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%。
是普通对象。

注

本规范中定义的所有实现 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 }。[[Getter]] 和 [[Setter]] 特性定义如下：

27.1.3.3.1.1 get Iterator.prototype.constructor

[[Getter]] 特性的值是一个无需参数的内置函数。调用时，它执行以下步骤：

返回 %Iterator%。

27.1.3.3.1.2 set Iterator.prototype.constructor

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

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

注

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

27.1.3.3.2 Iterator.prototype.drop ( `limit` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
令 numberLimit 为 Completion(ToNumber(limit))。
IfAbruptCloseIterator(numberLimit, iterated)。
如果 numberLimit 是 NaN，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
2. 返回 ? IteratorClose(iterated, error)。
如果 numberLimit 是有限值且 numberLimit > 𝔽(2⁵³ - 1)，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
2. 返回 ? IteratorClose(iterated, error)。
令 intLimit 为 ! ToIntegerOrInfinity(numberLimit)。
如果 intLimit < 0，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
2. 返回 ? IteratorClose(iterated, error)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
令 closure 为不带参数的新 Abstract Closure，它捕获 iterated 和 intLimit，并在被调用时执行以下步骤：
1. 令 remaining 为 𝔽(intLimit)。
2. 当 remaining > +0_𝔽 时，重复执行，
  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 value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(predicate) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
7. 将 counter 设置为 counter + 1_𝔽。

27.1.3.3.4 Iterator.prototype.filter ( `predicate` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(predicate) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
  7. 将 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 value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(predicate) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
7. 将 counter 设置为 counter + 1_𝔽。

27.1.3.3.6 Iterator.prototype.flatMap ( `mapper` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(mapper) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 是突然完成，则
        令 backupCompletion 为 Completion(IteratorClose(innerIterator, completion))。
        IfAbruptCloseIterator(backupCompletion, iterated)。
        返回 ? IteratorClose(iterated, completion)。
  9. 注：一旦 counter 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
  10. 将 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 value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(procedure) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
6. 将 counter 设置为 counter + 1_𝔽。

27.1.3.3.8 Iterator.prototype.join ( `separator` )

此方法将迭代器的值转换为字符串，然后连接这些字符串，并在它们之间插入 separator。如果未提供分隔符，则使用单个逗号作为分隔符。

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

令 obj 为 this 值。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为迭代器记录 { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 separator 为 undefined，则
1. 令 separatorString 为 ","。
否则，
1. 令 separatorString 为 Completion(ToString(separator))。
2. IfAbruptCloseIterator(separatorString, iterated)。
将 iterated 设置为 ? GetIteratorDirect(obj)。
令 result 为空字符串。
令 first 为 true。
重复，
1. 令 value 为 ? IteratorStepValue(iterated)。
2. 如果 value 为 done，返回 result。
3. 如果 first 为 true，则
  1. 将 first 设置为 false。
4. 否则，
  1. 将 result 设置为 result 和 separatorString 的字符串连接结果。
5. 如果 value 既不是 undefined 也不是 null，则
  1. 令 valueString 为 Completion(ToString(value))。
  2. IfAbruptCloseIterator(valueString, iterated)。
  3. 将 result 设置为 result 和 valueString 的字符串连接结果。

27.1.3.3.9 Iterator.prototype.map ( `mapper` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(mapper) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
  8. 将 counter 设置为 counter + 1_𝔽。
令 result 为 CreateIteratorFromClosure(closure, "Iterator Helper", %IteratorHelperPrototype%, « [[UnderlyingIterators]] »)。
将 result.[[UnderlyingIterators]] 设置为 « iterated »。
返回 result。

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

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(reducer) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
7. 将 counter 设置为 counter + 1_𝔽。

27.1.3.3.11 Iterator.prototype.some ( `predicate` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
如果 IsCallable(predicate) 是 false，则
1. 令 error 为 ThrowCompletion(a newly created TypeError object)。
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 达到 2⁵³_𝔽，以下步骤将不再改变 counter。
7. 将 counter 设置为 counter + 1_𝔽。

27.1.3.3.12 Iterator.prototype.take ( `limit` )

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

令 obj 为 this value。
如果 obj 不是 Object，则抛出 TypeError 异常。
令 iterated 为 Iterator Record { [[Iterator]]: obj, [[NextMethod]]: undefined, [[Done]]: false }。
令 numberLimit 为 Completion(ToNumber(limit))。
IfAbruptCloseIterator(numberLimit, iterated)。
如果 numberLimit 是 NaN，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
2. 返回 ? IteratorClose(iterated, error)。
如果 numberLimit 是有限值且 numberLimit > 𝔽(2⁵³ - 1)，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
2. 返回 ? IteratorClose(iterated, error)。
令 intLimit 为 ! ToIntegerOrInfinity(numberLimit)。
如果 intLimit < 0，则
1. 令 error 为 ThrowCompletion(a newly created RangeError object)。
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 设置为 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.13 Iterator.prototype.toArray ( )

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

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

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

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

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

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

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

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

返回 this value。

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

27.1.3.3.16 Iterator.prototype [ %Symbol.toStringTag% ]

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

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

[[Getter]] 特性的值是一个无需参数的内置函数。调用时，它执行以下步骤：

返回 "Iterator"。

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

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

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

注

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

27.1.3.4 Iterator 的抽象操作

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

抽象操作 IteratorZip，接收参数 iters (列表 (元素：Iterator 记录))、mode (("shortest"、"longest" 或 "strict"))、padding (列表 (元素：ECMAScript 语言值)) 和 finishResults (an Abstract Closure that takes a List of ECMAScript language values and returns an ECMAScript language value)；返回值：Generator。调用时执行以下步骤：

令 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 是突然完成，则
        从 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(a newly created TypeError object))。
        对满足 1 ≤ k < iterCount 的每个整数 k，按升序执行
        断言：iters[k] 不是 null。
        令 open 为 Completion(IteratorStep(iters[k]))。
        如果 open 是突然完成，则
        从 openIters 中移除 iters[k]。
        返回 ? IteratorCloseAll(openIters, open)。
        将 open 设置为 ! open。
        如果 open 是 done，则
        从 openIters 中移除 iters[k]。
        否则，
        返回 ? IteratorCloseAll(openIters, ThrowCompletion(a newly created TypeError object))。
        返回 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%。
是普通对象。

注

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

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

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

令 obj 为 this value。
令 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 为不带参数且不捕获任何内容的新 Abstract Closure，它在被调用时执行以下步骤：
  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 value。

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

27.1.5 Async-from-Sync Iterator 对象

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

27.1.5.1 CreateAsyncFromSyncIterator ( `syncIteratorRecord` )

抽象操作 CreateAsyncFromSyncIterator，接收参数 syncIteratorRecord (Iterator 记录)；返回值：Iterator 记录。它用于从同步 Iterator Record 创建 async Iterator Record。调用时执行以下步骤：

令 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 value。
断言：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 value。
断言：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, « a newly created TypeError object »)。
2. 返回 promiseCapability.[[Promise]]。
返回 AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, false)。

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

注

在本规范中，始终会提供 value，但为与 %AsyncFromSyncIteratorPrototype%.return ( [ value ] ) 保持一致，它仍被设为可选。

令 obj 为 this value。
断言：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, « a newly created TypeError object »)。
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, « a newly created TypeError object »)。
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 实例最初创建时具有表 86 中列出的内部槽。

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

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

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

抽象操作 AsyncFromSyncIteratorContinuation，接收参数 result (Object)、promiseCapability (a PromiseCapability Record for an intrinsic %Promise%)、syncIteratorRecord (Iterator 记录) 和 closeOnRejection (Boolean)；返回值：Promise。调用时执行以下步骤：

注：由于 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 是突然完成、done 是 false 且 closeOnRejection 是 true，则
1. 将 valueWrapper 设置为 Completion(IteratorClose(syncIteratorRecord, valueWrapper))。
IfAbruptRejectPromise(valueWrapper, promiseCapability)。
令 unwrap 为参数为 (value) 的新 Abstract Closure，它捕获 done，并在被调用时执行以下步骤：
1. 返回 CreateIteratorResultObject(value, done)。
令 onFulfilled 为 CreateBuiltinFunction(unwrap, 1, "", « »)。
注：onFulfilled 用于处理 IteratorResult 对象的 "value" 属性，以便在其值是 promise 时等待该值，并将结果重新封装到新的“已解包”IteratorResult 对象中。
如果 done 是 true 或 closeOnRejection 是 false，则
1. 令 onRejected 为 undefined。
否则，
1. 令 closeIterator 为参数为 (error) 的新 Abstract Closure，它捕获 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 接口包含表 87 中描述的属性：

表 87: Disposable 接口必需属性

属性值要求

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

%Symbol.dispose%

a function object

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

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

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

27.2.1.2 AsyncDisposable 接口

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

表 88: AsyncDisposable 接口必需属性

属性值要求

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

%Symbol.asyncDispose%

a function object that returns a promise

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

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

将 AsyncDisposable 对象与 await using 声明一起使用时，在直接包含该声明的 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]] 设置为新的空 List。
返回 disposableStack。

27.3.2 DisposableStack 构造函数的属性

DisposableStack 构造函数：

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

27.3.2.1 DisposableStack.prototype

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

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

27.3.3 DisposableStack 原型对象的属性

DisposableStack 原型对象：

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

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

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

令 disposableStack 为 this value。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDispose) 是 false，则抛出 TypeError 异常。
令 closure 为不带参数的新 Abstract 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 value。
执行 ? 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 value。
执行 ? 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 value。
执行 ? RequireInternalSlot(disposableStack, [[DisposableState]])。
如果 disposableStack.[[DisposableState]] 是 disposed，则返回 true。
返回 false。

27.3.3.6 DisposableStack.prototype.move ( )

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

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

27.3.3.7 DisposableStack.prototype.use ( `value` )

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

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

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

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

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 实例最初创建时具有表 89 中描述的内部槽。

表 89: DisposableStack 实例的内部槽

内部槽	类型	描述
`[[DisposableState]]`	pending or disposed	控制可处置栈如何响应对其 `%Symbol.dispose%` 方法的调用。
`[[DisposableResourceStack]]`	a List of DisposableResource Records	可处置栈被处置时要处置的资源。资源按照初始化顺序添加，并按照相反顺序处置。

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]] 设置为新的空 List。
返回 asyncDisposableStack。

27.4.2 AsyncDisposableStack 构造函数的属性

AsyncDisposableStack 构造函数：

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

27.4.2.1 AsyncDisposableStack.prototype

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

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

27.4.3 AsyncDisposableStack 原型对象的属性

AsyncDisposableStack 原型对象：

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

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

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

令 asyncDisposableStack 为 this value。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则抛出 ReferenceError 异常。
如果 IsCallable(onDisposeAsync) 是 false，则抛出 TypeError 异常。
令 closure 为不带参数的新 Abstract 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 value。
执行 ? 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 ( )

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

令 asyncDisposableStack 为 this value。
执行 ? 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 value。
执行 ? RequireInternalSlot(asyncDisposableStack, [[AsyncDisposableState]])。
如果 asyncDisposableStack.[[AsyncDisposableState]] 是 disposed，则返回 true。
返回 false。

27.4.3.6 AsyncDisposableStack.prototype.move ( )

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

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

27.4.3.7 AsyncDisposableStack.prototype.use ( `value` )

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

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

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

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

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 实例最初创建时具有表 90 中描述的内部槽。

表 90: AsyncDisposableStack 实例的内部槽

内部槽	类型	描述
`[[AsyncDisposableState]]`	pending or disposed	控制可处置栈如何响应对其 `%Symbol.asyncDispose%` 方法的调用。
`[[DisposableResourceStack]]`	a List of DisposableResource Records	可处置栈被处置时要处置的资源。资源按照初始化顺序添加，并按照相反顺序处置。

27.5 Promise 对象

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

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

如果 p.then(f, r) 会立即将一个调用函数 f 的 Job 加入队列，则 promise p 已兑现。
如果 p.then(f, r) 会立即将一个调用函数 r 的 Job 加入队列，则 promise p 已拒绝。
如果 promise 既未兑现也未拒绝，则它处于待处理状态。

如果 promise 不处于待处理状态，即它已兑现或已拒绝，则称该 promise 已敲定。

如果 promise 已敲定，或者已被“锁定”为匹配另一个 promise 的状态，则称该 promise 已解决。尝试解决或拒绝一个已经解决的 promise 不会产生任何效果。如果 promise 尚未解决，则称其未解决。未解决的 promise 始终处于待处理状态。已解决的 promise 可以处于待处理、已兑现或已拒绝状态。

thenable 是一个对象 obj，对其执行 Get(obj, "then") 会返回函数对象。

27.5.1 Promise 抽象操作

27.5.1.1 PromiseCapability Record

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

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

表 91: PromiseCapability Record 字段

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

27.5.1.1.1 IfAbruptRejectPromise ( `value`, `capability` )

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

IfAbruptRejectPromise(value, capability).

与以下内容具有相同含义：

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

27.5.1.2 PromiseReaction Record

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

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

表 92: PromiseReaction Record 字段

字段名称	值	含义
`[[Capability]]`	a PromiseCapability Record or undefined	此 Record 为其提供反应处理器的 promise 的 capability。
`[[Type]]`	fulfill or reject	当 `[[Handler]]` 为 empty 时，`[[Type]]` 用于允许与敲定类型相关的特定行为。
`[[Handler]]`	a JobCallback Record or empty	应应用于传入值的函数，其返回值将决定派生 promise 随后发生什么。如果 `[[Handler]]` 是 empty，则改用一个依赖 `[[Type]]` 值的函数。

27.5.1.3 CreateResolvingFunctions ( `toResolve` )

抽象操作 CreateResolvingFunctions，接收参数 toResolve (Promise)；返回值：记录 (字段：[[Resolve]] (函数对象), [[Reject]] (函数对象))。调用时执行以下步骤：

令 promiseOrEmpty 为 Record { [[Value]]: toResolve }。
令 resolveSteps 为参数为 (resolution) 的新 Abstract Closure，它捕获 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 是突然完成，则
  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 为参数为 (reason) 的新 Abstract Closure，它捕获 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` )

抽象操作 FulfillPromise，接收参数 promise (Promise) 和 value (ECMAScript 语言值)；返回值：unused。调用时执行以下步骤：

断言：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` )

抽象操作 NewPromiseCapability，接收参数 ctor (ECMAScript 语言值)；返回值：(正常完成 (值：PromiseCapability 记录) 或抛出完成)。它尝试以类似内置 Promise 构造函数的方式将 ctor 用作构造函数，以创建 promise 并提取其 resolve 和 reject 函数。该 promise 加上 resolve 和 reject 函数用于初始化新的 PromiseCapability Record。调用时执行以下步骤：

如果 IsConstructor(ctor) 是 false，则抛出 TypeError 异常。
注：假定 ctor 是支持 Promise 构造函数参数约定的构造函数（参见 27.5.3.1）。
令 resolvingFuncs 为 Record { [[Resolve]]: undefined, [[Reject]]: undefined }。
令 executorClosure 为参数为 (resolve, reject) 的新 Abstract Closure，它捕获 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]] }。

注

此抽象操作支持 Promise 子类化，因为它可以通用于任何以与 Promise 构造函数相同方式调用传入 executor 函数参数的构造函数。它用于将 Promise 构造函数的静态方法推广到任何子类。

27.5.1.6 IsPromise ( `arg` )

抽象操作 IsPromise，接收参数 arg (ECMAScript 语言值)；返回值：Boolean。它检查对象是否具有 promise 品牌。调用时执行以下步骤：

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

27.5.1.7 RejectPromise ( `promise`, `reason` )

抽象操作 RejectPromise，接收参数 promise (Promise) 和 reason (ECMAScript 语言值)；返回值：unused。调用时执行以下步骤：

断言：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` )

抽象操作 TriggerPromiseReactions，接收参数 reactions (列表 (元素：PromiseReaction 记录)) 和 arg (ECMAScript 语言值)；返回值：unused。它为 reactions 中的每个 Record 将一个新的 Job 加入队列。每个此类 Job 处理 PromiseReaction Record 的 [[Type]] 和 [[Handler]]，如果 [[Handler]] 不是 empty，则调用它并传入给定参数。如果 [[Handler]] 是 empty，则行为由 [[Type]] 决定。调用时执行以下步骤：

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

27.5.1.9 HostPromiseRejectionTracker ( `promise`, `operation` )

宿主定义的抽象操作 HostPromiseRejectionTracker，接收参数 promise (Promise) 和 operation (("reject" 或 "handle"))；返回值：unused。它允许宿主环境跟踪 promise 拒绝。

HostPromiseRejectionTracker 的默认实现是返回 unused。

注 1

HostPromiseRejectionTracker 会在两种情况下被调用：

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

HostPromiseRejectionTracker 的典型实现可能会尝试向开发者通知未处理的拒绝，同时也会谨慎地在随后附加新处理器而使先前通知失效时通知他们。

注 2

如果 operation 是 "handle"，实现不应以会干扰垃圾回收的方式保留对 promise 的引用。如果 operation 是 "reject"，实现可以保留对 promise 的引用，因为预期拒绝很少发生，也不会出现在热点代码路径上。

27.5.2 Promise Job

27.5.2.1 NewPromiseReactionJob ( `reaction`, `arg` )

抽象操作 NewPromiseReactionJob，接收参数 reaction (PromiseReaction 记录) 和 arg (ECMAScript 语言值)；返回值：记录 (字段：[[Job]] (a Job Abstract Closure), [[Realm]] ((Realm 记录或 null)))。它返回一个新的 Job Abstract Closure，该闭包将适当的处理器应用于传入值，并使用处理器的返回值来解决或拒绝与该处理器关联的派生 promise。调用时执行以下步骤：

令 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 不是突然完成。
  2. 返回 empty。
7. 断言：promiseCapability 是 PromiseCapability Record。
8. 如果 handlerResult 是突然完成，则
  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 是正常完成，则将 handlerRealm 设置为 getHandlerRealmResult.[[Value]]。
3. 否则，将 handlerRealm 设置为当前 Realm Record。
4. 注：除非处理器是 undefined，否则 handlerRealm 永远不会是 null。当处理器是已撤销的 Proxy 且没有 ECMAScript 代码运行时，handlerRealm 用于创建错误对象。
返回 Record { [[Job]]: job, [[Realm]]: handlerRealm }。

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

抽象操作 NewPromiseResolveThenableJob，接收参数 promiseToResolve (Promise)、thenable (Object) 和 then (JobCallback 记录)；返回值：记录 (字段：[[Job]] (a Job Abstract Closure), [[Realm]] (Realm 记录))。调用时执行以下步骤：

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

注

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

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 是突然完成，则
1. 执行 ? Call(resolvingFuncs.[[Reject]], undefined, « completion.[[Value]] »)。
返回 promise。

注

executor 参数必须是函数对象。调用它是为了启动并报告此 Promise 所表示的可能延迟操作的完成情况。调用 executor 时传入两个参数：resolve 和 reject。executor 函数可以使用这些函数来报告延迟计算最终完成或失败。从 executor 函数返回并不意味着延迟操作已经完成，而只意味着最终执行该延迟操作的请求已被接受。

传递给 executor 函数的 resolve 函数接受一个参数。executor 代码最终可以调用 resolve 函数，以表明它希望解决关联的 Promise。传递给 resolve 函数的参数表示延迟操作的最终值，可以是实际兑现值，也可以是另一个 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 value。
令 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 是突然完成，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

注

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

27.5.4.1.1 GetPromiseResolve ( `promiseCtor` )

抽象操作 GetPromiseResolve，接收参数 promiseCtor (构造函数)；返回值：(正常完成 (值：函数对象) 或抛出完成)。调用时执行以下步骤：

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

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

抽象操作 PerformPromiseAll，接收参数 iteratorRecord (Iterator 记录)、ctor (构造函数)、resultCapability (PromiseCapability 记录) 和 promiseResolve (函数对象)；返回值：(正常完成 (值：Object) 或抛出完成)。调用时执行以下步骤：

令 values 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保即使存在行为异常的 "then" 在输入 iterator 耗尽之前就调用传入的回调，resultCapability.[[Resolve]] 也只会被调用一次。
令 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 为参数为 (value) 的新 Abstract Closure，它捕获 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 value。
令 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 是突然完成，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

注

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

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

抽象操作 PerformPromiseAllSettled，接收参数 iteratorRecord (Iterator 记录)、ctor (构造函数)、resultCapability (PromiseCapability 记录) 和 promiseResolve (函数对象)；返回值：(正常完成 (值：Object) 或抛出完成)。调用时执行以下步骤：

令 values 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保即使存在行为异常的 "then" 在输入 iterator 耗尽之前就调用传入的某个回调，resultCapability.[[Resolve]] 也只会被调用一次。
令 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 为参数为 (value) 的新 Abstract Closure，它捕获 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 为参数为 (error) 的新 Abstract Closure，它捕获 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 value。
令 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 是突然完成，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

注

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

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

抽象操作 PerformPromiseAny，接收参数 iteratorRecord (Iterator 记录)、ctor (构造函数)、resultCapability (PromiseCapability 记录) 和 promiseResolve (函数对象)；返回值：(正常完成 (值：Object) 或抛出完成)。调用时执行以下步骤：

令 errors 为新的空 List。
注：remainingElementsCount 从 1 而不是 0 开始，以确保即使存在行为异常的 "then" 在输入 iterator 耗尽之前就调用传入的回调，resultCapability.[[Reject]] 也只会被调用一次。
令 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 为参数为 (error) 的新 Abstract Closure，它捕获 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 会以与第一个敲定的传入 promise 相同的方式敲定。执行此算法时，它会将传入 iterable 的所有元素都解决为 promise。

令 ctor 为 this value。
令 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 是突然完成，则
1. 如果 iteratorRecord.[[Done]] 是 false，则将 result 设置为 Completion(IteratorClose(iteratorRecord, result))。
2. IfAbruptRejectPromise(result, promiseCapability)。
返回 ! result。

注 1

如果 iterable 参数不产生任何值，或者 iterable 产生的 promise 都永远不会敲定，那么此方法返回的待处理 promise 将永远不会敲定。

注 2

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

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

抽象操作 PerformPromiseRace，接收参数 iteratorRecord (Iterator 记录)、ctor (构造函数)、resultCapability (PromiseCapability 记录) 和 promiseResolve (函数对象)；返回值：(正常完成 (值：Object) 或抛出完成)。调用时执行以下步骤：

重复执行，
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 value。
令 promiseCapability 为 ? NewPromiseCapability(ctor)。
执行 ? Call(promiseCapability.[[Reject]], undefined, « reason »)。
返回 promiseCapability.[[Promise]]。

注

此函数预期其 this value 是支持 Promise 构造函数参数约定的构造函数。

27.5.4.7 Promise.resolve ( `resolution` )

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

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

注

此函数预期其 this value 是支持 Promise 构造函数参数约定的构造函数。

27.5.4.7.1 PromiseResolve ( `ctor`, `resolution` )

抽象操作 PromiseResolve，接收参数 ctor (Object) 和 resolution (ECMAScript 语言值)；返回值：(正常完成 (值：Object) 或抛出完成)。它返回一个以 resolution 解决的新 promise。调用时执行以下步骤：

如果 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 value。
如果 ctor 不是 Object，则抛出 TypeError 异常。
令 status 为 Completion(Call(callback, undefined, args))。
如果 status 是突然完成，则
1. 令 promiseCapability 为 ? NewPromiseCapability(ctor)。
2. 执行 ? Call(promiseCapability.[[Reject]], undefined, « status.[[Value]] »)。
3. 返回 promiseCapability.[[Promise]]。
否则，
1. 返回 ? PromiseResolve(ctor, ! status)。

注

此函数预期其 this value 是支持 Promise 构造函数参数约定的构造函数。

27.5.4.9 Promise.withResolvers ( )

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

令 ctor 为 this value。
令 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 value。

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

注

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

27.5.5 Promise 原型对象的属性

Promise 原型对象：

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

27.5.5.1 Promise.prototype.catch ( `onRejected` )

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

令 promise 为 this value。
返回 ? 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 value。
如果 promise 不是 Object，则抛出 TypeError 异常。
令 ctor 为 ? SpeciesConstructor(promise, %Promise%)。
断言：IsConstructor(ctor) 是 true。
如果 IsCallable(onFinally) 是 false，则
1. 令 thenFinally 为 onFinally。
2. 令 catchFinally 为 onFinally。
否则，
1. 令 thenFinallyClosure 为参数为 (value) 的新 Abstract Closure，它捕获 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 为参数为 (reason) 的新 Abstract Closure，它捕获 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 value。
如果 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` ] )

抽象操作 PerformPromiseThen，接收参数 promise (Promise)、onFulfilled (ECMAScript 语言值) 和 onRejected (ECMAScript 语言值)和可选参数 resultCapability (PromiseCapability 记录)；返回值：(Object 或 undefined)。它使用 onFulfilled 和 onRejected 作为敲定操作，对 promise 执行“then”操作。如果传入 resultCapability，则通过更新 resultCapability 的 promise 来存储结果。如果未传入，则 PerformPromiseThen 是由规范内部操作调用，其结果并不重要。调用时执行以下步骤：

断言：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 实例最初创建时具有表 93 中描述的内部槽。

表 93: Promise 实例的内部槽

内部槽	类型	描述
`[[PromiseState]]`	pending, fulfilled, or rejected	控制 promise 如何响应对其 `then` 方法的调用。
`[[PromiseResult]]`	an ECMAScript language value or empty	promise 已兑现或拒绝所使用的值（如果有）。当且仅当 `[[PromiseState]]` 是 pending 时为 empty。
`[[PromiseFulfillReactions]]`	a List of PromiseReaction Records	当且如果 promise 从 pending 状态转换为 fulfilled 状态时要处理的 Record。
`[[PromiseRejectReactions]]`	a List of PromiseReaction Records	当且如果 promise 从 pending 状态转换为 rejected 状态时要处理的 Record。
`[[PromiseIsHandled]]`	a Boolean	指示 promise 是否曾经具有兑现或拒绝处理器；用于未处理拒绝跟踪。

27.6 GeneratorFunction 对象

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

数量惊人的各种方框和箭头。 — 图 6 (资料性): Generator 对象关系

27.6.1 GeneratorFunction 构造函数

GeneratorFunction 构造函数：

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

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

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

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

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

注

参见 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%（参见图 6）。
是普通对象。
不是函数对象，并且不具有 [[ECMAScriptCode]] 内部槽，也不具有表 26 或表 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 函数对象，并具有表 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 函数 "prototype" 属性的初始值。当使用 [[Call]] 调用 generator 函数对象时，prototype 属性的值用于初始化新创建 Generator 的 [[Prototype]] 内部槽。

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

注

与 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 函数对象的 ECMAScript 句法形式都会创建 AsyncGeneratorFunction 的直接实例。没有句法手段可以创建 AsyncGeneratorFunction 子类的实例。

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

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

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

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

注

参见 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]] 内部槽，也不具有表 26 或表 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 函数对象，并具有表 26 中列出的内部槽。所有此类实例的 [[IsClassConstructor]] 内部槽的值都是 false。

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

27.7.4.1 length

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

此属性具有特性 { [[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 函数 "prototype" 属性的初始值。当使用 [[Call]] 调用 generator 函数对象时，prototype 属性的值用于初始化新创建 AsyncGenerator 的 [[Prototype]] 内部槽。

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

注

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

27.8 Generator 对象

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

Generator 实例直接从创建该实例的 generator 函数的 "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, value, empty)。

27.8.1.3 %GeneratorPrototype%.return ( `value` )

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

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

27.8.1.4 %GeneratorPrototype%.throw ( `exception` )

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

令 gen 为 this value。
令 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 实例最初创建时具有表 94 中描述的内部槽。

表 94: Generator 实例的内部槽

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

27.8.3 Generator 抽象操作

27.8.3.1 GeneratorStart ( `gen`, `genBody` )

抽象操作 GeneratorStart，接收参数 gen (Generator) 和 genBody ((a FunctionBody Parse Node 或无参数的抽象闭包))；返回值：unused。调用时执行以下步骤：

断言：gen.[[GeneratorState]] 是 suspended-start。
令 genContext 为正在运行的执行上下文。
将 genContext 的 Generator 组件设置为 gen。
令 closure 为不带参数的新 Abstract Closure，它捕获 genBody，并在被调用时执行以下步骤：
1. 令 acGenContext 为正在运行的执行上下文。
2. 令 acGen 为 acGenContext 的 Generator 组件。
3. 如果 genBody 是 Parse Node，则
  1. 令 result 为 Completion(Evaluation of genBody)。
4. 否则，
  1. 断言：genBody 是不带参数的 Abstract Closure。
  2. 令 result 为 Completion(genBody())。
5. 断言：如果在此返回，则 generator 要么抛出了异常，要么执行了隐式或显式 return。
6. 从执行上下文栈中移除 acGenContext，并恢复执行上下文栈顶部的执行上下文作为正在运行的执行上下文。
7. 将 acGen.[[GeneratorState]] 设置为 completed。
8. 注：一旦 generator 进入 completed 状态，它就永远不会离开该状态，并且其关联的执行上下文永远不会恢复。此时可以丢弃与 acGen 关联的任何执行状态。
9. 如果 result 是抛出完成，则
  1. 令 resumption 为 result。
10. 否则，
  1. 如果 result 是正常完成，则
    1. 令 resultValue 为 undefined。
  2. 否则如果 result 是返回完成，则
    1. 令 resultValue 为 result.[[Value]]。
  3. 令 resumption 为 NormalCompletion(CreateIteratorResultObject(resultValue, true))。
11. 令 callerContext 为正在运行的执行上下文。
12. 恢复 callerContext，传入 resumption。
13. 断言：永远不会到达此步骤。
设置 genContext 的代码求值状态，使得当该执行上下文恢复求值时，将无参数调用 closure。
将 gen.[[GeneratorContext]] 设置为 genContext。
返回 unused。

27.8.3.2 GeneratorValidate ( `gen`, `genBrand` )

抽象操作 GeneratorValidate，接收参数 gen (ECMAScript 语言值) 和 genBrand ((String 或 empty))；返回值：(正常完成 (值：(suspended-start、suspended-yield 或 completed)) 或抛出完成)。调用时执行以下步骤：

执行 ? 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` )

抽象操作 GeneratorResume，接收参数 gen (ECMAScript 语言值)、value ((ECMAScript 语言值或 empty)) 和 genBrand ((String 或 empty))；返回值：(正常完成 (值：ECMAScript 语言值) 或抛出完成)。调用时执行以下步骤：

令 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` )

抽象操作 GeneratorResumeAbrupt，接收参数 gen (ECMAScript 语言值)、abruptCompletion ((返回完成或抛出完成)) 和 genBrand ((String 或 empty))；返回值：(正常完成 (值：ECMAScript 语言值) 或抛出完成)。调用时执行以下步骤：

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

27.8.3.5 GetGeneratorKind ( )

抽象操作 GetGeneratorKind，接收无参数；返回值：(non-generator、sync 或 async)。调用时执行以下步骤：

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

27.8.3.6 GeneratorYield ( `iteratorResult` )

抽象操作 GeneratorYield，接收参数 iteratorResult (an Object that conforms to the IteratorResult interface)；返回值：(正常完成 (值：ECMAScript 语言值) 或突兀完成)。调用时执行以下步骤：

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

27.8.3.7 Yield ( `arg` )

抽象操作 Yield，接收参数 arg (ECMAScript 语言值)；返回值：(正常完成 (值：ECMAScript 语言值) 或突兀完成)。调用时执行以下步骤：

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

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

抽象操作 CreateIteratorFromClosure，接收参数 closure (无参数的抽象闭包)、genBrand ((String 或 empty)) 和 genProto (Object)和可选参数 extraSlots (列表 (元素：内部槽名称))；返回值：Generator。调用时执行以下步骤：

注：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 函数创建，并且同时符合 async iterator 接口和 async iterable 接口。

AsyncGenerator 实例直接从创建该实例的 async generator 函数的 "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 value。
令 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 value。
令 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 value。
令 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 实例最初创建时具有下述内部槽：

表 95: AsyncGenerator 实例的内部槽

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

27.9.3 AsyncGenerator 抽象操作

27.9.3.1 AsyncGeneratorRequest Record

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

它们具有以下字段：

表 96: AsyncGeneratorRequest Record 字段

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

27.9.3.2 AsyncGeneratorStart ( `gen`, `genBody` )

抽象操作 AsyncGeneratorStart，接收参数 gen (AsyncGenerator) 和 genBody ((a FunctionBody Parse Node 或无参数的抽象闭包))；返回值：unused。调用时执行以下步骤：

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

27.9.3.3 AsyncGeneratorValidate ( `gen`, `genBrand` )

抽象操作 AsyncGeneratorValidate，接收参数 gen (ECMAScript 语言值) 和 genBrand ((String 或 empty))；返回值：(正常完成 (值：unused) 或抛出完成)。调用时执行以下步骤：

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

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

抽象操作 AsyncGeneratorEnqueue，接收参数 gen (AsyncGenerator)、completion (完成记录) 和 promiseCapability (PromiseCapability 记录)；返回值：unused。调用时执行以下步骤：

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

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

抽象操作 AsyncGeneratorCompleteStep，接收参数 gen (AsyncGenerator)、completion (完成记录) 和 done (Boolean)和可选参数 realm (Realm 记录)；返回值：unused。调用时执行以下步骤：

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

抽象操作 AsyncGeneratorResume，接收参数 gen (AsyncGenerator) 和 completion (完成记录)；返回值：unused。调用时执行以下步骤：

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

27.9.3.7 AsyncGeneratorUnwrapYieldResumption ( `resumptionValue` )

抽象操作 AsyncGeneratorUnwrapYieldResumption，接收参数 resumptionValue (完成记录)；返回值：(正常完成 (值：ECMAScript 语言值) 或突兀完成)。调用时执行以下步骤：

如果 resumptionValue 不是返回完成，则返回 ? resumptionValue。
令 awaited 为 Completion(Await(resumptionValue.[[Value]]))。
如果 awaited 是抛出完成，则返回 ? awaited。
断言：awaited 是正常完成。
返回 ReturnCompletion(awaited.[[Value]])。

27.9.3.8 AsyncGeneratorYield ( `arg` )

抽象操作 AsyncGeneratorYield，接收参数 arg (ECMAScript 语言值)；返回值：(正常完成 (值：ECMAScript 语言值) 或突兀完成)。调用时执行以下步骤：

令 genContext 为正在运行的执行上下文。
断言：genContext 是 generator 的执行上下文。
令 gen 为 genContext 的 Generator 组件的值。
断言：GetGeneratorKind() 是 async。
令 completion 为 NormalCompletion(arg)。
断言：执行上下文栈至少有两个元素。
令 previousContext 为执行上下文栈中倒数第二个元素。
令 previousRealm 为 previousContext 的 Realm。
执行 AsyncGeneratorCompleteStep(gen, completion, false, previousRealm)。
令 queue 为 gen.[[AsyncGeneratorQueue]]。
如果 queue 非空，则
1. 注：继续执行而不挂起 generator。
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` )

抽象操作 AsyncGeneratorAwaitReturn，接收参数 gen (AsyncGenerator)；返回值：unused。调用时执行以下步骤：

断言：gen.[[AsyncGeneratorState]] 是 draining-queue。
令 queue 为 gen.[[AsyncGeneratorQueue]]。
断言：queue 非空。
令 next 为 queue 的第一个元素。
令 completion 为 Completion(next.[[Completion]])。
断言：completion 是返回完成。
令 promiseCompletion 为 Completion(PromiseResolve(%Promise%, completion.[[Value]]))。
如果 promiseCompletion 是突然完成，则
1. 执行 AsyncGeneratorCompleteStep(gen, promiseCompletion, true)。
2. 执行 AsyncGeneratorDrainQueue(gen)。
3. 返回 unused。
断言：promiseCompletion 是正常完成。
令 promise 为 promiseCompletion.[[Value]]。
令 fulfilledClosure 为参数为 (value) 的新 Abstract Closure，它捕获 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 为参数为 (reason) 的新 Abstract Closure，它捕获 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` )

抽象操作 AsyncGeneratorDrainQueue，接收参数 gen (AsyncGenerator)；返回值：unused。它会排空 generator 的 AsyncGeneratorQueue，直到遇到一个持有返回完成的 AsyncGeneratorRequest。调用时执行以下步骤：

断言：gen.[[AsyncGeneratorState]] 是 draining-queue。
令 queue 为 gen.[[AsyncGeneratorQueue]]。
当 queue 非空时，重复执行，
1. 令 next 为 queue 的第一个元素。
2. 令 completion 为 Completion(next.[[Completion]])。
3. 如果 completion 是返回完成，则
  1. 执行 AsyncGeneratorAwaitReturn(gen)。
  2. 返回 unused。
4. 如果 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 函数行为所必需内部槽的子类实例。所有用于定义 async 函数对象的 ECMAScript 句法形式都会创建 AsyncFunction 的直接实例。没有句法手段可以创建 AsyncFunction 子类的实例。

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

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

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

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

注

参见 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]] 内部槽，也不具有表 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 函数对象，并具有表 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` )

抽象操作 AsyncFunctionStart，接收参数 promiseCapability (PromiseCapability 记录) 和 asyncFuncBody ((a FunctionBody Parse Node、an ExpressionBody Parse Node 或无参数的抽象闭包))；返回值：unused。调用时执行以下步骤：

令 runningContext 为正在运行的执行上下文。
令 asyncContext 为 runningContext 的副本。
注：为了使 AsyncBlockStart 能够恢复其执行，需要复制执行状态。恢复当前正在执行的上下文是没有明确定义的。
执行 AsyncBlockStart(promiseCapability, asyncFuncBody, asyncContext)。
返回 unused。

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

抽象操作 AsyncBlockStart，接收参数 promiseCapability (PromiseCapability 记录)、asyncBody ((解析节点或无参数的抽象闭包)) 和 asyncContext (执行上下文)；返回值：unused。调用时执行以下步骤：

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

27.10.5.3 Await ( `arg` )

抽象操作 Await，接收参数 arg (ECMAScript 语言值)；返回值：(正常完成 (值：(ECMAScript 语言值或 empty)) 或抛出完成)。调用时执行以下步骤：

令 asyncContext 为正在运行的执行上下文。
令 promise 为 ? PromiseResolve(%Promise%, arg)。
令 fulfilledClosure 为参数为 (value) 的新 Abstract Closure，它捕获 asyncContext，并在被调用时执行以下步骤：
1. 执行 Completion(RunSuspendedContext(asyncContext, NormalCompletion(value)))。
2. 注：有意忽略 RunSuspendedContext 返回的 Completion Record。
3. 返回 NormalCompletion(undefined)。
令 onFulfilled 为 CreateBuiltinFunction(fulfilledClosure, 1, "", « »)。
令 rejectedClosure 为参数为 (reason) 的新 Abstract Closure，它捕获 asyncContext，并在被调用时执行以下步骤：
1. 执行 Completion(RunSuspendedContext(asyncContext, ThrowCompletion(reason)))。
2. 注：有意忽略 RunSuspendedContext 返回的 Completion Record。
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.join ( separator )

27.1.3.3.9 Iterator.prototype.map ( mapper )

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

27.1.3.3.11 Iterator.prototype.some ( predicate )

27.1.3.3.12 Iterator.prototype.take ( limit )

27.1.3.3.13 Iterator.prototype.toArray ( )

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

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

27.1.3.3.16 Iterator.prototype [ %Symbol.toStringTag% ]

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

27.1.3.3.16.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.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.join ( `separator` )

27.1.3.3.9 Iterator.prototype.map ( `mapper` )

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

27.1.3.3.11 Iterator.prototype.some ( `predicate` )

27.1.3.3.12 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` )