01-并行执行异步函数

#题目描述#

给定一个异步函数数组 functions，返回一个新的 promise 对象 promise。数组中的每个函数都不接受参数并返回一个 promise。所有的 promise 都应该并行执行。

promise resolve 条件：
当所有从 functions 返回的 promise 都成功的并行解析时。promise 的解析值应该是一个按照它们在 functions 中的顺序排列的 promise 的解析值数组。promise 应该在数组中的所有异步函数并行执行完成时解析。

promise reject 条件：
当任何从 functions 返回的 promise 被拒绝时。promise 也会被拒绝，并返回第一个拒绝的原因。

请在不使用内置的 Promise.all 函数的情况下解决。

#示例# 

1、示例1

输入：functions = [
  () => new Promise(resolve => setTimeout(() => resolve(5), 200))
]
输出：{"t": 200, "resolved": [5]}
解释：
promiseAll(functions).then(console.log); // [5]

单个函数在 200 毫秒后以值 5 成功解析。

2、示例2

输入：functions = [
    () => new Promise(resolve => setTimeout(() => resolve(1), 200)), 
    () => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100))
]
输出：{"t": 100, "rejected": "Error"}
解释：由于其中一个 promise 被拒绝，返回的 promise 也在同一时间被拒绝并返回相同的错误。

3、示例3 

输入：functions = [
    () => new Promise(resolve => setTimeout(() => resolve(4), 50)), 
    () => new Promise(resolve => setTimeout(() => resolve(10), 150)), 
    () => new Promise(resolve => setTimeout(() => resolve(16), 100))
]
输出：{"t": 150, "resolved": [4, 10, 16]}
解释：所有的 promise 都成功执行。当最后一个 promise 被解析时，返回的 promise 也被解析了。

#提示# 

函数 functions 是一个返回 promise 的函数数组
1 <= functions.length <= 10

#题目解析# 

1、准入准出：定义一个函数promiseAll，当传入一个异步函数数组 functions，返回一个新的 promise 对象 promise。

/**
 * @param {Array<Function>} functions
 * @return {Promise<any>}
*/
var promiseAll = function (functions) {
    return new Promise((resolve, reject) => {
        // 代码实现
    })
};

2、 参数定义：functions是一个由Promise函数（不接受参数）组成的异步函数数组，所以都能通过promise.then() 、或await/async语法糖获取到执行的结果，且所有的Promise函数是并行执行，可以通过forEach循环调用

3、结果解析：

Promise resolve条件：定义一个成功返回值result，是一个所有解析值的数组，通过for循环或forEach函数进行循环执行functions数组里的异步函数，并且根据索引i进行解析值的数组赋值，promise().then(res => result[i] = res)，如何判断数组中的所有异步函数并行执行完成：相当于所有的promise都通过then取到了对应的解析值，可以定义一个count，每成功解析一个promise做累加，判断count的值和functions的length值相等时则说明全部解析完成

Promise reject条件：通过.catch捕获到哪个promise执行被拒绝了，有一个被拒绝，整个Primise也都被拒绝，并且输出当前的拒绝对象，只要捕获到那个一个即为第一个

#答案解析# 

/**
 * @param {Array<Function>} functions
 * @return {Promise<any>}
 */
var promiseAll = async function (functions) {
    return new Promise((resolve, reject) => {
        const result = []
        let count = 0;
        functions.forEach(async (fn, i) => {
            try {
                result[i] = await fn();
                if (++count == functions.length) {
                    resolve(result)
                }
            } catch (err){
                reject(err)
            }
        })
    })
};

/**
 * @param {Array<Function>} functions
 * @return {Promise<any>}
 */
var promiseAll = function (functions) {
    return new Promise((resolve, reject) => {
        const result = []
        let count = 0;
        functions.forEach((fn, i) => {
            fn().then(res => {
                result[i] = res;
                if (++count == functions.length) {
                    resolve(result)
                }
            }).catch(reject)
        })
    })
};

/**
 * @param {Array<Function>} functions
 * @return {Promise<any>}
 */
var promiseAll = function (functions) {
    return new Promise((resolve, reject) => {
        const result = [];
        let count = 0;
        for (let i = 0; i < functions.length; i++) {
            const item =functions[i]
            item().then((res) => {
                result[i] = res;
                if (++count === functions.length) {
                    resolve(result);
                }
            }).catch(reject)
        }
    })
};