【Promise】第四部分 自定义封装Promise

4. 自定义封装Promise

以下都是按照之前所讲的功能一步步进行迭代，最后实现自定义封装Promise，想要直接查看完整的直接跳到最下面的4.15或者是4.16

4.1 初步结构搭建

根据我们之前使用Promise进行模仿结构

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){

}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){

}

4.2 resolve和reject 功能的实现

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null
    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this

    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        self.PromiseState = 'rejected'
        self.PromiseResult = data
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    executor(resolve,reject)
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){

}

4.3 抛出异常改变状态和结果

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null
    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        self.PromiseState = 'rejected'
        self.PromiseResult = data
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve,reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }
   
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){

}

4.4 Promise对象状态只能被改变一次

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null
    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending')  return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve,reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }
   
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){

}

4.5 then方法执行回调

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null
    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending')  return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve,reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }
   
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){
    
    if(this.PromiseState === 'fulfilled')
    {
        onResolved(this.PromiseResult)
    }

    if(this.PromiseState === 'rejected')
    {
        onRejected(this.PromiseResult)
    }
    
}

4.6 异步任务回调的执行

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    this.callback = {}

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending')  return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
            添加一个判断
         */
        if(self.callback.onResolved)
        {
            self.callback.onResolved(data)
        }
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

         /*
            针对异步回调执行
            添加一个判断
         */
        if(self.callback.onRejected)
        {
            self.callback.onRejected(data)
        }
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve,reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }
   
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){
    
    if(this.PromiseState === 'fulfilled')
    {
        onResolved(this.PromiseResult)
    }

    if(this.PromiseState === 'rejected')
    {
        onRejected(this.PromiseResult)
    }

    /* 
        添加对pending的判断,因为异步操作,导致先指定then,
        这时候Promise对象的状态还未发生改变
    */
    if(this.PromiseState === 'pending')
    {
        // 保存回调函数
        this.callback = {
            onResolved : onResolved,
            onRejected : onRejected
        }
    }

}

4.7 指定多个回调的实现

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise (executor){
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve (data){
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending')  return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item=>{
            item.onResolved(data)
        })
       
    }

    function reject (data){
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
       // Promise对象状态只能被改变一次
       if(self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

         /*
            针对异步回调执行
         */
        self.callbacks.forEach(item=>{
            item.onRejected(data)
        })
        
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve,reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }
   
}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
*/
Promise.prototype.then = function (onResolved,onRejected){
    
    if(this.PromiseState === 'fulfilled')
    {
        onResolved(this.PromiseResult)
    }

    if(this.PromiseState === 'rejected')
    {
        onRejected(this.PromiseResult)
    }

    /* 
        添加对pending的判断,因为异步操作,导致先指定then,
        这时候Promise对象的状态还未发生改变
    */
    if(this.PromiseState === 'pending')
    {
        // 保存回调函数
        this.callbacks.push({
            onResolved : onResolved,
            onRejected : onRejected
        }) 
    }

}

4.8 同步修改状态then方法结果返回

回顾一下:

• 如果返回的结果是非Promise对象则状态为成功,值为回调返回的值
• 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected

    1. then()返回的是一个新的Promise对象
    2. 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    3. 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        if (this.PromiseState === 'fulfilled') {
            /* 
                判断如果非Promise对象则为状态为成功且值为返回的值
                如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
            */
           // 获取回调函数的执行结果
            let result = onResolved(this.PromiseResult)
            if(result instanceof Promise)
            {
                // 因为它是Promise对象所以可以调用then()
                result.then(value=>{
                    resolve(value)
                },reason=>{
                    reject(reason)
                })
            }else{
                resolve(result)
            }   
        }

        if (this.PromiseState === 'rejected') {
            onRejected(this.PromiseResult)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: onResolved,
                onRejected: onRejected
            })
        }

    })

}

