关于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)
    }