关于javascript:Promise全解

Promise 简介

是一个保留了异步事件将来执行后果的对象。它不是一个新技术，而是一种能够 优化异步编程编码格调的标准 。最早诞生于社区，用于解决 JavaScript 代码中 回调嵌套层级过多的问题和错误处理逻辑堆砌的问题。应用 Promise 对象封装异步操作，能够让代码变得直观、线性、优雅。

Promise 根本应用

用 Promise 封装 Ajax 申请

// 先写一个原始的 Ajax 申请
let xhr = new XMLHttpRequest()
function resolve(v){console.log(v);}
function reject(e){console.log(e);}
xhr.onerror = function(e){reject(e)
}
xhr.ontimeout = function(e){reject(e)
}
xhr.onreadystatechange = function(){if(xhr.readyState===4){if(xhr.status===200){resolve(xhr.response)
        }
    }
}
xhr.open('Get','https://wwww.google.com',true)
xhr.send()

// 第一版：利用 Promise 封装 ajax
let p = new Promise((resolve,reject)=>{let xhr = new XMLHttpRequest()
    xhr.onerror = function(e){reject(e)
    }
    xhr.ontimeout = function(e){reject(e)
    }
    xhr.onreadystatechange = function(){if(xhr.readyState===4){if(xhr.status===200){resolve(xhr.response)
            }
        }
    }
    xhr.open('Get','https://wwww.google.com',true)
    xhr.send()});

p.then(v=>{console.log("我是胜利时注册的回调");
},e=>{console.log("我是失败时注册的回调");
})

// 第二版 反对传参、封装了 Promise 创立的细节
function Xpromise(request){function executor(request,resolve,reject){let xhr = new XMLHttpRequest()
        xhr.onerror = function(e){reject(e)
        }
        xhr.ontimeout = function(e){reject(e)
        }
        xhr.onreadystatechange = function(){if(xhr.readyState===4){if(xhr.status===200){resolve(xhr.response)
                }
            }
        }
        xhr.open('Get',request.url,true)
        xhr.send()}
    renturn new Promise(executor);
}

let x1 = Xpromise(makeRequest('https://wwww.google.com')).then(v=>{console.log("我是胜利时注册的回调");
},e=>{console.log("我是失败时注册的回调");
})

另外，Promise 还提供了一系列好用的 API, 如动态 resolve()、all()、race()办法等。

实现原理概述

Promise 用 回调函数提早绑定 、 回调函数 onResolve 返回值穿透 机制解决回调嵌套层级过多的问题；应用 谬误冒泡机制 简化了错误处理逻辑堆砌的问题。

手工实现一个 Promise

第一版

// 第一点：Promise 是一个类
class MyPromise {
    // 第二点：Promised 构造函数的参数是一个函数；constructor(fn) {if (typeof fn !== "function") {throw new Error("promise 的结构函数参数应该为函数类型")
        }
        // 第三点：Promise 的外部状态有三个，Promise 对象具备值
        this._status = PENDING;
        this._value = undefined;
        // 第五点：new Promise(fn)时，就须要执行 fn 做业务逻辑，故构造函数里就要调用 fn 函数。此处外部函数_resolve 和_reject 会被调用用于追踪 Promise 的外部状态
        try {
            // 留神用 try-catch 包住
            fn(this._resolve.bind(this), this._reject.bind(this));
        } catch (err) {this._reject(err)
        }
    }
    // 第四点：定义 MyPromise 状态翻转时，要执行的外部函数
    _resolve(val){if (this._status !== this.PENDING) return // 这段代码体现了 Promise 的状态翻转：只能是 P ->F 或者是 P ->R
        this._status = FULLFILLED;
        this._value = val;
    };
    _reject(err){if (this._status !== this.PENDING) return
        this._status = REJECTED;
        this._value = err;
    };
}

第二版

