25.4 Promise 对象

25.4 Promise 对象

一个Promise对象是作为一个在未来会产生结果的计算（可能是异步的）的占位符 任何Promise对象只有三种互斥的状态：fulfilled, rejected 和 pending：

• 一个Promise对象 p ，如果p.then(f, r)立即把调用函数f这个操作加入队列，那说明 p 是fulfilled
• 一个Promise对象 p ，如果p.then(f, r)立即把调用函数r这个操作加入队列，那说明 p 是rejected
• 一个Promise对象既不是已完成，也不是已拒绝，那 p 的状态就是 pending

一个promise对象不是进行中，那就是已处理，比如是fulfilled或rejected 一个promise对象如果已处理或者已经被锁定了用来匹配其他promise的状态，那它就是 resolved 的，resolved的promise是不能被更改状态的。一个promise如果没有处理，那它就是unresolved。一个unresolved的promise总是处于进行中状态，一个 resolved 的promise可能是fulfilled, rejected, and pending.

25.4.1 Promise抽象操作

25.4.1.1 PromiseCapability Records

PromiseCapability 用来包装promise对象和能完成或者拒绝promise对象的函数的一个Record值，PromiseCapability records是由 NewPromiseCapability这个抽象操作产生的 PromiseCapability records 有如表58所列的字段

表58 PromiseCapability records字段

25.4.1.1.1 IfAbruptRejectPromise ( value, capability )

IfAbruptRejectPromise 是一运用PromiseCapability record的算法步骤的简写。一个算法步骤的形式：

 1. IfAbruptRejectPromise(value, capability).

意思和下面相同：

1. 如果value是一个 abrupt completion。那么：
   1. 运行 Call(capability.[[Reject]], undefined, « value.[[Value]] »)
   2. 返回 capability.[[Promise]].
2. 如果value是一个 Completion Record，使value等于value.[[Value]]

25.4.1.2 PromiseReaction Records

PromiseReaction 是一个用来存储当promise变为rejected或resolved时如何响应的信息。PromiseReaction records是由 PerformPromiseThen 这个抽象操作产生的，在 PromiseReactionJob 中使用 PromiseReaction records有如表59所列的字段

表59：PromiseReaction Record Fields

25.4.1.3 CreateResolvingFunctions ( promise )

当CreateResolvingFunctions以promise为参数运行时，其步骤如下：

1. 使 alreadyResolved 是一个新的 Record {[[Value]:false]}
2. 使 resolve 是一个新的如Promise Resolve Functions (25.4.1.3.2)中定义的内置函数对象
3. 设置 resolve 的内置[[Promise]]属性为promise
4. 设置 resolve 的内置[[AlreadyResolved]]属性为alreadyResolved
5. 使 reject 是一个新的如 Promise Reject Functions (25.4.1.3.1)中定义的内置函数对象
6. 设置 reject 的内置[[Promise]]属性为promise
7. 设置 reject 的内置[[AlreadyResolved]]属性为alreadyResolved
8. 返回一个新的 Record { [[Resolve]]: resolve, [[Reject]]: reject }

25.4.1.3.1 Promise Reject Functions

一个 promise reject function 是一个拥有内置属性[[Promise]]和[[AlreadyResolved]]的内置函数对象 当一个 promise reject functions F 以reason参数调用时，会有如下操作过程：

1. 断言：F有一个Object类型的内置属性[[Promise]]
2. 使 promise 是F的内置属性[[Promise]]
3. 使 alreadyResolved 是F的内置属性[[AlreadyResolved]]
4. 如果 alreadyResolved.[[Value]] 的值是true，返回undefined
5. 设置 alreadyResolved.[[Value]] 的值是true
6. 返回 RejectPromise(promise, reason)

promise reject function的length值是1

25.4.1.3.2 Promise Resolve Functions

一个 promise resolve function 是一个拥有内置属性[[Promise]]和[[AlreadyResolved]]的内置函数对象 当一个 promise resolve function F 以 resolution 参数调用时，会有如下操作过程：

1. 断言：F有一个Object类型的内置属性[[Promise]]
2. 使 promise 是F的内置属性[[Promise]]
3. 使 alreadyResolved 是F的内置属性[[AlreadyResolved]]
4. 如果 alreadyResolved.[[Value]] 的值是true，返回undefined
5. 设置 alreadyResolved.[[Value]] 的值是true
6. 如果 SameValue(resolution, promise) 得到的值是true，那么：
   • 新建一个名为 selfResolutionError 的 TypeError对象
   • 返回 RejectPromise(promise, selfResolutionError)
