JavaScript中Promise.allSettled任务计时与性能分析

/**
 * 包装Promise数组，使其在完成时记录并输出耗时。
 *
 * @param {Array<Promise>} promises 待执行的Promise数组。
 * @returns {Promise<Array<Object>>} Promise.allSettled的原始结果。
 */
function allSettledTimedAndLogged(promises) {
    const start = Date.now(); // 记录整个批次开始时间

    return Promise.allSettled(promises.map((p, index) => {
        // 使用.finally()确保无论Promise成功或失败，都能记录时间
        return p.finally(() => {
            console.log(`[任务 ${index}] 完成，耗时 ${Date.now() - start}ms`);
        });
    }));
}

const task1 = new Promise(resolve => setTimeout(() => resolve('Task 1 Done'), 1000));
const task2 = new Promise((_, reject) => setTimeout(() => reject('Task 2 Failed'), 500));
const task3 = new Promise(resolve => setTimeout(() => resolve('Task 3 Done'), 1500));

console.log('开始执行并发任务...');
allSettledTimedAndLogged([task1, task2, task3])
    .then(results => {
        console.log('所有任务完成，Promise.allSettled结果:', results);
    });

// 预期控制台输出（顺序可能因Promise完成时间而异）：
// 开始执行并发任务...
// [任务 1] 完成，耗时 ~1000ms
// [任务 0] 完成，耗时 ~500ms (如果任务2先完成)
// [任务 2] 完成，耗时 ~1500ms
// 所有任务完成，Promise.allSettled结果: [...]

/**
 * 包装Promise数组，使其在完成时记录耗时，并将计时结果嵌入到Promise.allSettled的返回数据中。
 *
 * @param {Array<Promise>} promises 待执行的Promise数组。
 * @returns {Promise<Array<Object>>} 包含每个Promise状态和耗时的结果数组。
 */
function allSettledTimed(promises) {
    const start = Date.now(); // 记录整个批次开始时间
    const times = new Array(promises.length); // 用于存储每个Promise的耗时

    // 包装每个Promise，使其在完成时记录耗时
    const wrappedPromises = promises.map((p, index) => {
        return p.finally(() => {
            times[index] = Date.now() - start; // 记录相对于批次开始时间的耗时
        });
    });

    // 等待所有Promise完成，然后将计时数据合并到结果中
    return Promise.allSettled(wrappedPromises).then(results => {
        // 遍历结果数组，将对应的耗时添加到每个结果对象中
        for (let i = 0; i < results.length; i++) {
            results[i].time = times[i]; // 添加自定义的'time'属性
        }
        return results;
    });
}

const apiCall1 = new Promise(resolve => setTimeout(() => resolve({ id: 1, data: 'User A' }), 1200));
const apiCall2 = new Promise((_, reject) => setTimeout(() => reject(new Error('Network Error')), 600));
const apiCall3 = new Promise(resolve => setTimeout(() => resolve({ id: 3, data: 'Product X' }), 800));

console.log('开始执行带计时的并发API调用...');
allSettledTimed([apiCall1, apiCall2, apiCall3])
    .then(results => {
        console.log('所有API调用完成，结果（含计时）:', results);
        // 进一步分析结果
        results.forEach((res, index) => {
            if (res.status === 'fulfilled') {
                console.log(`API ${index + 1} 成功，耗时 ${res.time}ms，值:`, res.value);
            } else {
                console.log(`API ${index + 1} 失败，耗时 ${res.time}ms，原因:`, res.reason.message);
            }
        });

        // 查找最慢的任务
        const slowestTask = results.reduce((prev, current) => (prev.time > current.time ? prev : current));
        console.log('最慢的任务耗时:', slowestTask.time, 'ms');
    });

// 预期控制台输出：
// 开始执行带计时的并发API调用...
// 所有API调用完成，结果（含计时）: [
//   { status: 'fulfilled', value: { id: 1, data: 'User A' }, time: ~1200 },
//   { status: 'rejected', reason: Error: Network Error, time: ~600 },
//   { status: 'fulfilled', value: { id: 3, data: 'Product X' }, time: ~800 }
// ]
// API 1 成功，耗时 ~1200ms，值: { id: 1, data: 'User A' }
// API 2 失败，耗时 ~600ms，原因: Network Error
// API 3 成功，耗时 ~800ms，值: { id: 3, data: 'Product X' }
// 最慢的任务耗时: ~1200 ms