一、Promise-lib/core.js：Promise构造函数
(package.json中约定入口文件为index.js，通过index,js加载lib下的index.js文件，该index.js文件再加载core.js，作为模块输出Promise构造函数)
使用：
var fn=function(resolve,reject){
setTimeout(function(){
resolve();
},3000);
}
new Promise(fn).then(function(){
console.log("callback begin.")
})
功能需求：
延迟执行回调函数、链式调用、出错时执行reject状态回调。
特殊情况处理，包含：外部resolve函数的参数是Promise对象或Promise构造函数、绑定或不绑定当前Promise的then方法，通过bindPromise.then=Promise.then方式；
调用Promise.then时this关键字没有指向Promise实例，比如
var promise=Promise(fn)
function Callback(fn){
var resolve=function(){};
var reject=function(){};
fn(resovle,reject);// onFulfilled,onRejected的返回值作为resolve、reject参数
};
promise.then.call(new Callback,onFulfilled,onRejected);
设计思路：
- 延迟执行的思路仍在于延迟完成后添加回调函数。jquery-deferred模块巧用事件机制，在延迟完成后执行Callbacks对象的fire方法，使以Callbacks.add注册的回调函数队列同时得到执行。promise模块的解决思路是在延迟完成后添加resovle和reject函数，由resovle和reject函数获取回调函数所需的参数this._65，同时改变当前promise的状态this._81，在resovle和reject函数的尾部通过执行fianle函数，顺序执行handle函数、handleResolve函数，在handleResolve函数中，通过Promise.then方法注册的回调函数onFulfilled、onRejected最终得到执行。
- 实现上述过程只差获取Promise.then方法注册的onFulfilled、onRejected回调函数，较为简单的设想是，为当前promise对象新增两个缓存onFulfilled、onRejected，在延迟完成后执行一系列函数时按条件执行这两个缓存函数既可以。然而Promise模块的设计思路是在模块内部构造Handler构造函数，在该构造函数创建的实例中，onFulfilled、onRejected回调函数分别通过this.onFulfilled和this.onRejected得到存储。至于Promise模块为何决定这样处理，参见第5条。
- 链式回调的实现。jquery通过返回当前执行的jquery对象实现链式回调，jquery-deferred模块then、pipe方法通过返回一个最新创建的Deferred对象实现，Promise模块then方法的思路也在于以空函数noop新建一个Promise对象res（以空函数注册的Promise对象需要手动触发resolve、reject函数），并作为返回值res。相应地，返回值中也存在Promise对象所具有的方法。之所以Promise.then不返回当前处理的promise对象实现链式回调，一则需要管束回调函数队列，二则顺序执行的回调队列存在延迟函数时，无法实现该回调队列按理想顺序得到执行。如果返回新的Promise对象res，后续通过then注册的函数可以在回调函数onFulfilled、onRejected执行完成后得到调用，也就实现了链式注册的回调函数按理想顺序得到执行的需要。
- 当Promise.then通过返回新的Promise对象res实现时，这一设计思路类同jquery-deferred模块的实现，然而jquery-deferred模块通过将新创建Deferred对象newDefer的启动函数resolveWith、rejectWith加入原始Deferred模块的Callbacks回调函数队列中，实现后续注册的回调函数得到陆续执行。Promise模块中，通过返回值res注册的回调函数仍需要手动启用resolve、reject函数以执行后续通过then方法注册的回调函数。简单的设想是将resolve、reject函数作为公共函数，以使返回值res的回调函数onFulfilled、onRejected通过this.resolve、this.reject得到执行。然而这样处理的歹处是向外暴露resolve、reject启动回调函数执行的接口，也就陷入jquery-deferred模块通过promise对象避免resolve、reject接口暴露的问题。因此启动函数resolve、reject必须是模块内部的私有方法。介于Promise对象的resolve和reject方法相同，因此可以用原始Promise对象的resolve、reject函数代替返回值res的resolve、reject函数。与此同时，resolve、reject函数构造要求是与Promise对象低耦合，Promise模块的实现是这两个函数的参数为self（当前处理的Promise对象）、newValue（外部函数fn中resolve、reject携带的参数值，或者回调函数onFulfilled、onRejected的返回值），以此使得这两个函数既能处理原始Promise对象，又能处理返回值res。相应地，后续处理函数fianle、handle、handleResolve也必须是私有函数。
- 有了返回值Promise对象res，当前Promise对象需要存储的数据变为3个，一则是首次调用then方法加载的回调函数onFulfilled和onRejected，二则是通过返回值res.then方法加载的回调函数，后续加载的回调函数又可使用resolve(res,value)启动执行，因此缓存数据只需要保有onFulfilled、onRejected以及res即可。Promise模块通过构造Handler对象实现，this.promise指向返回值res，this.onFulfilled、this.onRejected分别指向首次调用then方法加载的回调函数onFulfilled、onRejected。该Handler对象在首次调用then方法时创建，通过handle函数赋值给promise._54，在没有闭包变量可作缓存容器的前提下，只好借用实例的属性保存回调函数onFulfilled、onRejected以及返回值res。设想Handler实例通过handle函数添加到promise._54属性中，并且触发的前提是当前Promise实例的状态是pending，也即promise._81=0，因而就有了一个疑问，为什么不把promise._54属性更新的函数独立出来。在延迟完成以后，执行回调函数的过程中，Promise模块通过finale函数使用处理含有回调函数onFulfilled、onRejected及返回值res的数组promise._54，在顺序交给handle函数、handleResolve函数作处理，最终执行onFulfilled、onRejected，使用resovle、reject函数启动执行res中注册的注册的回调函数。
- Promise模块通过多次使用try-catch方式寻找并捕获错误，当捕获到错误时，即时启用reject函数执行相应的回调函数，当未曾捕获错误时，reject函数的执行有赖于外部函数fn使用过与之对应的reject函数。类比jquery-deferred模块，jquery-deferred模块除then方法处理错误，其他均不处理，按有无设置deferred.reject方法而执行。同时，try-catch方式也是不管执行时间到底有多久，只要一遇到错误就执行catch函数，就其延时处理的功能和Promise模块多少相似，而其实现尚待分析。
- 当外部函数fn中使用的resolve函数的参数是Promise对象或Promise构造函数时，分为两种情况，传参为另一个Promise对象调用当前Promise对象的then方法，如bindPromise.then=Promise.then类似形式，传参为其他Promise对象anoterPromise，且不绑定当前Promise对象的then方法。
- 若传参为当bindPromise对象绑定当前Promse的then方法时，延迟函数fn已进入执行状态，无需重新执行外部函数fn，开启新一轮的延迟，因为后续注册的回调函数都通过与Promise对象无关的resolve、reject函数执行，以及陆续以noop空函数创建的Promise对象无法在使用者书写回调函数时获取，传参为bindPromise对象的意义也在于供函数内部调用作处理，通过bindPromise的resovle、reject函数给回调函数传递参数，而不是产生另一次当前Promise对象的延时。
- 若传参为anotherPromise对象，通过doResovle执行该Promise对象的延时函数anotherFn，延时完成后执行then方法注册的回调函数。因为resovle、reject、finale、handle、handleResolved与Promise对象并无关联，所以当Promise模块发现外部resovle函数传参是anoterPromise对象时，可以通过及时终止内部resovle函数的执行，使then方法注册的回调函数也得不到调用；而当anotherFn执行完毕，又可以重新调用resovle函数触发then方法注册的回调得到执行。
- 调用Promise.then时this关键字没有指向Promise实例，以功能需求中给出的示例为例，实现的是用onFulfilled、onRejected过滤传参，再交给外部回调函数resovle、reject作处理，没有反复链式调用的需求。因此then方法的返回值不是一个Promise对象，而是由构造函数this.constructor创建的实例，这一过程在safeThen函数中实现，与此同时创建该实例的过程里，以空函数noop创建新的Promise对象，并作为参数传入Handler构造函数中，以此实现设置两个回调函数的需求。延迟执行完成后，首先将执行onFulfilled、onRejected回调函数，再由这两个函数的返回值作为参数，执行外部回调函数resolve、reject，这两个函数在this.constructor实例中注册。问题是，这一设计是为了满足何种需求。
具体实现：
- 构造函数Promise(fn)，用于创建Promise对象实例，构造函数内部调用doResolve函数注册fn外部函数中使用的resolve、reject函数。在执行过程中传递resolve、reject函数，外部函数fn在Promise构造函数中也只是注册，具体的执行过程在doResolve函数中实现。作为外部函数的resolve、reject的功能需求是约定回调函数onFulfilled、onRejected的执行事件，其次是向onFulfilled、onRejected传递参数。
- doResolve(fn,promise)函数，执行外部函数fn，注册外部函数resolve、reject，当延迟完成或失败时，外部函数通过Promise模块使用者手动调用执行，同时fn的执行状态done改写为true，调用内部resolve(promise,value)或reject(promise,value)触发回调函数执行。当外部fn函数执行失败，调用内部函数reject触发回调。
- resolve(promise,newValue)成功resolve状态回调函数启动器，newValue通过外部函数获得或者由回调函数返回值构成。区分newValue是另一个Promise对象bindPromise拥有当前Promise对象的then方法，以及另一个Promise对象anotherPromise没有当前Promise对象的then方法，以及仅仅是普通的参数。
- 若为bindPromise情况，实现功能为用bindPromise向回调函数传参。执行过程中，promise._81状态改写为3，即adopted使用另一个Promise的回调，promise._65记录bindPromise，供handle函数改变待处理的Promise对象为bindPromise（回调函数传参的需要），并在handleResolved通过bindPromise的resovle、reject函数给回调函数传递参数，同时回调函数仍通过原始Promise的then方法以及返回值res的then方法设置，均不改变。
- 若为anotherPromise情况，实现功能为执行另一次延时，延时结束后再执行then方法注册的回调函数。执行过程中，再度使用doResolve函数执行anotherPromise的延迟函数anotherFn，并挂载回调函数的启动器内部resolve、reject函数，终止本次resolve函数执行，因此回调函数的触发时机为anotherFn延迟执行完毕、触发执行resolve或reject函数时。
- 若为普通传参。执行过程中，promise._81状态改写为1，即resolved执行成功状态，调用finale函数获取回调函数和返回值res，顺序执行handle、handleResolve函数，最终使当前Promise.then方法和返回值res.then注册的回调函数得到执行。
- reject(promise,newValue)成功reject状态回调函数启动器，newValue通过外部函数获得或者由回调函数执行过程捕获的错误构成。执行过程中，promise._81状态改写为2，即rejected执行成功状态，调用finale函数获取回调函数和返回值res，顺序执行handle、handleResolve函数，最终使当前Promise.then方法和返回值res.then注册的回调函数得到执行。
- finale(promise)通过promise._54获取由then方法注册的回调函数onFulfilled,onRejected、以及then方法返回res构成的handler对象，handler为数组形式，获取元素项逐个调用handle方法执行回调函数。待到回调函数执行完毕，清空promise._54。
- Promise.then(onFulfilled,onRejected)，分为this关键字有否遭改变的两种情况。
- 若this.constructor仍指向Promise构造函数，以空函数noop创建新的Promise对象res，并作为返回值，调用Handler构造函数生成挂载有回调函数onFulfilled,onRejected、以及res的handler对象，调用handle函数将该handler添加到promise._54中，以供延迟执行完毕后使用。
- 若this.constructor不指向Promise构造函数，调用safeThen函数，以空函数noop创建新的Promise对象res，并作为参数传入Handler构造函数中，以此实现设置两个回调函数的需求。延迟执行完成后，首先将执行onFulfilled、onRejected回调函数，再由这两个函数的返回值作为参数，执行外部回调函数resolve、reject，这两个函数在this.constructor实例中注册，this.constructor调用res.then(resolve,reject)以完成延时执行的需要。
- safeThen(this,onFulfilled,onRejected)函数，处理then方法this.constructor不指向Promise构造函数的情况，以空函数noop创建新的Promise对象res，并用res.then方法挂载this.constructor实例中传入的resolve、reject函数，且res作为参数传入Handler构造函数中，以使resolve、reject函数作为延迟执行完成后的回调函数。而原始then方法注册的onFulfilled、onRejected回调函数也作为参数传入Handler构造函数，因此onFulfilled、onRejected回调函数将作为过滤器处理外部函数fn中resolve、reject函数传递的参数，并将返回结果传递给this.constructor实例中的resolve、reject函数。
- 构造函数Handler，存储当前Promise使用then方法注册的回调函数，以及关联的用空函数noop注册的Promise对象res，其或者作为then方法的返回值形成链式回调，或者作为两次回调函数实现的依赖条件。在then方法执行过程中，handler对象存储在promise._54中；在回调函数启动过程中，该handler对象从promise._54取出，以实现多次执行回调。
- handle(promise,handler)函数，当then方法挂载回调函数执行该函数时，将构造函数Handler创建的handler添加到promise._54中，以供延迟执行完毕、回调函数启用过程中使用。当延时执行完毕，由finale函数调用该函数时，判断promise._81是否为adopted状态，需要以另一个Promise对象bindPromise的参数执行回调函数，将参数promise赋值为bindPromise，以供后续使用；顺序执行handleResolved函数，目的是执行回调函数onFulfilled,onRejected，以及其他链式注册的回调函数。
- handleResolved(promise,handler)函数，通过handler获取回调函数onFulfilled,onRejected，以promise._65执行之，返回值作为参数执行res.then注册的回调函数。
图解：
源码：
'use strict';
var asap=require('asap/raw');
function noop(){}// 空函数
var LAST_ERROR=null;
var IS_ERROR={};
function getThen(obj){
try{
return obj.then;
}catch(ex){
LAST_ERROR=ex;
return IS_ERROR;
}
}
function tryCallOne(fn,a){
try{
return fn(a);
}catch (ex){
LAST_ERROR=ex;
return IS_ERROR;
}
}
function tryCallTwo(fn,a,b){
try{
fn(a,b);
}catch(ex){
LAST_ERROR=ex;
return IS_ERROR;
}
}
module.exports=Promise;
// 传入函数，构建Promise对象(延时执行的回调承诺)
function Promise(fn){
if ( typeof this!=='object' ){
throw new TypeError('Promises must be constructed via new');
}
if ( typeof fn!=='function' ){
throw new TypeError('not a function');
}
// 初次创建的时候this._45为0，this._54为空，以赋值更新，
// 调用一次then方法时this._45为1，this._54数组有一个元素，以push方法更新
this._45=0;
// 存储状态，0-pending，1-resovled，2-rejected，3-adopted外部函数fn中resovle函数获得参数为另一个Promise对象
this._81=0;
// 存储resovle、reject函数传递的参数，供回调函数onFulfilled,onRejected使用
this._65=null;
// 保存相关的Handler对象，存储有onFulfilled,onRejected回调函数，及then方法的返回值res
this._54=null;
if ( fn===noop ) return;// 引用地址相同
// 将resovle、reject函数提供给模块外部函数fn
doResolve(fn,this);
}
Promise._10=null;
Promise._97=null;
Promise._61=noop;
// then方法注册回调函数onFulfilled,onRejected
Promise.prototype.then=function(onFulfilled,onRejected){
if ( this.constructor!==Promise ){
return safeThen(this, onFulfilled, onRejected);
}
// 以noop空函数创建新的Promise对象，作为返回值获取后续注册的回调函数，供链式调用
// 以noop创建Promise对象时，doResolve函数将不予执行
var res=new Promise(noop);
handle(this,new Handler(onFulfilled,onRejected,res));
return res;
};
// promise(fn).then.call(Constructor,onFulfilled,onRejected)
// onFulfilled, onRejected回调执行完成后，在执行回调函数resolve,reject
function safeThen(self, onFulfilled, onRejected){
return new self.constructor(function (resolve,reject){
var res=new Promise(noop);
res.then(resolve, reject);
handle(self,new Handler(onFulfilled, onRejected, res));
});
};
// deferred为Handler对象，存储有onFulfilled,onRejected回调函数
function handle(self,deferred){
// 外部函数fn中resovle参数为promise，self改为该promise，以该promise向回调函数传参
while ( self._81===3 ){
self=self._65;
}
if ( Promise._10 ){// ？？？
Promise._10(self);
}
// then方法初次调用时，promise._54添加相关Handler对象
if ( self._81===0 ){
// then方法的返回值是新的promise对象，
if ( self._45===0 ){
self._45=1;
self._54=deferred;
return;
}
if ( self._45===1 ){// 什么时候发生？？？
self._45=2;
self._54=[self._54,deferred];
return;
}
self._54.push(deferred);
return;
}
// 执行onFulfilled、onRejected回调
handleResolved(self,deferred);
}
// deferred为Handler对象，存储有onFulfilled,onRejected回调函数
// deferred.promise为then方法中创建的Promise对象res，同时res作为返回值，拉取后续注册的回调函数
function handleResolved(self,deferred){
asap(function(){
var cb=self._81===1 ? deferred.onFulfilled : deferred.onRejected;
if ( cb===null ){
if ( self._81===1 ){
resolve(deferred.promise,self._65);
}else{
reject(deferred.promise,self._65);
}
return;
}
var ret=tryCallOne(cb,self._65);// 执行回调
if ( ret===IS_ERROR ){
reject(deferred.promise,LAST_ERROR);
}else{
resolve(deferred.promise,ret);
}
});
}
// resovled状态回调函数的启动器
function resolve(self,newValue){
// 外部函数fn所用参数不能为当前promise对象本身，实际上似乎也没有这个可能
if ( newValue===self ){
return reject( self,new TypeError('A promise cannot be resolved with itself.') );
}
// 外部函数fn中调用resovle携带的参数值newValue本身是一个promise对象或函数
if ( newValue && (typeof newValue==='object' || typeof newValue==='function') ){
var then=getThen(newValue);
// newValue不是合格的promise对象，调用reject方法执行失败的回调函数
if ( then===IS_ERROR ){
return reject(self,LAST_ERROR);
}
// newValue是promise对象
// 传参为bindPromise，且bindPromise.then=Promise.then，fn延时已执行，使用bindPromise的回调
if ( then===self.then && newValue instanceof Promise ){
self._81=3;// 执行状态为adopted
self._65=newValue;
finale(self);
return;
// 传参为anotherPromise，重新注册执行anotherPromise的延迟函数，完成后调用链式注册的回调
}else if( typeof then==='function' ){
doResolve(then.bind(newValue),self);
return;
}
}
self._81=1;// 执行状态为resovled
self._65=newValue;// 缓存外部函数fn中调用resovle携带的参数值
finale(self);
}
// rejected状态回调函数的启动器
function reject(self,newValue){
self._81=2;// 执行状态为rejected
self._65=newValue;// 缓存外部函数fn中调用resovle携带的参数值
if ( Promise._97 ){
Promise._97(self,newValue);
}
finale(self);
}
// 中间件，桥接resovle|reject-handle函数，根据当前promise对象相关Handler对象的数目执行handle函数
function finale(self){
if ( self._45===1 ){
handle(self,self._54);
self._54=null;
}
if ( self._45===2 ){
for ( var i=0; i
二、lib/done.js：Promise.prototype.done方法
Promise.prototype.done方法实现，调用then方法添加onFulfilled,onRejected，假使遭遇reject状态，添加抛出错误的回调函数。
'use strict';
var Promise=require('./core.js');
module.exports=Promise;
Promise.prototype.done=function (onFulfilled,onRejected){
var self=arguments.length ? this.then.apply(this,arguments) : this;
self.then(null, function (err){
setTimeout(function (){
throw err;
}, 0);
});
};
三、lib/es6-extensions.js：ES6-Promise模块实现
ES6-Promise模块功能需求及实现
- Promise.resolve(value)方法，返回作为参数value的Promise对象、或者以空函数noop创建新的Promise对象、或者将thenable对象转化为Promise对象(thenable对象的then方法立即执行)，目的是为链式调用then方法注册的回调函数设置参数。
- Promise.reject(value)方法，设置rejected状态的回调函数，并触发执行rejected状态的回调函数。回调将立即执行，因此reject方法的意义是个问题。
- Promise.prototype["catch"](onRejected)，当前Promise用then方法加载onRejected回调函数，并返回以noop创建的新Promise对象。该方法在原型中，其他均在构造函数中，构成静态方法。
- Promise.all方法，多个Promise对象或thenable对象(含有then方法的对象)同时启动，最后一个延时执行完成后，执行链式调用then方法注册的回调函数。实现功能同$.when().done()相似，实现原理也类同，通过创建新的Promise对象实现链式调用，通过闭包变量remaining判断各延时函数是否执行完毕。
- Promise.then方法，多个Promise对象或thenable对象(含有then方法的对象)同时启动，第一个延时执行完成后，就立即执行链式调用then方法注册的回调函数。问题是，其他延时对象执行完成后，还是会调用回调函数，依赖于使用者对源码的理解。
源码：
'use strict';
// 浏览器端实现
//This file contains the ES6 extensions to the core Promises/A+ API
var Promise=require('./core.js');
module.exports=Promise;
/* Static Functions */
var TRUE=valuePromise(true);
var FALSE=valuePromise(false);
var NULL=valuePromise(null);
var UNDEFINED=valuePromise(undefined);
var ZERO=valuePromise(0);
var EMPTYSTRING=valuePromise('');
// 以空函数noop创建Promise对象res，设置回调函数的参数
// 其他函数中调用该函数构成链式调用then方法的需要，主要目的是设置回调的参数
function valuePromise(value) {
var p=new Promise(Promise._61);// 以空函数noop创建Promise对象
p._81=1;// promise状态，pending、resolved、rejected、adopted
p._65=value;// 回调函数参数
return p;
}
// 返回新创建的Promise对象，以供链式调用then方法注册回调，并设置回调的参数
Promise.resolve=function(value){
if (value instanceof Promise) return value;
if (value===null) return NULL;
if (value===undefined) return UNDEFINED;
if (value===true) return TRUE;
if (value===false) return FALSE;
if (value===0) return ZERO;
if (value==='') return EMPTYSTRING;
// 将带有then方法的thenable对象转化为Promise对象，立即执行thenable对象的then方法
if ( typeof value==='object' || typeof value==='function' ){
try{
var then=value.then;
if ( typeof then==='function' ){
return new Promise(then.bind(value));
}
}catch(ex){
return new Promise(function (resolve,reject){
reject(ex);
});
}
}
return valuePromise(value);
};
// 多个延时对象Promise或thenable合并为一个Promise，几个延时对象同时启动，最后一个执行完成后执行回调
// 实现功能和$.when().then()相仿
Promise.all=function (arr){
var args=Array.prototype.slice.call(arr);
return new Promise(function (resolve,reject){
if ( args.length===0 ) return resolve([]);
var remaining=args.length;
function res(i,val){
if (val && (typeof val==='object' || typeof val==='function') ){
if ( val instanceof Promise && val.then===Promise.prototype.then ){
while ( val._81===3 ){
val=val._65;
}
if ( val._81===1 ) return res(i,val._65);
if ( val._81===2 ) reject(val._65);
val.then(function (val){
res(i,val);// val不是Promise对象或thenable对象时，将参数转交给args
},reject);
return;
}else{
// thenable对象时，直接执行thenable的then方法
var then=val.then;
if ( typeof then==='function' ){
var p=new Promise(then.bind(val));
p.then(function (val) {
res(i, val);
}, reject);
return;
}
}
}
args[i]=val;
if ( --remaining===0 ){// 延迟函数都执行完毕后，执行新建Promise对象的回调，传参由各延时构成
resolve(args);
}
}
for (var i=0; i
四、lib/finally.js-Promise.prototype.finally方法实现
Promise.prototype.finally(f)方法实现，若f函数返回值为Promise对象，延时完成后，回调函数的参数取原始Promise对象提供的参数；f返回值为其他，通过Promise.resolve方法构建Promise对象。因此finally方法执行延时，保持原有参数，实现的功能需要通过finally方法返回值Promise对象调用then方法注册回调函数，在回调函数中起作用，具体意义还是个问题。
'use strict';
var Promise=require('./core.js');
module.exports=Promise;
// f函数返回值为Promise对象时，延时完成后，将原始Promise对象的参数传递给后续注册的回调函数
Promise.prototype['finally']=function (f){
return this.then(function (value){
return Promise.resolve(f()).then(function (){
return value;
});
}, function (err){
return Promise.resolve(f()).then(function (){
throw err;
});
});
};
五、lib/synchronous.js：获取延迟状态、获取回调参数方法
- Promise.enableSynchronous方法，执行后，使获取延迟状态、获取回调参数各方法可用。
- Promise.disableSynchronous方法，执行后，将获取延迟状态、获取回调参数各方法设为undefined。
- Promise.prototype.getState方法，获取执行状态0-pending、1-resolved、2-rejected，当遇到3-adopted状态时，获取关联Promise对象bindPromise的状态。
- Promise.prototype.isPending方法是否执行中状态。
- Promise.prototype.isFulfilled方法是否执行成功状态。
- Promise.prototype.isRejected方法是否执行失败状态。
- Promise.prototype.getValue方法获取resolved状态传参value。
- Promise.prototype.getReason方法获取rejected状态传参reason。
'use strict';
var Promise=require('./core.js');
module.exports=Promise;
// 静态方法enableSynchronous使获取状态、获取传参方法可用
Promise.enableSynchronous=function (){
Promise.prototype.isPending=function(){
return this.getState()==0;
};
Promise.prototype.isFulfilled=function(){
return this.getState()==1;
};
Promise.prototype.isRejected=function(){
return this.getState()==2;
};
// 获取resolved状态传参value
Promise.prototype.getValue=function (){
if ( this._81===3 ){
return this._65.getValue();
}
if ( !this.isFulfilled() ){
throw new Error('Cannot get a value of an unfulfilled promise.');
}
return this._65;
};
// 获取rejected状态传参reason
Promise.prototype.getReason=function (){
if ( this._81===3 ){
return this._65.getReason();
}
if ( !this.isRejected() ){
throw new Error('Cannot get a rejection reason of a non-rejected promise.');
}
return this._65;
};
// 获取状态
Promise.prototype.getState=function (){
if ( this._81===3 ){
return this._65.getState();
}
if ( this._81===-1 || this._81===-2 ){
return 0;
}
return this._81;
};
};
// 静态方法disableSynchronous使获取状态、获取传参方法不可用
Promise.disableSynchronous=function(){
Promise.prototype.isPending=undefined;
Promise.prototype.isFulfilled=undefined;
Promise.prototype.isRejected=undefined;
Promise.prototype.getValue=undefined;
Promise.prototype.getReason=undefined;
Promise.prototype.getState=undefined;
};
六、lib/node-extensions.js 暂缺