4.9 异步修改状态then方法结果返回

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        if (this.PromiseState === 'fulfilled') {
            /* 
                判断如果非Promise对象则为状态为成功且值为返回的值
                如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
            */
           // 获取回调函数的执行结果
            let result = onResolved(this.PromiseResult)
            if(result instanceof Promise)
            {
                // 因为它是Promise对象所以可以调用then()
                result.then(value=>{
                    resolve(value)
                },reason=>{
                    reject(reason)
                })
            }else{
                resolve(result)
            }   
        }

        if (this.PromiseState === 'rejected') {
            let result = onRejected(this.PromiseResult)
            if(result instanceof Promise)
            {
                // 因为它是Promise对象所以可以调用then()
                result.then(value=>{
                    resolve(value)
                },reason=>{
                    reject(reason)
                })
            }else{
                resolve(result)
            } 
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    // 获取回调函数的执行结果
                    let result = onResolved(self.PromiseResult)
                    if(result instanceof Promise)
                    {
                        result.then(value=>{
                            resolve(value)
                        },reason=>{
                            reject(reason)
                        })
                    }else{
                        resolve(result)
                    }
                },
                onRejected: function(){
                     // 获取回调函数的执行结果
                     let result = onRejected(self.PromiseResult)
                     if(result instanceof Promise)
                     {
                         result.then(value=>{
                             resolve(value)
                         },reason=>{
                             reject(reason)
                         })
                     }else{
                         resolve(result)
                     }
                }
            })
        }

    })

}

4.10 对then方法进行优化处理

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
           generalCallback(onResolved)
        }

        if (this.PromiseState === 'rejected') {
            generalCallback(onRejected)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}

4.11 对catch方法进行封装(异常穿透、值传递)

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    //判断回调函数参数
    if(typeof onResolved != 'function')
    {
        onResolved = value => value
    }

    // 判断回调函数参数，并且实现异常穿透
    if(typeof onRejected != 'function'){
        onRejected = reason => {
            throw reason
        }
    }

    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
           generalCallback(onResolved)
        }

        if (this.PromiseState === 'rejected') {
            generalCallback(onRejected)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}


/*
    添加catch方法
    1. 捕获抛出的错误
    2. 异常穿透
       需要解决的问题：能够允许用户不写参数
       办法：在then方法中添加判断为其添加默认值
    3. 值传递  
*/
Promise.prototype.catch = function (onRejected){
    return this.then(undefined,onRejected)
}

4.12 对 Promise.resolved 和 Promise.rejected进行封装

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    添加then方法
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    //判断回调函数参数
    if(typeof onResolved != 'function')
    {
        onResolved = value => value
    }

    // 判断回调函数参数，并且实现异常穿透
    if(typeof onRejected != 'function'){
        onRejected = reason => {
            throw reason
        }
    }

    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
           generalCallback(onResolved)
        }

        if (this.PromiseState === 'rejected') {
            generalCallback(onRejected)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}


/*
    添加catch方法
    1. 捕获抛出的错误
    2. 异常穿透
       需要解决的问题：能够允许用户不写参数
       办法：判断为其添加默认函数
    3. 值传递  
*/
Promise.prototype.catch = function (onRejected){
    return this.then(undefined,onRejected)
}



/*
    添加Promise.resolve方法
    注意这里是添加在Promise对象上，不是实例对象上
*/
Promise.resolve = function (value){
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise)
        {
            value.then(value=>{
                resolve(value)
            },reason=>{
                reject(reason)
            })
        }else
        {
            resolve(value)
        }
    })
}

/*
    添加Promise.reject方法
    注意这里是添加在Promise对象上，不是实例对象上
*/

Promise.reject = function (res){
    return new Promise((resolve,reject)=>{
        reject(res)
    })
}