7. 如果Type(resolution) 不是一个对象，那么返回 FulfillPromise(promise, resolution)
8. 使 then 是 Get(resolution, “then”) 的值
9. 如果 then 是一个 abrupt completion 那么 返回 RejectPromise(promise,then.[[Value]])
10. 使 thenAction 是 then.[[Value]]
11. 如果 IsCallable(thenAction) 是false，那么返回 FulfillPromise(promise,resolution)
12. 运行 EnqueueJob(“PromiseJobs”, PromiseResolveThenableJob, « promise, resolution, thenAction »).
13. 返回undefined

25.4.1.4 FulfillPromise(promise,value)

当FullfillPromise 抽象操作以promise,value两个参数调用时，操作过程如下：

1. 断言：promise的内部属性[[PromiseState]]是”pending”
2. 使 reactions 是promise的内部属性[[PromiseFulfillReactions]]的值
3. 把promise的内部属性[[PromiseResult]]的值设为value
4. 把promise的内部属性[[PromiseFulfillReactions]]的值设为undefined
5. 把promise的内部属性[[PromiseRejectReactions]]的值设为undefined
6. 把promise的内部属性[[PromiseState]]的值设为”fulfilled”
7. 返回 TriggerPromiseReactions(reactions, value)

25.4.1.5 NewPromiseCapability ( C )

NewPromiseCapability 这个抽象操作尝试利用传入的构造函数当作内置的Promise构造函数，新建一个Promise对象，并且提取出其resolve和reject函数，这个promise对象和resolve和reject函数作为初始化一个新的PromiseCapability记录，这个新的PromiseCapability记录作为这个抽象操作的返回值

1. 如果 IsConstructor(C) 是false，抛出一个TypeError异常
2. 注意 C 是被当作一个符合Promise构造函数的参数规范的构造函数
3. 使 promiseCapability 是一个新的 PromiseCapability { [[Promise]]: undefined, [[Resolve]]: undefined, [[Reject]]: undefined }.
4. 使 executor 是一个新的内置的在GetCapabilitiesExecutor Functions（25.4.1.5.1）中定义的函数对象
5. 设置 executor 的内置属性[[Capability]]为promiseCapability
6. 使 promise 是 Construct(C, « executor »)
7. 如果 IsCallable(promiseCapability.[[Resolve]]) 是false，抛出TypeError异常
8. 如果 IsCallable(promiseCapability.[[Reject]]) 是false，抛出TypeError异常
9. 设置 promiseCapability.[[Promise]] 的值是promise
10. 返回 promiseCapability

注意：这个抽象操作可以作为Promise的子类，它是一个通用构造函数和Promise构造函数一样的调用方式，传入一个executor参数。它是用来概括任意继承Promise的构造函数的静态方法

25.4.1.5.1 GetCapabilitiesExecutor Functions

一个GetCapabilitiesExecutor函数是一个有内置属性[[Capability]]的匿名内置函数 当GetCapabilitiesExecutor函数 F 以resolve和reject作为参数调用时，操作过程如下：

1. 断言：F有值是一个PromiseCapability Record的内置属性[[Capability]]
2. 使promiseCapability是 F 的内置属性[[Capability]]的值
3. 如果promiseCapability.[[Resolve]]不是undefined, 抛出TypeError异常.
4. 如果promiseCapability.[[Reject]]不是undefined, 抛出TypeError异常.
5. 设置promiseCapability.[[Resolve]] 为 resolve.
6. 设置promiseCapability.[[Reject]] 为 reject.
7. 返回 undefined.

一个GetCapabilitiesExecutor函数的length属性值是2

25.4.1.6 IsPromise(x)

这个抽象操作用来简写promise是否是一个对象

1. 如果Type(x) 值不是Object，返回false
2. 如果x没有内置属性[[PromiseState]]，返回false
3. 返回true

25.4.1.7 RejectPromise ( promise, reason )

当这个抽象操作以promise和reason为参数调用时，其操作过程如下：

1. 断言：promise的内置属性 [[PromiseState]]值为”pending”
2. 使 reactions 的值是promise的内置属性[[PromiseRejectReactions]] 的值
3. 设置 promise的 [[PromiseResult]] 值为 reason.
4. 设置 promise的 [[PromiseFulfillReactions]] 值为 undefined.
5. 设置 promise的 [[PromiseRejectReactions]] 值为 undefined.
6. 设置 promise的 [[PromiseState]] 值为 “rejected”.
7. 如果 promise的值[[PromiseIsHandled]] 是false，运行 HostPromiseRejectionTracker(promise, “reject”).
8. 返回 TriggerPromiseReactions(reactions, reason).

