手写promise

先上代码 基本能用啦 目前完成了then catch all rece, 还需要完善promise状态不可改以及rece()时没有中断后续的执行,promise穿透等.

class Mypromise {
    constructor(callback) {
        this.status = 'pending';
        this.results = undefined;
        this.thenCallback = [];
        this.catchCallback = [];
        callback(this._resolve, this._reject)
    }
    _resolve = (res) => {
        this.status = 'fulfilled';
        this.results = res
        this.thenCallback.forEach(({ success, p }) => {
            this._handlerPromise(success, p)
        })
    }
    _reject = (err) => {
        this.status = 'rejected'
        this.results = err
        this.catchCallback.forEach(({ fail, p }) => {
            this._handlerPromise(fail, p)
        })

    }
    _handlerPromise(callback, p) {
        const result = callback(this.results)
        if (result instanceof Mypromise) {
            const status = result.status
            switch (status) {
                case 'pending':
                    result.then(innerRes => {
                        p._resolve(innerRes)
                    }, innerErr => {
                        p._reject(innerErr)
                    })
                    break;
                case 'fulfilled':
                    p._resolve(result.results)
                    break;
                case 'rejected':
                    p._reject(result.results)
                    break;
                default:
                    break;
            }

        } else {
            p._resolve(result)
        }
    }
    then(success, fail) {
        const p = new Mypromise((resolve, reject) => {

        })
        if (typeof success === 'function') {
            this.thenCallback.push({ success, p })
        }
        if (typeof fail === 'function') {
            this.catchCallback.push({ fail, p })
        }
        return p
    }
    catch(fail) {
        const p = new Mypromise((resolve, reject) => {
        })

        this.catchCallback.push({ fail, p })
        return p
    }
    static resolve(res) {
        return new Mypromise((resolve, reject) => {
            resolve(res)
        })
    }
    static reject(err) {
        return new Mypromise((resolve, reject) => {
            reject(err)
        })
    }
    // 等待所有都完成（或第一个失败)
    static all(promiseArray) {
        const pAll = new Mypromise((resolve, reject) => {

        });
        const resStore = [];
        let currentIndex = 0, promise = null, len = promiseArray.length;
        while (promise = promiseArray.shift()) {
            promise.then(res => {
                resStore[currentIndex] = res
                ++currentIndex
                if (currentIndex === len) {
                    pAll._resolve(resStore)
                }
            }, err => {
                pAll._reject(err)
            })
        }
        return pAll
    }
    // Promise.race 当一个promise状态确定的时候,Promise.race与其相同的状态,
    // 参数是一个数组,返回值是一个promise
    static rece(promiseArray) {
        const pAll = new Mypromise((resolve, reject) => {

        });
        let promise = null
        while (promise = promiseArray.shift()) {
            promise.then(res => {
                pAll._resolve(res)
            }, err => {
                pAll._reject(err)
            })
        }
        return pAll
    }
}

手写promise的核心还是在于js单线程和任务队列的机制

JavaScript是单线程语言，在一个进程上，只能运行一个线程，而不能多个线程同时运行。也就是说JavaScript不允许多个线程共享内存空间。因此，如果有多个线程想同时运行，则需采取排队的方式，即只有当前一个任务执行完毕，后一个任务才开始执行。

单线程就是一次只做一件事,而任务队列则是指将回调函数存放在一个数组中,当promise状态确定后我们在依次的执行这些回调
比如你可能经常会看到这样的代码

const p1 = new promise((resolve, reject) => {
    setTimeout(() => {
        resolve('success')
    }, 1000)
})

const p2 = p1.then((res) => {
    console.log(res)
})
// success;

在这过程中new promise是同步的 p1.then也是同步的,并且他们都返回了一个全新的promise。p1.then在返回promise的同时还将回调函数存放在了p1的任务队列thenCallback中，当钩子函数resolve触发便会依次的执行队列中的函数
.then越多那么任务队列里的函数就越多,所有的函数一开始就分配好了要在哪里执行,而不是等回调函数的结果出来以后才确定的.
这就是一切早已注定好了吧