根据上篇,再通过class语法糖的形式封装promise。
class Promise {
//构造方法
constructor(excutor) {
//4.为实例对象添加属性
this.PromiseState = 'pending'
this.PromiseResult = null;
//8.2 为了执行器函数中的同步改为异步,需要将then中的两个回调存储在一个对象里
//9 将callback改为数组类型,以解决多个回调的情况
this.callback = [];
//5.保存实例对象this的值
let self = this;
// 3、excutor有两个函数参数,分别是resolve(),reject()
function resolve(data) {
//6. promise的状态只能更改一次,所以对当前状态先做判断
if (self.PromiseState !== 'pending') return;
//5.1修改对象的状态和值
self.PromiseState = 'resolved';
self.PromiseResult = data;
// 8.3 调用成功的回调函数
// if (self.callback.onResolved) {
// // self.callback.onResolved(data)
// }
//9 以解决多个回调的情况
setTimeout(() => {
self.callback.forEach(item => {
item.onResolved(data)
})
})
}
function reject(data) {
// 6.promise的状态只能更改一次,所以对当前状态先做判断
if (self.PromiseState !== 'pending') return;
//5.1修改对象的状态和值
self.PromiseState = 'rejected';
self.PromiseResult = data;
// 8.3 调用失败的回调函数
// if (self.callback.onRejected) {
// // self.callback.onRejected(data)
// }
//9 以解决多个回调的情况
setTimeout(() => {
self.callback.forEach(item => {
item.onRejected(data)
})
})
}
// 5,处理throw抛的出异常
try {
// 2、同步调用形参执行器函数
excutor(resolve, reject);
} catch (e) {
reject(e)
}
}
// then 方法
then(onResolved, onRejected) {
//7.如何对then进行回调
//7.因为resolve状态对应then方法中第一个回调函数;
//reject状态对应then方法中第二个回调函数;
//所以,在调用onResolved和onRejected之前,要先对当前实例对象p的状态做判断
const self = this;
//12 catch方法异常穿透
if (typeof onRejected !== 'function') {
onRejected = reason => {
throw reason;
}
}
//13 catch方法值传递
if (typeof onResolved !== 'function') {
onResolved = value => value
}
return new Promise((resolve, reject) => {
//封装函数,减少重复代码
function callbacks(type) {
try {
let result = type(self.PromiseResult);
//判断
if (result instanceof Promise) {
result.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
resolve(result);
}
} catch (e) {
reject(e);
}
};
if (this.PromiseState === 'resolved') {
setTimeout(() => {
callbacks(onResolved);
})
}
if (this.PromiseState === 'rejected') {
// 获取回调函数的执行结果
setTimeout(() => {
callbacks(onRejected);
})
}
//8.1 为了执行器函数中的同步改为异步,
//判断pending状态,保存回调函数
//在得到状态改变的通知后,then方法需要判断究竟调用成功或失败的回调函数
// 将两个函数存放在一个对象中,一一对应构造函数里的相对应的函数
if (this.PromiseState === 'pending') {
//9 以解决多个回调的情况
this.callback.push({
//11异步任务then返回的结果
onResolved: function() {
callbacks(onResolved);
},
//11异步任务then返回的结果
onRejected: function() {
callbacks(onRejected);
}
})
}
})
}
// catch 方法
catch (onRejected) {
return this.then(undefined, onRejected);
}
// static静态成员,不属于实例对象,属于类(构造函数)
// resolve方法
static resolve(value) {
return new Promise((resolve, reject) => {
if (value instanceof Promise) {
value.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
resolve(value)
}
})
}
// resject方法
static reject(reason) {
return new Promise((resolve, reject) => {
reject(reason)
})
}
// all方法
static all(promises) {
return new Promise((resolve, reject) => {
let count = 0;
let arr = [];
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
//想要对象的状态为成功
//则每个promise对象都应成功
count++;
//将当前promise对象成功的结果存入到数组中
arr[i] = v;
//判断
if (count === promises.length) {
//修改状态
resolve(arr)
}
}, r => {
reject(r);
})
}
})
}
// race方法
static race(promises) {
return new Promise((resolve, reject) => {
for (let i = 0; i < promises.length; i++) {
//数组中的promise,谁先改变状态,那么谁先调then方法,
//最终返回的promise对象的结果也是第一个改变状态的promise的结果
promises[i].then(v => {
resolve(v)
}, r => {
reject(r)
})
}
})
};
}