MDN文檔

    const PENDING = 'pending'//初始化
    const RESOLVED = 'resolved'//完成
    const REJECTED = 'rejected'//失敗
/*一個 Promise有以下幾種狀態(tài):
pending: 初始狀態(tài)嫡秕，既不是成功厢洞，也不是失敗狀態(tài)爱只。
fulfilled: 意味著操作成功完成邓梅。
rejected: 意味著操作失敗。*/
function Promise(excutor) {
/*executor是一個帶有resolve冲杀，
reject兩個參數(shù)的函數(shù)公罕，
Promise構(gòu)造函數(shù)執(zhí)行
時立即調(diào)用executor 函數(shù)*/
    const self = this
    self.status = PENDING
    self.data = undefined
    self.callbacks = []
    function resolve(value) {
        if(self.status!==PENDING) {
            return
        }
        self.status = RESOLVED
        self.data = value
        if(self.callbacks.length>0){
           setTimeout(()=>{
               self.callbacks.forEach(item=>{
                   item.onResolved(value)
               })
           })

        }
    }
    function reject(reason){
        if(self.status!==PENDING) {
            return
        }
        self.status = REJECTED
        self.data = reason
        if(self.callbacks.length>0){
            setTimeout(()=>{
                self.callbacks.forEach(item=>{
                    item.onRejected(reason)
                })
            })
        }
    }
    try{
        excutor(resolve,reject)
    }catch (err) {
        reject(err)
    }
}
Promise.prototype.then = function(onResolved,onRejected){
    onResolved = typeof onResolved === 'function'?onResolved:value => value
    onRejected = typeof onRejected === 'function'?onRejected:reason => {throw reason}
/*判斷傳過來的是否是function棺聊，如果不是那就說明有結(jié)果了*/
    const self = this
    return new Promise((resolve,reject)=>{
        function handle(callback) {
            try{
/*執(zhí)行失敗或成功的回調(diào)，
獲取值如果是promise對象那么繼續(xù)執(zhí)行then方法淹接，
如果有結(jié)果則resolve結(jié)果修改data十性，返回resolved狀態(tài)的promise，拋出錯誤
那么 then 返回的 Promise 也會成為rejected的promise*/
                const  result = callback(self.data)
                if(result instanceof Promise){
                    result.then(resolve, reject)
                }else{
                    resolve(result)
                }

            }catch (err) {
                reject(err)
            }
        }

        if(self.status===PENDING){
            self.callbacks.push({
                onResolved(){
                    handle(onResolved)

                },
                onRejected(){
                    handle(onRejected)
                }
            })
        }else if(self.status===RESOLVED){
            setTimeout(()=>{
                handle(onResolved)
            })
        }else{
            setTimeout(()=>{
               handle(onRejected)
            })
        }
})
}
Promise.prototype.catch = function(onRejected){
      return this.then(undefined,onRejected)
}
Promise.resolve = function (value) {
/*
返回一個狀態(tài)由給定value決定的Promise對象塑悼。
如果該值是thenable(即劲适，帶有then方法的對象)，
返回的Promise對象的最終狀態(tài)由then方法執(zhí)行決定拢肆；
否則的話(該value為空减响，基本類型或者不帶then方法的對象),
返回的Promise對象狀態(tài)為fulfilled，并且將該value傳遞給對應(yīng)的then方法郭怪。
*/
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise){
            value.then(resolve,reject)
        }else{
            resolve(value)
        }

    })
}
Promise.reject = function (reason) {
/*返回一個狀態(tài)為失敗的Promise對象支示，并將給定的失敗信息傳遞給對應(yīng)的處理方法*/
    return new Promise((resolve,reject)=>{
        reject(reason)
    })
}
Promise.all = function (promises) {
/*傳一個promise數(shù)組
返回一個promise讀對象，如果成功傳進(jìn)來的promises數(shù)組的執(zhí)行結(jié)果按傳進(jìn)
來的順序放在數(shù)組里鄙才，如果失敗就傳第一個失敗的原因
*/
    return new Promise((resolve,reject)=>{
        let flags = new Array(promises.length)
        let count = 0
        promises.forEach(
            (item,index)=>{
                item.then(
                    value => {
                        flags[index] = value
                        count++
                        if(count===promises.length){
                            resolve(flags)
                        }
                    },
                    reason => {
                        reject(reason)
                    }
                )
            }
        )
    })
}
Promise.race = function (promises) {
    return new Promise((resolve,reject)=>{
/*
將第一個promise的結(jié)果進(jìn)行返回
*/
        promises.forEach(
            (item,index)=>{
                item.then(
                    value => {
                      resolve(value)
                    },
                    reason => {
                        reject(reason)
                    }
                )
            }
        )
    })
}