class MyPromise {constructor(fn) {if (typeof fn !== "function") {throw new Error("myPromise 的结构函数参数应该为函数类型")
        }
        this._status = PENDING;
        this._value = undefined;
        // 个性 2 - 新增定义两个回调函数数组
        this.fulfilledQueue = [];
        this.rejectedQueue = [];
        try {fn(this._resolve.bind(this), this._reject.bind(this));
        } catch (err) {this._reject(err)
        }
    }
    _resolve(val){if (this._status !== this.PENDING) return
        // 个性 4：注册的回调函数在 Promise 状态翻转时会执行，执行的形式是循环从队列外面取出回调执行
        // 定义 run 函数
        run = (value)=>{
            this._status = FULLFILLED;
            this._value = val;
            let ck;
            while(ck = this.fulfilledQueue.shift()){ck(value);
            }
        }
        // 个性 5：run()函数的执行，这里十分要害。要把 run 放进 setTimeOut。为什么？// 因为执行_resolve()函数时，then()可能还没执行，所以为了让 then()中的回调、包含链式调用的 then()的回调增加到 fulfilledQueue 中，// 须要提早执行 run()。实际上这里用 setTimeout 性能差，理论中采纳微工作的形式实现
        setTimeout(run,0)
        //run();};
    _reject(err){if (this._status !== this.PENDING) return
        run = (error)=>{
            this._status = this.REJECTED;
            this._value = err;
            let ck;
            while(ck = this.rejectedQueue.shift()){ck(error)
            }
        }
        setTimeout(run,0);
    };

    // 最重要的 then 函数：// 个性 1 - 用于注册回调，then()函数有两个参数，都是可选的，如果参数不是函数将会被疏忽
    // then()反对被同一个 Promise 屡次注册，个性 2 - 所以 Promise 外部要保护两个数组，别离存储 then 上注册的胜利回调和失败回调）；// then()反对链式调用, 个性 3 - 之所以反对是因为其返回值是一个新的 Promise，此处要实现回调函数 onFulfilled 穿透机制的实现
    
    // 个性 1 - 回调函数的注册: 故为它传递两个回调函数占位
    then(onFulfilled,onRejected){const {_status, _value} = this;
        // 个性 3 - 返回一个新的 promise
        return new MyPromise((onFulfilledNext, onRejectedNext)=>{
            let fulfilled = value => {
                try{if(typeof onFulfilled != "function"){
                        // 如果 onFulfilled 或 onRejected 不是函数，onFulfilled 或 onRejected 被疏忽
                        onFulfilledNext(value)
                    }else{
                        // 如果 onFulfilled 或者 onRejected 返回一个值 res
                        let res = onFulfilled(value)
                        if(res instanceof MyPromise){// 若 res 为 Promise，这时后一个回调函数，就会期待该 Promise 对象 (即 res) 的状态发生变化，才会被调用，并且新的 Promise 状态和 res 的状态雷同
                            res.then(onFulfilledNext, onRejectedNext)
                        }else{
                            // 若 res 不为 Promise，则使 res 间接作为新返回的 Promise 对象的值
                            onFulfilledNext(res)
                        }
                    }
                }catch(err){onRejectedNext(err)
                }
            }
            let rejected = error => {
                try{if(typeof onRejected != "function"){onRejectedNext(error)
                    }else{let res = onRejectedNext(error)
                        if(res instanceof MyPromise){res.then(onFulfilledNext, onRejectedNext)
                        }else{onFulfilledNext(res);
                        }
                    }
                }catch(err){onRejectedNext(err)
                }
            }
            switch(_status){
                case PENDING:
                    // 在 promise 状态扭转前, onFulfilled 或者 onRejected 不可被调用
                    this._fulfilledQueue.push(onFulfilled)
                    this._rejectedQueue.push(onRejected)
                    break
                case FULFILLED:
                    //onFulfilled 调用次数只有一次，fulfilled 对 onFulFilled 进行包装。why need 包装？因为 onFulFilled 可能是函数、可能不是，如果是函数，返回值可能是 Promise 可能不是
                    fulfilled(_value)
                    break
                case REJECTED:
                    //onRejected 调用次数只有一次
                    rejected(_value)
                    break
            }
        })
    }
}

第三版

class MyPromise {constructor(handle) {if (!isFunction(handle)) {throw new Error('MyPromise must accept a function as a parameter')
        }
        this._status = PENDING
        this._value = undefined
        this._fulfilledQueues = []
        this._rejectedQueues = []
        try {handle(this._resolve.bind(this), this._reject.bind(this))
        } catch (err) {this._reject(err)
        }
    }
    // 增加 resovle 时执行的函数
    _resolve(val) {const run = () => {if (this._status !== PENDING) return
            const runFulfilled = (value) => {
                let cb;
                while (cb = this._fulfilledQueues.shift()) {cb(value)
                }
            }
            const runRejected = (error) => {
                let cb;
                while (cb = this._rejectedQueues.shift()) {cb(error)
                }
            }
            /* 
              如果 resolve 的参数为 Promise 对象，则必须期待该 Promise 对象状态扭转后,
              以后 Promsie 的状态才会扭转，且状态取决于参数 Promsie 对象的状态，因而这里进行逻辑辨别
            */
            if (val instanceof MyPromise) {
                val.then(value => {
                    this._value = value
                    this._status = FULFILLED
                    runFulfilled(value)
                }, err => {
                    this._value = err
                    this._status = REJECTED
                    runRejected(err)
                })
            } else {
                this._value = val
                this._status = FULFILLED
                runFulfilled(val)
            }
        }
        setTimeout(run, 0)
    }
    _reject(err) {if (this._status !== PENDING) return
        const run = () => {
            this._status = REJECTED
            this._value = err
            let cb;
            while (cb = this._rejectedQueues.shift()) {cb(err)
            }
        }
        setTimeout(run, 0)
    }
    then(onFulfilled, onRejected) {const { _value, _status} = this
        return new MyPromise((onFulfilledNext, onRejectedNext) => {
            let fulfilled = value => {
                try {if (!isFunction(onFulfilled)) {onFulfilledNext(value)
                    } else {let res = onFulfilled(value);
                        if (res instanceof MyPromise) {res.then(onFulfilledNext, onRejectedNext)
                        } else {onFulfilledNext(res)
                        }
                    }
                } catch (err) {onRejectedNext(err)
                }
            }
            let rejected = error => {
                try {if (!isFunction(onRejected)) {onRejectedNext(error)
                    } else {let res = onRejected(error);
                        if (res instanceof MyPromise) {res.then(onFulfilledNext, onRejectedNext)
                        } else {onFulfilledNext(res)
                        }
                    }
                } catch (err) {onRejectedNext(err)
                }
            }
            switch (_status) {
                case PENDING:
                    this._fulfilledQueues.push(fulfilled)
                    this._rejectedQueues.push(rejected)
                    break
                case FULFILLED:
                    fulfilled(_value)
                    break
                case REJECTED:
                    rejected(_value)
                    break
            }
        })
    }
}

第四版 finally

class MyPromise {constructor(handle) {if (!isFunction(handle)) {throw new Error('MyPromise must accept a function as a parameter')
        }
        this._status = PENDING
        this._value = undefined
        this._fulfilledQueues = []
        this._rejectedQueues = []
        try {handle(this._resolve.bind(this), this._reject.bind(this))
        } catch (err) {this._reject(err)
        }
    }
    _resolve(val) {const run = () => {if (this._status !== PENDING) return
            const runFulfilled = (value) => {
                let cb;
                while (cb = this._fulfilledQueues.shift()) {cb(value)
                }
            }
            const runRejected = (error) => {
                let cb;
                while (cb = this._rejectedQueues.shift()) {cb(error)
                }
            }
            if (val instanceof MyPromise) {
                val.then(value => {
                    this._value = value
                    this._status = FULFILLED
                    runFulfilled(value)
                }, err => {
                    this._value = err
                    this._status = REJECTED
                    runRejected(err)
                })
            } else {
                this._value = val
                this._status = FULFILLED
                runFulfilled(val)
            }
        }
        setTimeout(run, 0)
    }
    _reject(err) {if (this._status !== PENDING) return
        const run = () => {
            this._status = REJECTED
            this._value = err
            let cb;
            while (cb = this._rejectedQueues.shift()) {cb(err)
            }
        }
        setTimeout(run, 0)
    }
    then(onFulfilled, onRejected) {const { _value, _status} = this
        return new MyPromise((onFulfilledNext, onRejectedNext) => {
            let fulfilled = value => {
                try {if (!isFunction(onFulfilled)) {onFulfilledNext(value)
                    } else {let res = onFulfilled(value);
                        if (res instanceof MyPromise) {res.then(onFulfilledNext, onRejectedNext)
                        } else {onFulfilledNext(res)
                        }
                    }
                } catch (err) {onRejectedNext(err)
                }
            }
            let rejected = error => {
                try {if (!isFunction(onRejected)) {onRejectedNext(error)
                    } else {let res = onRejected(error);
                        if (res instanceof MyPromise) {res.then(onFulfilledNext, onRejectedNext)
                        } else {onFulfilledNext(res)
                        }
                    }
                } catch (err) {onRejectedNext(err)
                }
            }
            switch (_status) {
                case PENDING:
                    this._fulfilledQueues.push(fulfilled)
                    this._rejectedQueues.push(rejected)
                    break
                case FULFILLED:
                    fulfilled(_value)
                    break
                case REJECTED:
                    rejected(_value)
                    break
            }
        })
    }
    // 增加 catch 办法
    catch(onRejected) {return this.then(undefined, onRejected)
    }
    // 增加动态 resolve 办法
    static resolve(value) {
        // 如果参数是 MyPromise 实例，间接返回这个实例
        if (value instanceof MyPromise) return value
        return new MyPromise(resolve => resolve(value))
    }
    // 增加动态 reject 办法
    static reject(value) {return new MyPromise((resolve, reject) => reject(value))
    }
    // 增加动态 all 办法
    static all(list) {return new MyPromise((resolve, reject) => {
            /**
             * 返回值的汇合
             */
            let values = []
            let count = 0
            for (let [i, p] of list.entries()) {
                // 数组参数如果不是 MyPromise 实例，先调用 MyPromise.resolve
                this.resolve(p).then(res => {values[i] = res
                    count++
                    // 所有状态都变成 fulfilled 时返回的 MyPromise 状态就变成 fulfilled
                    if (count === list.length) resolve(values)
                }, err => {
                    // 有一个被 rejected 时返回的 MyPromise 状态就变成 rejected
                    reject(err)
                })
            }
        })
    }
    // 增加动态 race 办法
    static race(list) {return new MyPromise((resolve, reject) => {for (let p of list) {
                // 只有有一个实例率先扭转状态，新的 MyPromise 的状态就跟着扭转
                this.resolve(p).then(res => {resolve(res)
                }, err => {reject(err)
                })
            }
        })
    }
    finally(cb) {
        return this.then(value => MyPromise.resolve(cb()).then(() => value),
            reason => MyPromise.resolve(cb()).then(() => { throw reason})
        );
    }
}

其它问题

1. Promise 与宏观工作、async 函数等执行程序问题

Promise 是微工作的一种实现，给出如下的代码，剖析其输入程序

// 题目 1
async function a1 () {console.log('a1 start')
    await a2()
    console.log('a1 end')
}
async function a2 () {console.log('a2')
}
console.log('script start')
setTimeout(() => {console.log('setTimeout')
}, 0)
Promise.resolve().then(() => {console.log('promise1')
})
a1()
let promise2 = new Promise((resolve) => {resolve('promise2.then')
    console.log('promise2')
})
promise2.then((res) => {console.log(res)
    Promise.resolve().then(() => {console.log('promise3')
    })
})
console.log('script end')
// 题目 2
async function async1() {console.log('async1 start');
    await async2();
    await async3()
    console.log('async1 end');
}
async function async2() {console.log('async2');
}
async function async3() {console.log('async3');
}
console.log('script start');
setTimeout(function() {console.log('setTimeout');
}, 0)
async1();
new Promise(function(resolve) {console.log('promise1');
    resolve();}).then(function() {console.log('promise2');
});
console.log('script end');
// 题目 3
async function async1(){console.log('async1 start')
    await async2()
    console.log('async1 end')
  }
async function async2(){console.log('async2')
}
console.log('script start')
setTimeout(function(){console.log('setTimeout0') 
},0)  
setTimeout(function(){console.log('setTimeout3') 
},3)  
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick'));
async1();
new Promise(function(resolve){console.log('promise1')
    resolve();
    console.log('promise2')
}).then(function(){console.log('promise3')
})
console.log('script end')

答案：
题目一：script start->a1 start->a2->promise2->script end->promise1->a1 end->promise2.then->promise3->setTimeout
题目二：script start->async1 start->async2->promise1->script end->async3->promise2->async1 end->setTimeout
在浏览器 console 可试验
题目三：script start->async1 start->async2->promise1->promise2
->script end->nextTick->async1 end->promise3->setTimeout->setImmediate->setTimeout3
在 node 环境中可试验

2. 如何实现 all、如何实现链式调用的

all()的实现：函数中保护了一个数组和计数器，数组的大小为初始时 all 函数中传递的 Promise 对象数量，数组存储各个 Promise 执行胜利后 resolve 失去的后果，每胜利一个计数器 +1，直到计数器累加到数组大小时即调用 resolve(value)，只有有一个 Promise 执行到失败的回调，即全副失败。
链式调用的实现：then 函数返回的仍然是一个 Promise, 见第二版的 Promise 实现。

3. all 中任何一个 Promise 出错，导致其它正确的数据也无奈应用，如何解决呢？

办法 1：应用 allSettled 代替；办法 2：改写 Promise, 将 reject 操作换成是 resolve(new Error(“ 自定义的谬误 ”))；办法 3：引入第三方库 promise-transaction

4.Promise 真的好用吗，它存在什么问题？

问题 1：没有提供中途勾销的机制；问题 2：必须要设置回调，否则外部谬误无奈在内部反映进去；问题 3：应用时仍然存在大量 Promise 的 api, 逻辑不清晰。