4.13 对Promise.all 方法进行封装

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    添加then方法
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    //判断回调函数参数
    if(typeof onResolved != 'function')
    {
        onResolved = value => value
    }

    // 判断回调函数参数，并且实现异常穿透
    if(typeof onRejected != 'function'){
        onRejected = reason => {
            throw reason
        }
    }

    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
           generalCallback(onResolved)
        }

        if (this.PromiseState === 'rejected') {
            generalCallback(onRejected)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}


/*
    添加catch方法
    1. 捕获抛出的错误
    2. 异常穿透
       需要解决的问题：能够允许用户不写参数
       办法：判断为其添加默认函数
    3. 值传递  
*/
Promise.prototype.catch = function (onRejected){
    return this.then(undefined,onRejected)
}



/*
    添加Promise.resolve方法
    注意这里是添加在Promise对象上，不是实例对象上
*/
Promise.resolve = function (value){
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise)
        {
            value.then(value=>{
                resolve(value)
            },reason=>{
                reject(reason)
            })
        }else
        {
            resolve(value)
        }
    })
}

/*
    添加Promise.reject方法
    注意这里是添加在Promise对象上，不是实例对象上
*/

Promise.reject = function (res){
    return new Promise((resolve,reject)=>{
        reject(res)
    })
}

/* 
    添加Promise.all 方法
    注意这里是添加在Promise对象上，不是实例对象上
    1. 返回的是一个新的Promise对象
    2. 如果都成功，返回的状态为fulfilled,值为数组保存所有传入的值
    3. 如果有一个或者是多个失败返回的状态为rejected，值为最近失败的值
*/
Promise.all = function (Promises){ 

   return new Promise((resolve,reject)=>{
       // 该属性用来判断是否都为成功
       let count = 0

       //该属性用来保存成功的值
       let arr = []

        for(let i = 0; i< Promises.length; i++)
        {
            // 因为每个都是Promise对象所以都可以调用then方法
            Promises[i].then(value=>{
                arr[i] = value
                count++
                if(count === Promises.length)
                {
                    resolve(arr)
                }
            },reason=>{
                reject(reason)
            })
        }
   })
 }

4.14 对Promise.race 方法进行封装

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        self.callbacks.forEach(item => {
            item.onResolved(data)
        })

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        self.callbacks.forEach(item => {
            item.onRejected(data)
        })

    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    添加then方法
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    //判断回调函数参数
    if(typeof onResolved != 'function')
    {
        onResolved = value => value
    }

    // 判断回调函数参数，并且实现异常穿透
    if(typeof onRejected != 'function'){
        onRejected = reason => {
            throw reason
        }
    }

    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
           generalCallback(onResolved)
        }

        if (this.PromiseState === 'rejected') {
            generalCallback(onRejected)
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}


/*
    添加catch方法
    1. 捕获抛出的错误
    2. 异常穿透
       需要解决的问题：能够允许用户不写参数
       办法：判断为其添加默认函数
    3. 值传递  
*/
Promise.prototype.catch = function (onRejected){
    return this.then(undefined,onRejected)
}



/*
    添加Promise.resolve方法
    注意这里是添加在Promise对象上，不是实例对象上
*/
Promise.resolve = function (value){
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise)
        {
            value.then(value=>{
                resolve(value)
            },reason=>{
                reject(reason)
            })
        }else
        {
            resolve(value)
        }
    })
}

/*
    添加Promise.reject方法
    注意这里是添加在Promise对象上，不是实例对象上
*/

Promise.reject = function (res){
    return new Promise((resolve,reject)=>{
        reject(res)
    })
}

