一、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<self._54.length; i++ ){
handle(self,self._54[i]);
}
self._54=null;
}
}
// 存储回调函数onFulfilled,onRejected和管理器promise
function Handler(onFulfilled,onRejected,promise){
this.onFulfilled=typeof onFulfilled==='function' ? onFulfilled : null;
this.onRejected=typeof onRejected==='function' ? onRejected : null;
this.promise=promise;
}
// 将resovle、reject函数传给模块外部函数fn
function doResolve(fn,promise){
var done=false;// 是否执行完毕
var res=tryCallTwo(fn,function(value){
if (done) return;
done=true;
resolve(promise,value);
},function (reason){
if (done) return;
done=true;
reject(promise,reason);
})
// fn执行报错,调用reject回调函数
if ( !done && res===IS_ERROR ){
done=true;
reject(promise,LAST_ERROR);
}
}二、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<args.length; i++){
res(i,args[i]);
}
});
};
// 设置rejected状态回调函数的参数,并触发rejected状态回调函数
Promise.reject=function (value){
return new Promise(function (resolve,reject){
reject(value);
});
};
// 同时执行的延时对象,当第一个延时执行完成,即执行回调函数,没有解决其他延时执行后调用回调的问题
Promise.race=function (values){
return new Promise(function (resolve,reject){
values.forEach(function(value){
Promise.resolve(value).then(resolve,reject);
});
});
};
// 报错时执行onRejected回调
Promise.prototype['catch']=function (onRejected){
return this.then(null, onRejected);
};四、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 暂缺