25.4.1.8 TriggerPromiseReactions ( reactions, argument )

这个抽象操作为一组 PromiseReactionRecords 中的每一个record分配一个任务，每个任务执行PromiseReactionRecord的[[Handler]]，并且如果[[Handler]]是一个函数，会把传入的参数传给它。

1. 以最初插入时的顺序取出reactions中的每个reaction，并且执行下面的过程：
   • 运行 EnqueueJob(“PromiseJobs”, PromiseReactionJob, « reaction, argument »)
2. 返回undefined

25.4.1.9 HostPromiseRejectionTracker ( promise, operation )

这是一个定义实现的抽象操作，允许宿主环境最终promise的rejections 一个 HostPromiseRejectionTracker 的实现必须实现所有可能的情况，默认实现什么也不做

注意1：有两种情况调用 HostPromiseRejectionTracker

• 当一个promise 没有任何handler就rejected时，会以”reject”为operation参数调用
• 当第一次用一个handler去rejected一个promise时，会以”handle”为operation参数调用

一个典型的HostPromiseRejectionTracker实现可能会尝试去提醒开发者没有handler的reject操作，同时要小心提醒如果这种提醒会因为新的handler加入而失效。

注意2：如果operation是”handle”，一个实现就不应该持有promise的引用，因为会影响内存回收，应该持有如果operation是”reject”的promise引用，因为我们认为reject操作是很少发生的。

25.4.2 Promise Jobs

25.4.2.1 PromiseReactionJob(reaction,argument)

这个PromiseReactionJob就是以reaction和argument为参数调用handler去处理输入值，并且以hendler的返回值去resolve或者reject和handle关联的promise

1. 断言：reaction是一个PromiseReaction Record
2. 使 promiseCapability 是reaction.[[Capabilities]]
3. 使 handler 是reaction.[[Handler]].
4. 如果 handler 是 “Identity”，使handlerResult是NormalCompletion(argument)
5. 否则如果 handler 是 “Thrower”，使handlerResult 是 Completion{[[Type]]: throw, [[Value]]: argument, [[Target]]: empty}.
6. 否则使 handlerResult 是 Call(handler, undefined, « argument »).
7. 如果 handlerResult 是 abrupt completion,就：
   • 使status是 Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »).
   • NextJob Completion(status)
8. 使status是 Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »).
9. NextJob Completion(status)

25.4.2.2 PromiseResolveThenableJob ( promiseToResolve, thenable, then)

其操作过程如下：

1. 使 resolvingFunctions 是 CreateResolvingFunctions(promiseToResolve).
2. 使 thenCallResult 是 Call(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
3. 如果 thenCallResult 是 abrupt completion, 就
   • 使 status 是 Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).
   • NextJob Completion(status).
4. NextJob Completion(thenCallResult).

注意：这个任务使用提供的thenable和then方法去resolve所给的promise，这个处理过程必须确保在其他代码都已经执行完之后再执行

25.4.3 Promise构造函数

Promise构造函数是%Promise%这个intrinsic 对象，并且是全局对象Promise的值，当以构造函数的形式调用它，会初始化一个新的Promise对象。Promise不能以普通函数的形式调用，如果那样的话会抛出异常
Promise被设计成是可以继承，它可以被用来作为一个类的扩展，子类构造函数设计时需要继承Promise规定的那些行为中必须包括super，以此来调用Promise的构造函数来创建和初始化子类的实例，这个实例的内部支持Promise和Promise.prototype的内置方法

25.4.3.1 Promise(executor)

当Promise以executor为参数调用时，会有以下几步：