/* 
    添加Promise.all 方法
    注意这里是添加在Promise对象上，不是实例对象上
    1. 返回的是一个新的Promise对象
    2. 如果都成功，返回的状态为fulfilled,值为数组保存所有传入的值
    3. 如果有一个或者是多个失败返回的状态为rejected，值为最近失败的值
*/
Promise.all = function (Promises){ 

   return new Promise((resolve,reject)=>{
       // 该属性用来判断是否都为成功
       let count = 0

       //该属性用来保存成功的值
       let arr = []

        for(let i = 0; i< Promises.length; i++)
        {
            // 因为每个都是Promise对象所以都可以调用then方法
            Promises[i].then(value=>{
                arr[i] = value
                count++
                if(count === Promises.length)
                {
                    resolve(arr)
                }
            },reason=>{
                reject(reason)
            })
        }
   })
 }

 /* 
    添加Promise.race 方法
    注意这里是添加在Promise对象上，不是实例对象上
    1. 返回的是一个新的Promise对象
    2. 第一个完成的 promise状态改变就是最终的结果状态
*/
Promise.race = function (Promises){ 

    return new Promise((resolve,reject)=>{     
         for(let i = 0; i< Promises.length; i++)
         {
             // 因为每个都是Promise对象所以都可以调用then方法
             Promises[i].then(value=>{
                resolve(value)
             },reason=>{
                 reject(reason)
             })
         }
    })
  }

4.15 then方法回调的异步执行

/* 
    有一个参数我们取名为executor(执行器)
*/
function Promise(executor) {
    // 添加状态和结果值
    this.PromiseState = 'pending'
    this.PromiseResult = null

    // 添加callback属性,用来保存回调函数
    // 将原来对象的形式修改成了数组,为了实现指定多个回调
    this.callbacks = []

    // 这里需要保存当前的this,因为下面的resolve,reject
    // 因为是直接调用所以this会指向window
    const self = this


    function resolve(data) {
        /* 
            我们知道有两个功能
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data

        /*
            针对异步回调执行
         */
        //then方法回调异步执行
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onResolved(data)
            })   
        });

    }

    function reject(data) {
        /* 
            1. 修改对象的状态
            2. 设置对象的结果值
        */
        // Promise对象状态只能被改变一次
        if (self.PromiseState != 'pending') return;
        self.PromiseState = 'rejected'
        self.PromiseResult = data

        /*
           针对异步回调执行
        */
        //then方法回调异步执行
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onRejected(data)
            })
        });    
    }

    // 同步调用执行器函数
    // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
    // 抛出异常只能使用try..catch进行捕获
    try {
        executor(resolve, reject)
    } catch (error) {
        // 调用reject函数对状态结果进行修改
        reject(error)
    }

}

/* 
    添加then方法
    将then添加到原型链上,它有两个参数取名为onResolved,onRejected
    - then()返回的是一个新的Promise对象
    - 如果返回的结果是非Promise对象则状态为成功,值为返回的值
    - 如果返回的结果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
*/
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    //判断回调函数参数
    if(typeof onResolved != 'function')
    {
        onResolved = value => value
    }

    // 判断回调函数参数，并且实现异常穿透
    if(typeof onRejected != 'function'){
        onRejected = reason => {
            throw reason
        }
    }

    // 返回一个新Promise对象
    return new Promise((resolve, reject) => {

        //对函数进行封装
        function generalCallback (type){
            /* 
                   判断如果非Promise对象则为状态为成功且值为返回的值
                   如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
               */
              // 获取回调函数的执行结果
             try {
                let result = type(self.PromiseResult)
                if(result instanceof Promise)
                {
                    // 因为它是Promise对象所以可以调用then()
                    result.then(value=>{
                        resolve(value)
                    },reason=>{
                        reject(reason)
                    })
                }else{
                    resolve(result)
                }   
             } catch (error) {
                 reject(error)
             }
       }

        if (this.PromiseState === 'fulfilled') {
            //then方法回调异步执行
            setTimeout(() => {
                generalCallback(onResolved)
            });        
        }

        if (this.PromiseState === 'rejected') {
            //then方法回调异步执行
            setTimeout(() => {
                generalCallback(onRejected)
            });  
        }

        /* 
            添加对pending的判断,因为异步操作,导致先指定then,
            这时候Promise对象的状态还未发生改变
        */
        if (this.PromiseState === 'pending') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: function(){
                    generalCallback(onResolved)
                },
                onRejected: function(){
                    generalCallback(onRejected)
                }
            })
        }

    })

}


