MDN文档

    const PENDING = 'pending'//初始化
    const RESOLVED = 'resolved'//完成
    const REJECTED = 'rejected'//失败
/*一个 Promise有以下几种状态:
pending: 初始状态，既不是成功，也不是失败状态。
fulfilled: 意味着操作成功完成。
rejected: 意味着操作失败。*/
function Promise(excutor) {
/*executor是一个带有resolve，
reject两个参数的函数，
Promise构造函数执行
时立即调用executor 函数*/
    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，如果不是那就说明有结果了*/
    const self = this
    return new Promise((resolve,reject)=>{
        function handle(callback) {
            try{
/*执行失败或成功的回调，
获取值如果是promise对象那么继续执行then方法，
如果有结果则resolve结果修改data，返回resolved状态的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) {
/*
返回一个状态由给定value决定的Promise对象。
如果该值是thenable(即，带有then方法的对象)，
返回的Promise对象的最终状态由then方法执行决定；
否则的话(该value为空，基本类型或者不带then方法的对象),
返回的Promise对象状态为fulfilled，并且将该value传递给对应的then方法。
*/
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise){
            value.then(resolve,reject)
        }else{
            resolve(value)
        }

    })
}
Promise.reject = function (reason) {
/*返回一个状态为失败的Promise对象，并将给定的失败信息传递给对应的处理方法*/
    return new Promise((resolve,reject)=>{
        reject(reason)
    })
}
Promise.all = function (promises) {
/*传一个promise数组
返回一个promise读对象，如果成功传进来的promises数组的执行结果按传进
来的顺序放在数组里，如果失败就传第一个失败的原因
*/
    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的结果进行返回
*/
        promises.forEach(
            (item,index)=>{
                item.then(
                    value => {
                      resolve(value)
                    },
                    reason => {
                        reject(reason)
                    }
                )
            }
        )
    })
}