关于javascript:手写Promise17promise中allraceresolvecathfinally的实现

Promise.all()
Promise.all()办法用于将多个 Promise 实例，包装成一个新的 Promise 实例。
Promise.all()办法承受一个数组作为参数，数组中如果有不是promise实例的状况，就会先调用上面讲到的Promise.resolve办法，将参数转为 Promise 实例，再进一步解决。Promise.all()办法的参数能够不是数组，但必须具备 Iterator 接口，且返回的每个成员都是 Promise 实例。
Promise.all()返回值也是一个promise对象，当所有状态都变成fulfilled，返回值的状态才会变成fulfilled，当有一个promise实例的状态变成rejected，此时第一个被reject的实例的返回值，会传递给返回值的回调函数。

实现过程中定义一个执行后果的数组，遍历all()参数，如果是一般值，间接进入后果数组，如果是promise实例，就先执行，因为for循环有立刻执行的特点，而咱们的promise实例有可能会有异步代码,向下传递执行后果的时候必须要保障咱们所有的实例执行完。传递后果之前要判断所有实例代码是否执行完。

    static all(array) {
        let result = [];
        // 用于判断以后执行值是否等于数组长度，相等时才执行resolve（）
        let idx = 0;

        return new MyPromise((resolve, reject) => {
            // 增加元素办法
            function addElement(index, value) {
                result[index] = value;
                idx++;
                if (idx === array.length) {
                    resolve(result)
                }
            }
            for (let i = 0; i < array.length; ++i) {
                let cur = array[i];
                // 判断cur是否是一般值，一般值间接进入result数组，
                // promise对象就执行它,调用then办法，执行胜利则增加到result数组，如果失败
                if (cur instanceof MyPromise) {
                    // promise对象
                    cur.then(value => addElement(i, value), reason => reject(reason))
                } else {
                    // 一般值
                    addElement(i, array[i]);
                }
            }
        })
    }

promise.race()
race()办法相似，更加简略，遍历传入参数（数组对象），如果是一般值就调用resolve()回调，如果是promise实例，执行then办法

    static race(array) {
        return new MyPromise((resolve, reject) => {
            for (let i = 0; i < array.length; ++i) {
                let cur = array[i];
                if (cur instanceof MyPromise) {
                    cur.then(resolve, reject);
                } else {
                    resolve(cur)
                }
            }
        })
    }

promise.resolve()
将现有对象转换为pomise对象，它的返回值就是一个promise对象。不便前面调用then办法。实现它只须要稍作判断即可

    static resolve(e) {
        if (e instanceof MyPromise) {
            return e;
        } else {
            return new MyPromise(resolve => resolve(e))
        }
    }

Promise.prototype.finally()
finally()办法用于指定不论 Promise 对象最初状态如何，都会执行的操作。该办法是 ES2018 引入规范的。finally办法的回调函数不承受任何参数,不依赖于 Promise 的执行后果。函数体内执行then办法会返回一个promise对象，胜利回调或者失败回调执行callback即可，并且返回胜利回调后果或者抛出失败异样，然而思考到有异步代码的状况，借助resolve()办法，在resolve办法中把callback调用的后果传递进来，无论是一般值还是promise都转成promise对象。之后就能够执行then办法。

    finally(callback) {
        return this.then(value => {
            return MyPromise.resolve(callback()).then(() => value);
        }, reason => {
            return MyPromise.resolve(callback()).then(() => {
                throw reason
            })
        })
    }

Promise.prototype.catch()
Promise.prototype.catch()办法是.then(null, rejection)或.then(undefined, rejection)的别名，用于指定产生谬误时的回调函数。then()办法指定的回调函数，如果运行中抛出谬误，也会被catch()办法捕捉。
Promise 对象的谬误具备“冒泡”性质，会始终向后传递，直到被捕捉为止。也就是说，谬误总是会被下一个catch语句捕捉。
跟传统的try/catch代码块不同的是，如果没有应用catch()办法指定错误处理的回调函数，Promise 对象抛出的谬误不会传递到外层代码，即不会有任何反馈。
在catch办法中执行then办法，第一次参数传入null或者undefined。第二个参数就是failCallback

    catch (failCallback) {
        this.then(undefined, failCallback)
    }