/*
    添加catch方法
    1. 捕获抛出的错误
    2. 异常穿透
       需要解决的问题：能够允许用户不写参数
       办法：判断为其添加默认函数
    3. 值传递  
*/
Promise.prototype.catch = function (onRejected){
    return this.then(undefined,onRejected)
}



/*
    添加Promise.resolve方法
    注意这里是添加在Promise对象上，不是实例对象上
*/
Promise.resolve = function (value){
    return new Promise((resolve,reject)=>{
        if(value instanceof Promise)
        {
            value.then(value=>{
                resolve(value)
            },reason=>{
                reject(reason)
            })
        }else
        {
            resolve(value)
        }
    })
}

/*
    添加Promise.reject方法
    注意这里是添加在Promise对象上，不是实例对象上
*/

Promise.reject = function (res){
    return new Promise((resolve,reject)=>{
        reject(res)
    })
}

/* 
    添加Promise.all 方法
    注意这里是添加在Promise对象上，不是实例对象上
    1. 返回的是一个新的Promise对象
    2. 如果都成功，返回的状态为fulfilled,值为数组保存所有传入的值
    3. 如果有一个或者是多个失败返回的状态为rejected，值为最近失败的值
*/
Promise.all = function (Promises){ 

   return new Promise((resolve,reject)=>{
       // 该属性用来判断是否都为成功
       let count = 0

       //该属性用来保存成功的值
       let arr = []

        for(let i = 0; i< Promises.length; i++)
        {
            // 因为每个都是Promise对象所以都可以调用then方法
            Promises[i].then(value=>{
                arr[i] = value
                count++
                if(count === Promises.length)
                {
                    resolve(arr)
                }
            },reason=>{
                reject(reason)
            })
        }
   })
 }

 /* 
    添加Promise.race 方法
    注意这里是添加在Promise对象上，不是实例对象上
    1. 返回的是一个新的Promise对象
    2. 第一个完成的 promise状态改变就是最终的结果状态
*/
Promise.race = function (Promises){ 

    return new Promise((resolve,reject)=>{     
         for(let i = 0; i< Promises.length; i++)
         {
             // 因为每个都是Promise对象所以都可以调用then方法
             Promises[i].then(value=>{
                resolve(value)
             },reason=>{
                 reject(reason)
             })
         }
    })
  }

4.16 使用class对其进行封装

