首先要确定Promise的几个特点
- Promise就是一个类，在执行这个类的时候需要传递一个执行器进去，执行器会立即执行
- Promise有三个状态，分别为 成功 fulfilled 失败 rejected 等待pending （pending=>fulfilled pending=>rejected） 一旦状态确定就不可更改
- resolve 和reject函数是用来更改状态的 resolve：fulfilled,reject：rejected
- then方法内部做的事情就是判断状态，如果状态是成功，就调用成功回调，如果是失败就调用失败回调，then方法被定义在原型对象里
- then成功回调有一个返回值，表示调用成功之后的值，失败回调也有一个返回值，表示失败的原因
- 同一个promise下的then可以调用多次的
- then方法是可以被链式调用的，后面then方法的回调函数拿到的值是上一个then方法的回调函数的返回值
以上就是Promise的主要部分，下面我们就根据这些特点来实现我们自己的promise
const PENDING = 'pending';
const FUFILLED = 'fufilled';
const REJECTED = 'rejected';
class MyPromise {
status = PENDING;
value = null;
reason = null;
successCallback = [];
failCallback = [];
constructor(executor) {//初始化的时候传进来的执行器
try {
executor(this.resolve, this.reject);//改变状态的俩函数，一个成功，一个失败
} catch (error) {
this.reject(err);//执行器出错的话，直接调用失败，改变当前promise的状态
}
}
resolve = (value) => {//决议函数
if (this.status !== PENDING) return;//如果状态不是等待，证明已经执行过了，为了符合promise一旦决议不可更改的特性，退出
this.status = FUFILLED;//更改状态
this.value = value;//保存一下决议值
while (this.successCallback.length) this.successCallback.shift()();
//如果执行器中代码是异步，并且绑定then函数时会把成功回调暂存起来，等执行器决议后调用通过then绑定的成功回调
//当前这个promise可能会绑定多个then函数，所以成功回调用数组存放
}
reject = (reason) => {//失败状态函数
if (this.status !== PENDING) return;//同上面的决议函数一样，调用过，退出
this.reason = reason;//暂存失败原因，方便后续使用
this.status = REJECTED;//修改状态
while (this.failCallback.length) this.failCallback.shift()();
//和resolve一样，不过这个是失败的数组，依次拿出来调用
}
then(successCallback, failCallback) {//then函数
successCallback = successCallback ? successCallback : value => value;//成功参数可选，没有的话给个默认参数
failCallback = failCallback ? failCallback : reason => { throw reason };
//失败参数可选，没有的话给个默认手动抛错的函数，方便后续没传入的时候假如报错了，可以链式传递
let promise2 = new MyPromise((resolve, reject) => {//声明promise，返回，符合then总是返回promise的规则
if (this.status === FUFILLED) {//同步代码，成功了
setTimeout(() => {///定时器添加是为了把这个函数修改为异步执行，等待promsie2同步执行完了，声明完毕后执行，这样才能获取到promise2
try {
let x = successCallback(this.value);//获取成功回调返回值
resolvePromise(promise2, x, resolve, reject);
//查看是否返回的是promise并且是否循环返回当前promise，如果是返回的promise展开他，并根据状态执行。如果是普通值，直接resolve
} catch (error) {
reject(error);//执行回调过程出错了，调用reject传递错误
}
}, 0)
} else if (this.status === REJECTED) {//同成功逻辑大体相似，不同是执行回调不一样，传入回调参数不一样
setTimeout(() => {
try {
let x = failCallback(this.reason);
resolvePromise(promise2, x, resolve, reject);
} catch (error) {
reject(error);
}
}, 0)
} else {//上一个promsie执行器返回的不是立即值是一个异步操作
this.successCallback.push(() => {//把这个成功回调暂存起来，等待当前promise resolve之后调用
setTimeout(() => {
try {
let x = successCallback(this.value);
resolvePromise(promise2, x, resolve, reject);
} catch (error) {
reject(error);
}
}, 0)
})
this.failCallback.push(() => {//把这个失败回调暂存起来，等待当前promise resolve之后调用
setTimeout(() => {
try {
let x = failCallback(this.reason);
resolvePromise(promise2, x, resolve, reject);
} catch (error) {
reject(error);
}
}, 0)
})
}
})
return promise2;
}
static all(array) {//promsie中的all方法 等待数组中所有项都完成后，在执行下一步
let result = []; //放完成结果
let index = 0;//用来记录完成了几个
return new MyPromise((resolve, reject) => {
function addData(i, data) {//i是用来记录的下标防止顺序乱了，因为数组里有可能是立即值，有可能是promise，往reslut放的顺序有坑你不一致
//data array数组项的执行结果
result[key] = data;//放入
index++;//标识加一
if (index === result.length) {//相等全部完成了，往下走 resolve
resolve(result);
}
}
for (let i = 0; i < array.length; i++) {
//依次取出数组的项，查看是立即值还是promise，立即值的话直接添加到result数组里，promise的话展开它，成功了就添加到reslut里，失败了直接抛出reject，抛弃其他值
let current = array[i];
if (current instanceof MyPromise) {
current.then((value) => {
addData(i, value)
}, reason => { reject(reason) })
} else {
addData(i, current)
}
}
})
}
static resolve(value) {//遵循promise中resolve规范，如果传入是一个promise直接返回，如果不是用promise包i裹一层变成promise返回。
if (value instanceof MyPromise) return value;
return new MyPromise((resolve) => resolve(value));
}
finally(callBack) {//先调用then返回promise，在它的回调里返回一个promise对象，然后调用callback并把它的返回值传递给promsie resolve方法，最后直接把当前promsie的成功值或失败值往后传递
return this.then(() => {
return MyPromise.resolve(callBack()).then(() => value);
}, reason => {
return MyPromise.resolve(callBack()).then(() => { throw reason });
})
}
catch(failCallback) {//捕获错误方法，给当前返回的promsie通过then注册一个失败的回调，如果当前promise失败了就执行，
//是给返回promise注册的，每个then方法都会返回一个新的promise，如果前面某个链上的then返回的promsie有错误的话，并且没有使用错误回调捕获的话
//我们会通过then默认错误回调，依次抛错，然后链式传递下来，知道被catch这个错误回调捕获
return this.then(undefined, failCallback)
}
done(onFulfilled, onRejected) {
//done代表promsie得结束，可以像then方法那样用，提供fulfilled和rejected状态的回调函数，也可以不提供任何参数。但不管怎样，done都会捕捉到任何可能出现的错误，并向全局抛出。
this.then(onFulfilled, onRejected)
.catch(function (reason) {
// 抛出一个全局错误
setTimeout(() => { throw reason }, 0);
});
}
}
function resolvePromise(promise2, x, resolve, reject) {//对比是否循环返回promsie的函数，判断返回的是promsie还是普通值得函数来进行下一步得调用
if (x === promise2) {
reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
return;
}
if (x instanceof MyPromise) {
x.then(value => resolve(value), reason => reject(reason))
} else {
resolve(x);
}
}
代码里的每一行都会有我的注释，有兴趣得同学可下载下来run一下，看看，自己读一读。
