// 判断变量否为function
|
function isFunction(variable) {
|
return typeof variable === 'function';
|
}
|
|
// 定义promise状态常量
|
var PENDING = 'PENDING',
|
FULFILLED = 'FULFILLED',
|
REJECTED = 'REJECTED'
|
|
/**
|
*定义_Promise构造函数
|
*
|
* @param {*} handle 注册回调方法
|
*/
|
function _Promise(handle) {
|
if (!isFunction(handle)) {
|
throw Error("_Promise构造函数接收函数作为参数");
|
}
|
this._status = PENDING
|
this._value = undefined
|
this._fulfilledQueues = []
|
this._rejectedQueues = []
|
try {
|
handle(this._resolve.bind(this), this._reject.bind(this))
|
} catch (err) {
|
this._reject(err)
|
}
|
}
|
|
// 重写_Promise原型对象
|
_Promise.prototype = {
|
constructor: _Promise,
|
_resolve: function (val) {
|
var _this = this
|
function run() {
|
if (_this._status != PENDING) return;
|
_this._status = FULFILLED
|
function runFulfilled(value) {
|
var cb;
|
while (cb = _this._fulfilledQueues.shift()) {
|
cb(value)
|
}
|
}
|
function runRejected(error) {
|
var cb;
|
while (cb = _this._rejectedQueues.shift()) {
|
cb(error)
|
}
|
}
|
if (val instanceof _Promise) {
|
val.then(function (value) {
|
_this._value = value
|
runFulfilled(value)
|
}.bind(_this), function (err) {
|
_this._value = err
|
runRejected(err)
|
}.bind(_this))
|
} else {
|
_this._value = val
|
runFulfilled(val)
|
}
|
}
|
setTimeout(run, 0)
|
},
|
_reject: function (err) {
|
var _this = this
|
if (this._status !== PENDING) return
|
function run() {
|
_this._status = REJECTED
|
_this._value = err
|
var cb;
|
while (cb = _this._rejectedQueues.shift()) {
|
cb(err)
|
}
|
}
|
setTimeout(run, 0)
|
},
|
|
/**
|
*then方法
|
*
|
* @param {*} onFulfilled 异步成功的回调
|
* @param {*} onRejected 异步失败回调
|
* @returns 返回新的_Promise实例，支持链式调用
|
*/
|
then: function (onFulfilled, onRejected) {
|
var _value = this._value
|
var _status = this._status
|
var _this = this
|
return new _Promise(function (onFulfilledNext, onRejectedNext) {
|
function fulfilled(value) {
|
try {
|
if (!isFunction(onFulfilled)) {
|
onFulfilledNext(value)
|
} else {
|
var res = onFulfilled(value);
|
if (res instanceof _Promise) {
|
res.then(onFulfilledNext, onRejectedNext)
|
} else {
|
onFulfilledNext(res)
|
}
|
}
|
} catch (err) {
|
onRejectedNext(err)
|
}
|
}
|
var rejected = error => {
|
try {
|
if (!isFunction(onRejected)) {
|
onRejectedNext(error)
|
} else {
|
var res = onRejected(error);
|
if (res instanceof _Promise) {
|
res.then(onFulfilledNext, onRejectedNext)
|
} else {
|
onFulfilledNext(res)
|
}
|
}
|
} catch (err) {
|
onRejectedNext(err)
|
}
|
}
|
|
switch (_status) {
|
case PENDING:
|
_this._fulfilledQueues.push(fulfilled)
|
_this._rejectedQueues.push(rejected)
|
break
|
case FULFILLED:
|
fulfilled(_value)
|
break
|
case REJECTED:
|
rejected(_value)
|
break
|
}
|
})
|
},
|
|
/**
|
*catch方法
|
*
|
* @param {*} onRejected 失败时回调方法
|
* @returns 返回新的_Promise实例
|
*/
|
catch: function (onRejected) {
|
return this.then(undefined, onRejected)
|
}
|
}
|
|
// _Promise构造函数的部分静态方法
|
_Promise.resolve = function (value) {
|
if (value instanceof _Promise) return value
|
return new _Promise(function (resolve) {
|
return resolve(value)
|
})
|
}
|
_Promise.reject = function (value) {
|
return new _Promise(function (resolve, reject) {
|
return resolve(value)
|
})
|
}
|
|
/**
|
*并发多个异步事件
|
*
|
* @param {*} list 由_promise对象组成的数组集合
|
* @returns 返回新的_promise实例 支持链式调用
|
*/
|
_Promise.all = function (list) {
|
var _this = this
|
return new _Promise(function (resolve, reject) {
|
var values = []
|
var count = 0
|
list.forEach(function (e, i) {
|
_this.resolve(e).then(function (res) {
|
values[i] = res
|
count++
|
if (count === list.length) resolve(values);
|
}, function (err) {
|
reject(err)
|
})
|
})
|
})
|
}
|
|
/**
|
*不管成功或失败都执行的finally方法
|
*
|
* @param {*} cb 回调事件
|
* @returns 新的promise实例
|
*/
|
_Promise.finally = function (cb) {
|
return this.then(function (value) {
|
return _Promise.resolve(cb()).then(function () { return value; })
|
}, function (reason) {
|
return _Promise.resolve(cb()).then(function () { throw reason; })
|
})
|
}
|
