promise原理实现

promise:用于解决回调地狱的问题。

原理的实现：

class myPromise {
            constructor(executor) {
                this.resolve = this.resolve.bind(this)
                this.reject = this.reject.bind(this)
                this.status = 'pending'
                this.value = null
                this.resolvedTasks = []
                this.rejectedTasks = []
                try {
                    executor(this.resolve, this.reject)
                } catch (e) {
                    this.reject(e)
                }
            }
            resolve(value) {
                setTimeout(() => {
                    this.status = 'fulfilled'
                    this.value = value
                    this.resolvedTasks.forEach(v => v(value))
                })


            }
            reject(reason) {
                setTimeout(() => {
                    this.status = 'rejected'
                    this.value = reason
                    this.rejectedTasks.forEach(v => v(reason))
                });
            }
            then(onFulfilled, onRejected) {
                return new myPromise((resolve, reject) => {
                    this.resolvedTasks.push((value) => {
                        try {
                            const res = onFulfilled(value)
                            if (res instanceof myPromise) {
                                res.then(resolve, reject)
                            } else {
                                resolve(res)
                            }
                        } catch (error) {
                            reject(error)
                        }
                    })
                    this.rejectedTasks.push((value) => {
                        try {
                            const res = onRejected(value)
                            if (res instanceof myPromise) {
                                res.then(resolve, reject)
                            } else {
                                resolve(res)
                            }
                        } catch (error) {
                            reject(error)
                        }
                    })
                })
            }
            catch(onRejected) {
                return this.then(null, onRejected)
            }
        }

promise.race实现（那个执行快就执行那个）

Promise.myRace = promiseArr =>{
　　return new Promise((res,rej) =>{
　　　　promiseArr.forEach( arr =>{
　　　　　　arr.then(res,rej)
　　　　})
　　})
}

promise.all实现(当全部执行成功才执行)

Promise.all = promiseArr =>{
  return new Promise((resolve,reject)=>{
     let result = []
     let index = 0
     for(let i = 0; i < promiseArr.length;i++){
           promiseArr[i].then(res=>{
              result[i] = res
              index++
              if(index === promiseArr.length){
                       resolve(result)
                }
            }).catch(err){
               reject(err)
            }
        }
    })     
}