1. 如果NewTarget是undefined，抛出一个TypeError异常
2. 如果IsCallable(executor) 为false，抛出一个TypeError异常
3. 使promise是 OrdinaryCreateFromConstructor(NewTarget, “%PromisePrototype%”, « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »).
4. 设置 promise 的内部属性 [[PromiseState]] 为 “pending”
5. 设置 promise 的内部属性 [[PromiseFulfillReactions]] 为一个空的 List
6. 设置 promise 的内部属性 [[PromiseRejectReactions]] 为一个空的 List
7. 设置 promise 的内部属性 [[PromiseIsHandled]] 为false
8. 使 resolvingFunctions 为 CreateResolvingFunctions(promise).
9. 使 completion 为 Call(executor, undefined, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
10. 如果 completion 是 一个 abrupt completion，那么：运行 Call(resolvingFunctions.[[Reject]], undefined, « completion.[[Value]] »).
11. 返回 promise

注意：executor参数必须是一个函数对象。它被调用时是用来启动以及报告完成Promise对象所表示的那个可能的延迟对象。executor以resolve和reject两个参数调用。这些函数可能是用来报告那个延迟对象最终是完成还是失败。executor函数中的返回不意味着延迟对象已经完成了，只有最终对延迟对象的执行请求被接受了才是。
传给executor的resolve函数接受一个参数，executor可能最终会调用resolve函数，表明它将会resolve这个关联的Promise对象。传给resolve的参数将代表这个延迟对象的最终值，并且可以是实际的最终执行值或者其他已经fulfill的Promise对象所提供的值
传给executor的reject函数接受一个参数，executor可能最终会调用reject函数，表明它将会reject这个关联的Promise对象并且永远不会被fulfill。传给reject的参数将代表这个延迟对象的最终值，一般它将会是一个Error对象

25.4.4 Promise构造函数的属性

Promise构造函数的内置属性[[Prototype]]值是%FunctionPrototype% Promise构造函数有以下这些属性：

25.4.4.1 Promise.all(iterable)

all函数会返回一个新的promise实例，这个新的实例的状态取决于传入的参数。如果传入的一组promise都fulfill，那新的实例就是fulfill的，如果其中有一个promise是rejected的话，那这个新的实例就是rejected的，并且第一个rejected的promise的返回值会传给新实例的回调。它会通过下面的算法把所以传进来的iterable转换成promise。

1. 使 C 是 this 值
2. 如果Type(C) 不是 Object，抛出TypeError异常
3. 使promiseCapability 是一个 NewPromiseCapability(C)
4. 使 iterator 是GetIterator(iterable)
5. IfAbruptRejectPromise(iterator, promiseCapability)
6. 使iteratorRecord 是 Record{[[Iterator]]: iterator, [[Done]]: false}.
7. 使result 是 PerformPromiseAll(iteratorRecord, C, promiseCapability).
8. 如果result 是一个 abrupt completion，然后
   • 如果 iteratorRecord.[[Done]] 是false，使result是IteratorClose(iterator, result).
   • IfAbruptRejectPromise(result, promiseCapability)
9. 返回 Completion(result)

注意：all函数要求其this值是一个构造函数，支持把参数转换成Promise构造函数

25.4.4.1.1 运行时语法：PerformPromiseAll( iteratorRecord, constructor, resultCapability)

当 PerformPromiseAll 这个抽象操作以IteratorRecord、constructor、resultCapability这些函数调用时，会有接下来的几步：

1. 断言：constructor是一个构造函数
2. 断言：resultCapability 是一个PromiseCapability 记录
3. 使values是一个新的空的List
4. 使remainingElementsCount 是一个新的Record{[[Value]] : 1}
5. 使index等于0
6. 重复下面的步骤
   • 使next等于 IteratorStep(iteratorRecord.[[Iterator]])
   • 如果next是一个abrupt completion，设置iteratorRecord.[[Done]]等于true
   • ReturnIfAbrupt(next).
   • 如果next是false，那么
     • 设置 iteratorRecord.[[Done]] 为true
     • 设置 remainingElementsCount.[[Value]] 等于 remainingElementsCount.[[Value]] - 1.
     • 如果 remainingElementsCount.[[Value]] 等于 0：
       • 使valuesArray等于 CreateArrayFromList(values)
       • 执行 Call(resultCapability.[[Resolve]], undefined, « valuesArray »).
     • 返回 resultCapability.[[Promise]].
   • 使nextValue是IteratorValue(next)
   • 如果 nextValue 是一个abrupt completion，设置 iteratorRecord.[[Done]] 为true
   • ReturnIfAbrupt(nextValue).
   • 把 undefined 加入到 values 中
   • 使 nextPromise 是 Invoke(constructor, “resolve”, « nextValue »).
   • 使 resolveElement 是一个新的如Promise.all Resolve Element Functions中定义的内置函数对象。
   • 设置resolveElement的内置属性 [[AlreadyCalled]] 是一个新的 Record {[[Value]]: false }.
   • 设置resolveElement的内置属性 [[Index]] 是 index.
   • 设置resolveElement的内置属性 [[Values]] 是 values.
   • 设置resolveElement的内置属性 [[Capabilities]] 是 resultCapability.
   • 设置resolveElement的内置属性 [[RemainingElements]] 是 remainingElementsCount.
   • 设置 remainingElementsCount.[[Value]] 的值为 remainingElementsCount.[[Value]] + 1.
   • 执行 Invoke(nextPromise, “then”, « resolveElement, resultCapability.[[Reject]] »).
   • index = index+1

25.4.4.1.2 Promise.all Resolve Element Functions

一个Promise.all resolve element function 是一个匿名的内置函数，用来解决具体的Promise.all元素，每个Promise.all resolve element function 都有[[Index]], [[Values]], [[Capabilities]], [[RemainingElements]], 和 [[AlreadyCalled]] 这些内置属性 当一个Promise.all resolve element function F以 x 参数调用的时候，会有以下几步：

1. 使alreadyCalled的值是F的内置属性[[AlreadyCalled]]
2. 如果alreadyCalled.[[Value]]的值是true，返回undefined
3. 设置alreadyCalled.[[Value]]的值为true
4. 使index是F的内置属性[[Index]]的值
5. 使values是F的内置属性[[Values]]的值
6. 使 promiseCapability 是F的内置属性[[Capabilities]]的值
7. 使 remainingElementsCount 是F的内置属性[[RemainingElements]]的值
8. 设置values[index] 的值为x
9. 使 remainingElementsCount.[[Value]] 的值为remainingElementsCount.[[Value]] - 1.
10. 如果remainingElementsCount.[[Value]]是0，那么：
    • 使 valuesArray 为 CreateArrayFromList(values).
    • 返回 Call(promiseCapability.[[Resolve]], undefined, « valuesArray »).
11. 返回undefined

Promise.all resolve element function 的length属性值是1

25.4.4.2 Promise.prototype

Promise.prototype的初始值是 %PromisePrototype% 它有属性：{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }

25.4.4.3 Promise.race(iterable)

race函数返回一个新的Promise实例，这个实例会settled当传给他的参数中的第一个promise被settle时。它按照下面的算法把参数中的元素都resolve。

1. 使C为this值
2. 如果Type(C) 不是 Object，抛出TypeError异常
3. 使promiseCapability 是一个 NewPromiseCapability(C)
4. 使 iterator 是GetIterator(iterable)
5. IfAbruptRejectPromise(iterator, promiseCapability)
6. 使iteratorRecord 是 Record{[[Iterator]]: iterator, [[Done]]: false}.
7. 使result 是 PerformPromiseAll(iteratorRecord, C, promiseCapability).
8. 如果result 是一个 abrupt completion，然后
   • 如果 iteratorRecord.[[Done]] 是false，使result是IteratorClose(iterator, result).
   • IfAbruptRejectPromise(result, promiseCapability)
9. 返回 Completion(result)

注意1：如果iterable参数是空或者没有任何一个在iterable中的promise会通过这个方法被settle，那这个方法返回的promise将永远不会被settle了 注意2：race函数期望其this值是一个构造函数，支持把参数转换为Promise构造函数。当然也期望this值能有一个resolve方法

25.4.4.3.1 运行时方法：PerformPromiseRace ( iteratorRecord, promiseCapability, C )

当PerformPromiseRace这个抽象操作被以iteratorRecord，promiseCapability和C作为参数调用时，会有接下来的几个步骤：

1. 重复下面的步骤：
   • 使next是 IteratorStep(iteratorRecord.[[Iterator]]).
   • 如果 next 是一个 abrupt completion, 设置 iteratorRecord.[[Done]] 的值为 true.
   • ReturnIfAbrupt(next).
   • 如果 next 为 false, 那么：
     • 设置 iteratorRecord.[[Done]] 为 true.
     • 返回 promiseCapability.[[Promise]].
   • 使 nextValue 是 IteratorValue(next).
   • 如果 nextValue 是一个 abrupt completion, 设置 iteratorRecord.[[Done]] 为 true.
   • ReturnIfAbrupt(nextValue).
   • 使 nextPromise 为 Invoke(C, “resolve”, « nextValue »).
   • 执行 Invoke(nextPromise, “then”, « promiseCapability.[[Resolve]], promiseCapability.[[Reject]] »).

25.4.4.4 Promise.reject(r)

reject函数返回一个以参数为reject值得新的promise对象

1. 使 C 为 this 值.
2. 如果 Type(C) 不是 Object, 抛出一个 TypeError 异常.
3. 使 promiseCapability 为 NewPromiseCapability(C).
4. 执行 Call(promiseCapability.[[Reject]], undefined, « r »).
5. 返回 promiseCapability.[[Promise]].

注意： reject函数期望其this值是一个构造函数，支持把参数转换为Promise构造函数

25.4.4.5 Promise.resolve(x)

resolve函数返回一个以传入的参数resolved的新promise对象，如果参数是一个由Promise构造函数产生的promise对象，那么直接返回参数。

1. 使 C 为 this 值.
2. 如果 Type(C) 不是 Object, 抛出 TypeError 异常.
3. 如果 IsPromise(x) 为 true, 那么：
   • 使 xConstructor 为 Get(x, “constructor”).
   • 如果 SameValue(xConstructor, C) 为 true, 返回 x.
4. 使 promiseCapability 为 NewPromiseCapability(C).
5. 执行 Call(promiseCapability.[[Resolve]], undefined, « x »).
6. 返回 promiseCapability.[[Promise]].

25.4.4.6 get Promise [ @@species ]

Promise[@@species] 是一个访问器属性，set访问器函数为function，get访问器函数运行时有以下几步：

1. 返回this值

这个函数的name属性为”get [Symbol.species]”

注意：Promise prototype的方法一般都是用其this对象的构造函数来创建派生的对象。然而，一个子类构造函数可能通过重定义@@species 这个属性来实现重写这个默认行为

25.4.5 Promise原型对象的属性

Promise原型对象是%PromisePrototype%。其内置属性[[Prototype]] 的值是%ObjectPrototype%。Promise原型对象是一个普通的对象，它没有任何Promise实例拥有的内置属性

25.4.5.1 Promise.prototype.catch(onRejected)

当以onRejected为参数调用catch函数时，会有接下来的几步会发生：

1. 使 promise 为 this 值.
2. 返回 Invoke(promise, “then”, « undefined, onRejected »).

25.4.5.2 Promise.prototype.constructor

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

25.4.5.3 Promise.prototype.then ( onFulfilled, onRejected )

当then函数以onFulfilled 和 onRejected为参数调用时, 会发生以下几步:

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

25.4.5.3.1 PerformPromiseThen ( promise, onFulfilled, onRejected, resultCapability )

PerformPromiseThen这个抽象操作是在promise上以onFulfilled和onRejected为其处理行为执行then操作，其结果是resultCapability的promise属性值

1. 断言: IsPromise(promise) 为 true.
2. 断言: resultCapability 是一个 PromiseCapability record.
3. 如果 IsCallable(onFulfilled) 为 false, 那么：
   • 使 onFulfilled 为 “Identity”.
4. 如果 IsCallable(onRejected) 为 false, 那么：
   • 使 onRejected be “Thrower”.
5. 使 fulfillReaction 为 PromiseReaction { [[Capabilities]]: resultCapability, [[Handler]]: onFulfilled }.
6. 使 rejectReaction 为 PromiseReaction { [[Capabilities]]: resultCapability, [[Handler]]: onRejected}.
7. 如果 promise的内置属性 [[PromiseState]] 值为 “pending”, 那么：
   • 把 fulfillReaction 加入到 promise的内置属性 [[PromiseFulfillReactions]] 这个List中的末尾.
   • 把 rejectReaction 加入到 promise的内置属性 [[PromiseRejectReactions]] 这个List中的末尾.
8. 否则如果 promise的内置属性 [[PromiseState]] 值为 “fulfilled”, 那么：
   • 使 value 为 promise的内置属性 [[PromiseResult]]的值.
   • 执行 EnqueueJob(“PromiseJobs”, PromiseReactionJob, « fulfillReaction, value »).
9. 否则：
   • 断言: promise的内置属性 [[PromiseState]] 值为 “rejected”.
   • 使 reason 为 promise 的内置属性 [[PromiseResult]] 的值.
   • 如果 promise 的 [[PromiseIsHandled]] 值为 false, 执行 HostPromiseRejectionTracker(promise, “handle”).
   • 执行 EnqueueJob(“PromiseJobs”, PromiseReactionJob, « rejectReaction, reason »).
10. 设置 promise 的 [[PromiseIsHandled]] 值为 true.
11. 返回 resultCapability.[[Promise]].

25.4.5.4 Promise.prototype[ @@toStringTag ]

@@toStringTag 的初始值为 “Promise”. 这个特性有如下属性： { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.4.6 Promise实例的属性

Promise实例是一个普通对象，继承Promise prototype 中的属性，Promise实例有如表60的初始属性

表60 Promise内置属性