嵌套 Promise.all 異步/等待 map

Question

我遇到了一個嵌套的 for 循環，其中包含等待操作，如下所示：

    async handleProjects (projects) {
        for (let i = 0; i < projects.rows.length; i++) {
            projects.rows[i].owner = await this.userProvider.serialize(projects.rows[i].owner);
            for (let j = 0; j < projects.rows[i].collaborators.length; j++) {
                const collaborator = await this.userProvider.serialize(projects.rows[i].collaborators[j].email);
                if (collaborator) {
                    projects.rows[i].collaborators[j].name = collaborator.name;
                    delete projects.rows[i].collaborators[j].role;
                }
            }
        }
        return projects;
    }

1.上面的代碼是按順序運行的嗎？

2.提高性能我想使用 promise.all 如下所示，但有些運行時間大致相同，有時 promise.all 甚至更長。 我的錯誤在哪里？

    async handleProject (projects) {
        await Promise.all(projects.rows.map(async (row) => {
            console.log(row);
            row.owner = await this.userProvider.serialize(row.owner);
            return await Promise.all(row.collaborators.map(async (collaborator) => {
                const collaboratorObj = await this.userProvider.serialize(collaborator.email);
                if (collaboratorObj) {
                    collaborator.name = collaboratorObj.name;
                    delete collaborator.role;
                }
            }));
        }));
        return projects;
    }

Answer 1

讓我們看一下使用超時來模擬您的異步調用。

在您進行優化之前，此代碼等效於您的第一個示例。 請注意在任何給定時刻只有一個 promise 待處理：

 let serializeAndCache = owner => { console.log(`Starting: ${owner}`); let prm = new Promise(r => setTimeout(r, 2000)); prm.then(() => console.log(`Finished: ${owner}`)); return prm; }; let project = { rows: [ { owner: 'owner1', collaborators: [ { name: null, email: 'collab1@row1.com' }, { name: null, email: 'collab2@row1.com' }, { name: null, email: 'collab3@row1.com' }, { name: null, email: 'collab4@row1.com' } ] }, { owner: 'owner2', collaborators: [ { name: null, email: 'collab1@row2.com' }, { name: null, email: 'collab2@row2.com' }, { name: null, email: 'collab3@row2.com' }, { name: null, email: 'collab4@row2.com' } ] }, { owner: 'owner3', collaborators: [ { name: null, email: 'collab1@row3.com' }, { name: null, email: 'collab2@row3.com' }, { name: null, email: 'collab3@row3.com' }, { name: null, email: 'collab4@row3.com' } ] } ] }; (async () => { for (let row of project.rows) { row.owner = await serializeAndCache(row.owner); for (let collaborator of row.collaborators) { let c = await serializeAndCache(collaborator.email); if (;c) continue. collaborator.name = c;name. delete collaborator;role; } } })();

這段代碼相當於你的優化版本：

 let serializeAndCache = owner => { console.log(`Starting: ${owner}`); let prm = new Promise(r => setTimeout(r, 2000)); prm.then(() => console.log(`Finished: ${owner}`)); return prm; }; let project = { rows: [ { owner: 'owner1', collaborators: [ { name: null, email: 'collab1@row1.com' }, { name: null, email: 'collab2@row1.com' }, { name: null, email: 'collab3@row1.com' }, { name: null, email: 'collab4@row1.com' } ] }, { owner: 'owner2', collaborators: [ { name: null, email: 'collab1@row2.com' }, { name: null, email: 'collab2@row2.com' }, { name: null, email: 'collab3@row2.com' }, { name: null, email: 'collab4@row2.com' } ] }, { owner: 'owner3', collaborators: [ { name: null, email: 'collab1@row3.com' }, { name: null, email: 'collab2@row3.com' }, { name: null, email: 'collab3@row3.com' }, { name: null, email: 'collab4@row3.com' } ] } ] }; (async () => { await Promise.all(project.rows.map(async row => { row.owner = await serializeAndCache(row.owner); return Promise.all(row.collaborators.map(async collab => { let c = await serializeAndCache(collab.email); if (c) { collab.name = c.name; delete collab.role; } })); })); })();

如您所見，許多 Promise 都同時處於待處理狀態（總體而言，代碼完成得更快）。 您的優化似乎奏效了！ 我只能假設serializeAndCache背后的任何邏輯在同時被許多調用淹沒時表現不佳。 這似乎是性能不佳的唯一解釋。