class Promise {
    // 构造函数
    constructor(executor) {
        // 添加状态和结果值
        this.PromiseState = 'pending'
        this.PromiseResult = null

        // 添加callback属性,用来保存回调函数
        // 将原来对象的形式修改成了数组,为了实现指定多个回调
        this.callbacks = []

        // 这里需要保存当前的this,因为下面的resolve,reject
        // 因为是直接调用所以this会指向window
        const self = this


        function resolve(data) {
            /* 
                我们知道有两个功能
                1. 修改对象的状态
                2. 设置对象的结果值
            */
            // Promise对象状态只能被改变一次
            if (self.PromiseState != 'pending') return;
            self.PromiseState = 'fulfilled'
            self.PromiseResult = data

            /*
                针对异步回调执行
             */
            //then方法回调异步执行
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onResolved(data)
                })
            });

        }

        function reject(data) {
            /* 
                1. 修改对象的状态
                2. 设置对象的结果值
            */
            // Promise对象状态只能被改变一次
            if (self.PromiseState != 'pending') return;
            self.PromiseState = 'rejected'
            self.PromiseResult = data

            /*
               针对异步回调执行
            */
            //then方法回调异步执行
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onRejected(data)
                })
            });
        }

        // 同步调用执行器函数
        // 执行器中有两个参数,并且这两个参数都是函数,所以我们要声明函数
        // 抛出异常只能使用try..catch进行捕获
        try {
            executor(resolve, reject)
        } catch (error) {
            // 调用reject函数对状态结果进行修改
            reject(error)
        }
    }

    //then 方法封装
    then(onResolved, onRejected) {
        const self = this
        //判断回调函数参数
        if (typeof onResolved != 'function') {
            onResolved = value => value
        }

        // 判断回调函数参数，并且实现异常穿透
        if (typeof onRejected != 'function') {
            onRejected = reason => {
                throw reason
            }
        }

        // 返回一个新Promise对象
        return new Promise((resolve, reject) => {

            //对函数进行封装
            function generalCallback(type) {
                /* 
                       判断如果非Promise对象则为状态为成功且值为返回的值
                       如果是Promise对象,则该Promise对象的状态和结果决定then()返回的状态和结果
                   */
                // 获取回调函数的执行结果
                try {
                    let result = type(self.PromiseResult)
                    if (result instanceof Promise) {
                        // 因为它是Promise对象所以可以调用then()
                        result.then(value => {
                            resolve(value)
                        }, reason => {
                            reject(reason)
                        })
                    } else {
                        resolve(result)
                    }
                } catch (error) {
                    reject(error)
                }
            }

            if (this.PromiseState === 'fulfilled') {
                //then方法回调异步执行
                setTimeout(() => {
                    generalCallback(onResolved)
                });
            }

            if (this.PromiseState === 'rejected') {
                //then方法回调异步执行
                setTimeout(() => {
                    generalCallback(onRejected)
                });
            }

            /* 
                添加对pending的判断,因为异步操作,导致先指定then,
                这时候Promise对象的状态还未发生改变
            */
            if (this.PromiseState === 'pending') {
                // 保存回调函数
                this.callbacks.push({
                    onResolved: function () {
                        generalCallback(onResolved)
                    },
                    onRejected: function () {
                        generalCallback(onRejected)
                    }
                })
            }

        })
    }

    // catch 方法封装
    catch(onRejected) {
        return this.then(undefined, onRejected)
    }

    /*
        Promise.resolve方法 封装
        注意这里是添加在Promise对象上，不是实例对象上
    */

    static resolve(value) {
        return new Promise((resolve, reject) => {
            if (value instanceof Promise) {
                value.then(value => {
                    resolve(value)
                }, reason => {
                    reject(reason)
                })
            } else {
                resolve(value)
            }
        })
    }

    /*
        Promise.reject方法 封装
        注意这里是添加在Promise对象上，不是实例对象上
    */

    static reject = function (res) {
        return new Promise((resolve, reject) => {
            reject(res)
        })
    }

    /* 
        Promise.all 方法 封装
        注意这里是添加在Promise对象上，不是实例对象上
    */
    static all = function (Promises) {
        return new Promise((resolve, reject) => {
            // 该属性用来判断是否都为成功
            let count = 0

            //该属性用来保存成功的值
            let arr = []

            for (let i = 0; i < Promises.length; i++) {
                // 因为每个都是Promise对象所以都可以调用then方法
                Promises[i].then(value => {
                    arr[i] = value
                    count++
                    if (count === Promises.length) {
                        resolve(arr)
                    }
                }, reason => {
                    reject(reason)
                })
            }
        })
    }

    /* 
        添加Promise.race 方法 封装
        注意这里是添加在Promise对象上，不是实例对象上
    */
    static race = function (Promises) {

        return new Promise((resolve, reject) => {
            for (let i = 0; i < Promises.length; i++) {
                // 因为每个都是Promise对象所以都可以调用then方法
                Promises[i].then(value => {
                    resolve(value)
                }, reason => {
                    reject(reason)
                })
            }
        })
    }

}

总结

以上就是今天要讲的内容，希望对大家有所帮助！！！