手写一个Promise

首先要确定Promise的几个特点

1. Promise就是一个类，在执行这个类的时候需要传递一个执行器进去，执行器会立即执行
2. Promise有三个状态，分别为 成功 fulfilled 失败 rejected 等待pending （pending=>fulfilled pending=>rejected） 一旦状态确定就不可更改
3. resolve 和reject函数是用来更改状态的 resolve：fulfilled,reject：rejected
4. then方法内部做的事情就是判断状态，如果状态是成功，就调用成功回调，如果是失败就调用失败回调，then方法被定义在原型对象里
5. then成功回调有一个返回值，表示调用成功之后的值，失败回调也有一个返回值，表示失败的原因
6. 同一个promise下的then可以调用多次的
7. 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一下，看看，自己读一读。